chore(make): default PATH_TO_CHECK to api/

chore(api): bootstrap ty type-checking
- Add api/ty.toml exclusions for incremental rollout - Wire ty into make type-check (with basedpyright + mypy) - Update style workflow to run make type-check
2026-01-29 02:43:32 +08:00 · 2026-01-29 02:41:26 +08:00
441 changed files with 7724 additions and 42125 deletions
@@ -480,4 +480,4 @@ const useButtonState = () => {
 ### Related Skills

 - `frontend-testing` - For testing refactored components
- `web/docs/test.md` - Testing specification
+- `web/testing/testing.md` - Testing specification
@@ -7,7 +7,7 @@ description: Generate Vitest + React Testing Library tests for Dify frontend com

 This skill enables Claude to generate high-quality, comprehensive frontend tests for the Dify project following established conventions and best practices.

-> **⚠️ Authoritative Source**: This skill is derived from `web/docs/test.md`. Use Vitest mock/timer APIs (`vi.*`).
+> **⚠️ Authoritative Source**: This skill is derived from `web/testing/testing.md`. Use Vitest mock/timer APIs (`vi.*`).

 ## When to Apply This Skill

@@ -309,7 +309,7 @@ For more detailed information, refer to:

 ### Primary Specification (MUST follow)

- **`web/docs/test.md`** - The canonical testing specification. This skill is derived from this document.
+- **`web/testing/testing.md`** - The canonical testing specification. This skill is derived from this document.

 ### Reference Examples in Codebase

@@ -4,7 +4,7 @@ This guide defines the workflow for generating tests, especially for complex com

 ## Scope Clarification

-This guide addresses **multi-file workflow** (how to process multiple test files). For coverage requirements within a single test file, see `web/docs/test.md` § Coverage Goals.
+This guide addresses **multi-file workflow** (how to process multiple test files). For coverage requirements within a single test file, see `web/testing/testing.md` § Coverage Goals.

 | Scope | Rule |
 |-------|------|
@@ -9,9 +9,6 @@
 # CODEOWNERS file
 /.github/CODEOWNERS @laipz8200 @crazywoola

-# Agents
-/.agents/skills/ @hyoban
-
 # Docs
 /docs/ @crazywoola

@@ -72,7 +72,6 @@ jobs:
          OPENDAL_FS_ROOT: /tmp/dify-storage
        run: |
          uv run --project api pytest \
-            -n auto \
            --timeout "${PYTEST_TIMEOUT:-180}" \
            api/tests/integration_tests/workflow \
            api/tests/integration_tests/tools \
@@ -7,7 +7,7 @@ Dify is an open-source platform for developing LLM applications with an intuitiv
 The codebase is split into:

 - **Backend API** (`/api`): Python Flask application organized with Domain-Driven Design
- **Frontend Web** (`/web`): Next.js application using TypeScript and React
+- **Frontend Web** (`/web`): Next.js 15 application using TypeScript and React 19
 - **Docker deployment** (`/docker`): Containerized deployment configurations

 ## Backend Workflow
@@ -18,7 +18,36 @@ The codebase is split into:

 ## Frontend Workflow

- Read `web/AGENTS.md` for details
+```bash
+cd web
+pnpm lint:fix
+pnpm type-check:tsgo
+pnpm test
+```
+
+### Frontend Linting
+
+ESLint is used for frontend code quality. Available commands:
+
+```bash
+# Lint all files (report only)
+pnpm lint
+
+# Lint and auto-fix issues
+pnpm lint:fix
+
+# Lint specific files or directories
+pnpm lint:fix app/components/base/button/
+pnpm lint:fix app/components/base/button/index.tsx
+
+# Lint quietly (errors only, no warnings)
+pnpm lint:quiet
+
+# Check code complexity
+pnpm lint:complexity
+```
+
+**Important**: Always run `pnpm lint:fix` before committing. The pre-commit hook runs `lint-staged` which only lints staged files.

 ## Testing & Quality Practices

@@ -77,7 +77,7 @@ How we prioritize:

 For setting up the frontend service, please refer to our comprehensive [guide](https://github.com/langgenius/dify/blob/main/web/README.md) in the `web/README.md` file. This document provides detailed instructions to help you set up the frontend environment properly.

-**Testing**: All React components must have comprehensive test coverage. See [web/docs/test.md](https://github.com/langgenius/dify/blob/main/web/docs/test.md) for the canonical frontend testing guidelines and follow every requirement described there.
+**Testing**: All React components must have comprehensive test coverage. See [web/testing/testing.md](https://github.com/langgenius/dify/blob/main/web/testing/testing.md) for the canonical frontend testing guidelines and follow every requirement described there.

 #### Backend

@@ -3,6 +3,7 @@ DOCKER_REGISTRY=langgenius
 WEB_IMAGE=$(DOCKER_REGISTRY)/dify-web
 API_IMAGE=$(DOCKER_REGISTRY)/dify-api
 VERSION=latest
+PATH_TO_CHECK ?= api/

 # Default target - show help
 .DEFAULT_GOAL := help
@@ -80,7 +81,7 @@ test:
 		echo "Target: $(TARGET_TESTS)"; \
 		uv run --project api --dev pytest $(TARGET_TESTS); \
 	else \
-		PYTEST_XDIST_ARGS="-n auto" uv run --project api --dev dev/pytest/pytest_unit_tests.sh; \
+		uv run --project api --dev dev/pytest/pytest_unit_tests.sh; \
 	fi
 	@echo "✅ Tests complete"

@@ -617,7 +617,6 @@ PLUGIN_DAEMON_URL=http://127.0.0.1:5002
 PLUGIN_REMOTE_INSTALL_PORT=5003
 PLUGIN_REMOTE_INSTALL_HOST=localhost
 PLUGIN_MAX_PACKAGE_SIZE=15728640
-PLUGIN_MODEL_SCHEMA_CACHE_TTL=3600
 INNER_API_KEY_FOR_PLUGIN=QaHbTe77CtuXmsfyhR7+vRjI/+XbV1AaFy691iy+kGDv2Jvy0/eAh8Y1

 # Marketplace configuration
@@ -717,3 +716,4 @@ SANDBOX_EXPIRED_RECORDS_CLEAN_GRACEFUL_PERIOD=21
 SANDBOX_EXPIRED_RECORDS_CLEAN_BATCH_SIZE=1000
 SANDBOX_EXPIRED_RECORDS_RETENTION_DAYS=30
 SANDBOX_EXPIRED_RECORDS_CLEAN_TASK_LOCK_TTL=90000
+
@@ -227,9 +227,6 @@ ignore_imports =
    core.workflow.nodes.knowledge_index.entities -> core.rag.retrieval.retrieval_methods
    core.workflow.nodes.knowledge_index.knowledge_index_node -> core.rag.retrieval.retrieval_methods
    core.workflow.nodes.knowledge_index.knowledge_index_node -> models.dataset
-    core.workflow.nodes.knowledge_index.knowledge_index_node -> services.summary_index_service
-    core.workflow.nodes.knowledge_index.knowledge_index_node -> tasks.generate_summary_index_task
-    core.workflow.nodes.knowledge_index.knowledge_index_node -> core.rag.index_processor.processor.paragraph_index_processor
    core.workflow.nodes.knowledge_retrieval.knowledge_retrieval_node -> core.rag.retrieval.retrieval_methods
    core.workflow.nodes.llm.node -> models.dataset
    core.workflow.nodes.agent.agent_node -> core.tools.utils.message_transformer
@@ -303,58 +300,6 @@ ignore_imports =
    core.workflow.nodes.agent.agent_node -> services
    core.workflow.nodes.tool.tool_node -> services

-[importlinter:contract:model-runtime-no-internal-imports]
-name = Model Runtime Internal Imports
-type = forbidden
-source_modules =
-    core.model_runtime
-forbidden_modules =
-    configs
-    controllers
-    extensions
-    models
-    services
-    tasks
-    core.agent
-    core.app
-    core.base
-    core.callback_handler
-    core.datasource
-    core.db
-    core.entities
-    core.errors
-    core.extension
-    core.external_data_tool
-    core.file
-    core.helper
-    core.hosting_configuration
-    core.indexing_runner
-    core.llm_generator
-    core.logging
-    core.mcp
-    core.memory
-    core.model_manager
-    core.moderation
-    core.ops
-    core.plugin
-    core.prompt
-    core.provider_manager
-    core.rag
-    core.repositories
-    core.schemas
-    core.tools
-    core.trigger
-    core.variables
-    core.workflow
-ignore_imports =
-    core.model_runtime.model_providers.__base.ai_model -> configs
-    core.model_runtime.model_providers.__base.ai_model -> extensions.ext_redis
-    core.model_runtime.model_providers.__base.large_language_model -> configs
-    core.model_runtime.model_providers.__base.text_embedding_model -> core.entities.embedding_type
-    core.model_runtime.model_providers.model_provider_factory -> configs
-    core.model_runtime.model_providers.model_provider_factory -> extensions.ext_redis
-    core.model_runtime.model_providers.model_provider_factory -> models.provider_ids
-
 [importlinter:contract:rsc]
 name = RSC
 type = layers
@@ -53,7 +53,6 @@ select = [
    "S301", # suspicious-pickle-usage, disallow use of `pickle` and its wrappers.
    "S302", # suspicious-marshal-usage, disallow use of `marshal` module
    "S311", # suspicious-non-cryptographic-random-usage,
-    "TID",   # flake8-tidy-imports

 ]

@@ -89,7 +88,6 @@ ignore = [
    "SIM113",  # enumerate-for-loop
    "SIM117",  # multiple-with-statements
    "SIM210",  # if-expr-with-true-false
-    "TID252",  # allow relative imports from parent modules
 ]

 [lint.per-file-ignores]
@@ -106,25 +104,15 @@ ignore = [
    "N803", # invalid-argument-name
 ]
 "tests/*" = [
-    "F811",  # redefined-while-unused
-    "T201",  # allow print in tests,
-    "S110",  # allow ignoring exceptions in tests code (currently)
-    "PT019", # @patch-injected params look like unused fixtures
+    "F811", # redefined-while-unused
+    "T201", # allow print in tests,
+    "S110", # allow ignoring exceptions in tests code (currently)
+
 ]
-"controllers/console/explore/trial.py" = ["TID251"]
-"controllers/console/human_input_form.py" = ["TID251"]
-"controllers/web/human_input_form.py" = ["TID251"]

 [lint.pyflakes]
 allowed-unused-imports = [
+    "_pytest.monkeypatch",
    "tests.integration_tests",
    "tests.unit_tests",
 ]
-
-[lint.flake8-tidy-imports]
-
-[lint.flake8-tidy-imports.banned-api."flask_restx.reqparse"]
-msg = "Use Pydantic payload/query models instead of reqparse."
-
-[lint.flake8-tidy-imports.banned-api."flask_restx.reqparse.RequestParser"]
-msg = "Use Pydantic payload/query models instead of reqparse."
@@ -122,8 +122,7 @@ These commands assume you start from the repository root.

   ```bash
   cd api
-   # Note: enterprise_telemetry queue is only used in Enterprise Edition
-   uv run celery -A app.celery worker -P threads -c 2 --loglevel INFO -Q dataset,priority_dataset,priority_pipeline,pipeline,mail,ops_trace,app_deletion,plugin,workflow_storage,conversation,workflow,schedule_poller,schedule_executor,triggered_workflow_dispatcher,trigger_refresh_executor,retention,enterprise_telemetry
+   uv run celery -A app.celery worker -P threads -c 2 --loglevel INFO -Q dataset,priority_dataset,priority_pipeline,pipeline,mail,ops_trace,app_deletion,plugin,workflow_storage,conversation,workflow,schedule_poller,schedule_executor,triggered_workflow_dispatcher,trigger_refresh_executor,retention
   ```

 1. Optional: start Celery Beat (scheduled tasks, in a new terminal).
@@ -1,12 +1,4 @@
-from __future__ import annotations
-
 import sys
-from typing import TYPE_CHECKING, cast
-
-if TYPE_CHECKING:
-    from celery import Celery
-
-    celery: Celery


 def is_db_command() -> bool:
@@ -31,7 +23,7 @@ else:
    from app_factory import create_app

    app = create_app()
-    celery = cast("Celery", app.extensions["celery"])
+    celery = app.extensions["celery"]

 if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5001)
@@ -1,45 +1,16 @@
 import logging
 import time

-from flask import request
 from opentelemetry.trace import get_current_span
 from opentelemetry.trace.span import INVALID_SPAN_ID, INVALID_TRACE_ID

 from configs import dify_config
 from contexts.wrapper import RecyclableContextVar
-from controllers.console.error import UnauthorizedAndForceLogout
 from core.logging.context import init_request_context
 from dify_app import DifyApp
-from services.enterprise.enterprise_service import EnterpriseService
-from services.feature_service import LicenseStatus

 logger = logging.getLogger(__name__)

-# Console bootstrap APIs exempt from license check.
-# Defined at module level to avoid per-request tuple construction.
-# - system-features: license status for expiry UI (GlobalPublicStoreProvider)
-# - setup: install/setup status check (AppInitializer)
-# - init: init password validation for fresh install (InitPasswordPopup)
-# - login: auto-login after setup completion (InstallForm)
-# - features: billing/plan features (ProviderContextProvider)
-# - account/profile: login check + user profile (AppContextProvider, useIsLogin)
-# - workspaces/current: workspace + model providers (AppContextProvider)
-# - version: version check (AppContextProvider)
-# - activate/check: invitation link validation (signin page)
-# Without these exemptions, the signin page triggers location.reload()
-# on unauthorized_and_force_logout, causing an infinite loop.
-_CONSOLE_EXEMPT_PREFIXES = (
-    "/console/api/system-features",
-    "/console/api/setup",
-    "/console/api/init",
-    "/console/api/login",
-    "/console/api/features",
-    "/console/api/account/profile",
-    "/console/api/workspaces/current",
-    "/console/api/version",
-    "/console/api/activate/check",
-)
-

 # ----------------------------
 # Application Factory Function
@@ -60,39 +31,6 @@ def create_flask_app_with_configs() -> DifyApp:
        init_request_context()
        RecyclableContextVar.increment_thread_recycles()

-        # Enterprise license validation for API endpoints (both console and webapp)
-        # When license expires, block all API access except bootstrap endpoints needed
-        # for the frontend to load the license expiration page without infinite reloads.
-        if dify_config.ENTERPRISE_ENABLED:
-            is_console_api = request.path.startswith("/console/api/")
-            is_webapp_api = request.path.startswith("/api/") and not is_console_api
-
-            if is_console_api or is_webapp_api:
-                if is_console_api:
-                    is_exempt = any(request.path.startswith(p) for p in _CONSOLE_EXEMPT_PREFIXES)
-                else:  # webapp API
-                    is_exempt = request.path.startswith("/api/system-features")
-
-                if not is_exempt:
-                    try:
-                        # Check license status with caching (10 min TTL)
-                        license_status = EnterpriseService.get_cached_license_status()
-                        if license_status in (LicenseStatus.INACTIVE, LicenseStatus.EXPIRED, LicenseStatus.LOST):
-                            # Cookie clearing is handled by register_external_error_handlers
-                            # in libs/external_api.py which detects the error code and calls
-                            # build_force_logout_cookie_headers(). Frontend then checks
-                            # code === 'unauthorized_and_force_logout' and calls location.reload().
-                            raise UnauthorizedAndForceLogout(
-                                f"Enterprise license is {license_status}. Please contact your administrator."
-                            )
-                    except UnauthorizedAndForceLogout:
-                        raise
-                    except Exception:
-                        # If license check fails, log but don't block the request.
-                        # This prevents service disruption if enterprise API is temporarily
-                        # unavailable.
-                        logger.exception("Failed to check enterprise license status")
-
    # add after request hook for injecting trace headers from OpenTelemetry span context
    # Only adds headers when OTEL is enabled and has valid context
    @dify_app.after_request
@@ -143,7 +81,6 @@ def initialize_extensions(app: DifyApp):
        ext_commands,
        ext_compress,
        ext_database,
-        ext_enterprise_telemetry,
        ext_fastopenapi,
        ext_forward_refs,
        ext_hosting_provider,
@@ -194,7 +131,6 @@ def initialize_extensions(app: DifyApp):
        ext_commands,
        ext_fastopenapi,
        ext_otel,
-        ext_enterprise_telemetry,
        ext_request_logging,
        ext_session_factory,
    ]
@@ -213,7 +149,7 @@ def initialize_extensions(app: DifyApp):
            logger.info("Loaded %s (%s ms)", short_name, round((end_time - start_time) * 1000, 2))


-def create_migrations_app() -> DifyApp:
+def create_migrations_app():
    app = create_flask_app_with_configs()
    from extensions import ext_database, ext_migrate

@@ -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")

@@ -1464,58 +1450,54 @@ def clear_orphaned_file_records(force: bool):
        all_ids_in_tables = []
        for ids_table in ids_tables:
            query = ""
-            match ids_table["type"]:
-                case "uuid":
-                    click.echo(
-                        click.style(
-                            f"- Listing file ids in column {ids_table['column']} in table {ids_table['table']}",
-                            fg="white",
-                        )
+            if ids_table["type"] == "uuid":
+                click.echo(
+                    click.style(
+                        f"- Listing file ids in column {ids_table['column']} in table {ids_table['table']}", fg="white"
                    )
-                    c = ids_table["column"]
-                    query = f"SELECT {c} FROM {ids_table['table']} WHERE {c} IS NOT NULL"
-                    with db.engine.begin() as conn:
-                        rs = conn.execute(sa.text(query))
-                    for i in rs:
-                        all_ids_in_tables.append({"table": ids_table["table"], "id": str(i[0])})
-                case "text":
-                    t = ids_table["table"]
-                    click.echo(
-                        click.style(
-                            f"- Listing file-id-like strings in column {ids_table['column']} in table {t}",
-                            fg="white",
-                        )
+                )
+                query = (
+                    f"SELECT {ids_table['column']} FROM {ids_table['table']} WHERE {ids_table['column']} IS NOT NULL"
+                )
+                with db.engine.begin() as conn:
+                    rs = conn.execute(sa.text(query))
+                for i in rs:
+                    all_ids_in_tables.append({"table": ids_table["table"], "id": str(i[0])})
+            elif ids_table["type"] == "text":
+                click.echo(
+                    click.style(
+                        f"- Listing file-id-like strings in column {ids_table['column']} in table {ids_table['table']}",
+                        fg="white",
                    )
-                    query = (
-                        f"SELECT regexp_matches({ids_table['column']}, '{guid_regexp}', 'g') AS extracted_id "
-                        f"FROM {ids_table['table']}"
+                )
+                query = (
+                    f"SELECT regexp_matches({ids_table['column']}, '{guid_regexp}', 'g') AS extracted_id "
+                    f"FROM {ids_table['table']}"
+                )
+                with db.engine.begin() as conn:
+                    rs = conn.execute(sa.text(query))
+                for i in rs:
+                    for j in i[0]:
+                        all_ids_in_tables.append({"table": ids_table["table"], "id": j})
+            elif ids_table["type"] == "json":
+                click.echo(
+                    click.style(
+                        (
+                            f"- Listing file-id-like JSON string in column {ids_table['column']} "
+                            f"in table {ids_table['table']}"
+                        ),
+                        fg="white",
                    )
-                    with db.engine.begin() as conn:
-                        rs = conn.execute(sa.text(query))
-                    for i in rs:
-                        for j in i[0]:
-                            all_ids_in_tables.append({"table": ids_table["table"], "id": j})
-                case "json":
-                    click.echo(
-                        click.style(
-                            (
-                                f"- Listing file-id-like JSON string in column {ids_table['column']} "
-                                f"in table {ids_table['table']}"
-                            ),
-                            fg="white",
-                        )
-                    )
-                    query = (
-                        f"SELECT regexp_matches({ids_table['column']}::text, '{guid_regexp}', 'g') AS extracted_id "
-                        f"FROM {ids_table['table']}"
-                    )
-                    with db.engine.begin() as conn:
-                        rs = conn.execute(sa.text(query))
-                    for i in rs:
-                        for j in i[0]:
-                            all_ids_in_tables.append({"table": ids_table["table"], "id": j})
-                case _:
-                    pass
+                )
+                query = (
+                    f"SELECT regexp_matches({ids_table['column']}::text, '{guid_regexp}', 'g') AS extracted_id "
+                    f"FROM {ids_table['table']}"
+                )
+                with db.engine.begin() as conn:
+                    rs = conn.execute(sa.text(query))
+                for i in rs:
+                    for j in i[0]:
+                        all_ids_in_tables.append({"table": ids_table["table"], "id": j})
        click.echo(click.style(f"Found {len(all_ids_in_tables)} file ids in tables.", fg="white"))

    except Exception as e:
@@ -1755,18 +1737,59 @@ def file_usage(
                if src_filter != src:
                    continue

-        match ids_table["type"]:
-            case "uuid":
-                # Direct UUID match
-                query = (
-                    f"SELECT {ids_table['pk_column']}, {ids_table['column']} "
-                    f"FROM {ids_table['table']} WHERE {ids_table['column']} IS NOT NULL"
-                )
-                with db.engine.begin() as conn:
-                    rs = conn.execute(sa.text(query))
-                    for row in rs:
-                        record_id = str(row[0])
-                        ref_file_id = str(row[1])
+        if ids_table["type"] == "uuid":
+            # Direct UUID match
+            query = (
+                f"SELECT {ids_table['pk_column']}, {ids_table['column']} "
+                f"FROM {ids_table['table']} WHERE {ids_table['column']} IS NOT NULL"
+            )
+            with db.engine.begin() as conn:
+                rs = conn.execute(sa.text(query))
+                for row in rs:
+                    record_id = str(row[0])
+                    ref_file_id = str(row[1])
+                    if ref_file_id not in file_key_map:
+                        continue
+                    storage_key = file_key_map[ref_file_id]
+
+                    # Apply filters
+                    if file_id and ref_file_id != file_id:
+                        continue
+                    if key and not storage_key.endswith(key):
+                        continue
+
+                    # Only collect items within the requested page range
+                    if offset <= total_count < offset + limit:
+                        paginated_usages.append(
+                            {
+                                "src": f"{ids_table['table']}.{ids_table['column']}",
+                                "record_id": record_id,
+                                "file_id": ref_file_id,
+                                "key": storage_key,
+                            }
+                        )
+                    total_count += 1
+
+        elif ids_table["type"] in ("text", "json"):
+            # Extract UUIDs from text/json content
+            column_cast = f"{ids_table['column']}::text" if ids_table["type"] == "json" else ids_table["column"]
+            query = (
+                f"SELECT {ids_table['pk_column']}, {column_cast} "
+                f"FROM {ids_table['table']} WHERE {ids_table['column']} IS NOT NULL"
+            )
+            with db.engine.begin() as conn:
+                rs = conn.execute(sa.text(query))
+                for row in rs:
+                    record_id = str(row[0])
+                    content = str(row[1])
+
+                    # Find all UUIDs in the content
+                    import re
+
+                    uuid_pattern = re.compile(guid_regexp, re.IGNORECASE)
+                    matches = uuid_pattern.findall(content)
+
+                    for ref_file_id in matches:
                        if ref_file_id not in file_key_map:
                            continue
                        storage_key = file_key_map[ref_file_id]
@@ -1789,50 +1812,6 @@ def file_usage(
                            )
                        total_count += 1

-            case "text" | "json":
-                # Extract UUIDs from text/json content
-                column_cast = f"{ids_table['column']}::text" if ids_table["type"] == "json" else ids_table["column"]
-                query = (
-                    f"SELECT {ids_table['pk_column']}, {column_cast} "
-                    f"FROM {ids_table['table']} WHERE {ids_table['column']} IS NOT NULL"
-                )
-                with db.engine.begin() as conn:
-                    rs = conn.execute(sa.text(query))
-                    for row in rs:
-                        record_id = str(row[0])
-                        content = str(row[1])
-
-                        # Find all UUIDs in the content
-                        import re
-
-                        uuid_pattern = re.compile(guid_regexp, re.IGNORECASE)
-                        matches = uuid_pattern.findall(content)
-
-                        for ref_file_id in matches:
-                            if ref_file_id not in file_key_map:
-                                continue
-                            storage_key = file_key_map[ref_file_id]
-
-                            # Apply filters
-                            if file_id and ref_file_id != file_id:
-                                continue
-                            if key and not storage_key.endswith(key):
-                                continue
-
-                            # Only collect items within the requested page range
-                            if offset <= total_count < offset + limit:
-                                paginated_usages.append(
-                                    {
-                                        "src": f"{ids_table['table']}.{ids_table['column']}",
-                                        "record_id": record_id,
-                                        "file_id": ref_file_id,
-                                        "key": storage_key,
-                                    }
-                                )
-                            total_count += 1
-            case _:
-                pass
-
    # Output results
    if output_json:
        result = {
@@ -8,7 +8,7 @@ from pydantic_settings import BaseSettings, PydanticBaseSettingsSource, Settings
 from libs.file_utils import search_file_upwards

 from .deploy import DeploymentConfig
-from .enterprise import EnterpriseFeatureConfig, EnterpriseTelemetryConfig
+from .enterprise import EnterpriseFeatureConfig
 from .extra import ExtraServiceConfig
 from .feature import FeatureConfig
 from .middleware import MiddlewareConfig
@@ -73,8 +73,6 @@ class DifyConfig(
    # Enterprise feature configs
    # **Before using, please contact business@dify.ai by email to inquire about licensing matters.**
    EnterpriseFeatureConfig,
-    # Enterprise telemetry configs
-    EnterpriseTelemetryConfig,
 ):
    model_config = SettingsConfigDict(
        # read from dotenv format config file
@@ -18,49 +18,3 @@ class EnterpriseFeatureConfig(BaseSettings):
        description="Allow customization of the enterprise logo.",
        default=False,
    )
-
-
-class EnterpriseTelemetryConfig(BaseSettings):
-    """
-    Configuration for enterprise telemetry.
-    """
-
-    ENTERPRISE_TELEMETRY_ENABLED: bool = Field(
-        description="Enable enterprise telemetry collection (also requires ENTERPRISE_ENABLED=true).",
-        default=False,
-    )
-
-    ENTERPRISE_OTLP_ENDPOINT: str = Field(
-        description="Enterprise OTEL collector endpoint.",
-        default="",
-    )
-
-    ENTERPRISE_OTLP_HEADERS: str = Field(
-        description="Auth headers for OTLP export (key=value,key2=value2).",
-        default="",
-    )
-
-    ENTERPRISE_OTLP_PROTOCOL: str = Field(
-        description="OTLP protocol: 'http' or 'grpc' (default: http).",
-        default="http",
-    )
-
-    ENTERPRISE_OTLP_API_KEY: str = Field(
-        description="Bearer token for enterprise OTLP export authentication.",
-        default="",
-    )
-
-    ENTERPRISE_INCLUDE_CONTENT: bool = Field(
-        description="Include input/output content in traces (privacy toggle).",
-        default=True,
-    )
-
-    ENTERPRISE_SERVICE_NAME: str = Field(
-        description="Service name for OTEL resource.",
-        default="dify",
-    )
-
-    ENTERPRISE_OTEL_SAMPLING_RATE: float = Field(
-        description="Sampling rate for enterprise traces (0.0 to 1.0, default 1.0 = 100%).",
-        default=1.0,
-    )
@@ -243,11 +243,6 @@ class PluginConfig(BaseSettings):
        default=15728640 * 12,
    )

-    PLUGIN_MODEL_SCHEMA_CACHE_TTL: PositiveInt = Field(
-        description="TTL in seconds for caching plugin model schemas in Redis",
-        default=60 * 60,
-    )
-

 class MarketplaceConfig(BaseSettings):
    """
@@ -6,6 +6,7 @@ from contexts.wrapper import RecyclableContextVar

 if TYPE_CHECKING:
    from core.datasource.__base.datasource_provider import DatasourcePluginProviderController
+    from core.model_runtime.entities.model_entities import AIModelEntity
    from core.plugin.entities.plugin_daemon import PluginModelProviderEntity
    from core.tools.plugin_tool.provider import PluginToolProviderController
    from core.trigger.provider import PluginTriggerProviderController
@@ -28,6 +29,12 @@ plugin_model_providers_lock: RecyclableContextVar[Lock] = RecyclableContextVar(
    ContextVar("plugin_model_providers_lock")
 )

+plugin_model_schema_lock: RecyclableContextVar[Lock] = RecyclableContextVar(ContextVar("plugin_model_schema_lock"))
+
+plugin_model_schemas: RecyclableContextVar[dict[str, "AIModelEntity"]] = RecyclableContextVar(
+    ContextVar("plugin_model_schemas")
+)
+
 datasource_plugin_providers: RecyclableContextVar[dict[str, "DatasourcePluginProviderController"]] = (
    RecyclableContextVar(ContextVar("datasource_plugin_providers"))
 )
@@ -243,13 +243,15 @@ class InsertExploreBannerApi(Resource):
    def post(self):
        payload = InsertExploreBannerPayload.model_validate(console_ns.payload)

+        content = {
+            "category": payload.category,
+            "title": payload.title,
+            "description": payload.description,
+            "img-src": payload.img_src,
+        }
+
        banner = ExporleBanner(
-            content={
-                "category": payload.category,
-                "title": payload.title,
-                "description": payload.description,
-                "img-src": payload.img_src,
-            },
+            content=content,
            link=payload.link,
            sort=payload.sort,
            language=payload.language,
@@ -1,11 +1,10 @@
 from typing import Any, Literal

 from flask import abort, make_response, request
-from flask_restx import Resource
-from pydantic import BaseModel, Field, TypeAdapter, field_validator
+from flask_restx import Resource, fields, marshal, marshal_with
+from pydantic import BaseModel, Field, field_validator

 from controllers.common.errors import NoFileUploadedError, TooManyFilesError
-from controllers.common.schema import register_schema_models
 from controllers.console import console_ns
 from controllers.console.wraps import (
    account_initialization_required,
@@ -17,11 +16,9 @@ from controllers.console.wraps import (
 )
 from extensions.ext_redis import redis_client
 from fields.annotation_fields import (
-    Annotation,
-    AnnotationExportList,
-    AnnotationHitHistory,
-    AnnotationHitHistoryList,
-    AnnotationList,
+    annotation_fields,
+    annotation_hit_history_fields,
+    build_annotation_model,
 )
 from libs.helper import uuid_value
 from libs.login import login_required
@@ -92,14 +89,6 @@ reg(CreateAnnotationPayload)
 reg(UpdateAnnotationPayload)
 reg(AnnotationReplyStatusQuery)
 reg(AnnotationFilePayload)
-register_schema_models(
-    console_ns,
-    Annotation,
-    AnnotationList,
-    AnnotationExportList,
-    AnnotationHitHistory,
-    AnnotationHitHistoryList,
-)


@console_ns.route("/apps/<uuid:app_id>/annotation-reply/<string:action>")
@@ -118,11 +107,10 @@ class AnnotationReplyActionApi(Resource):
    def post(self, app_id, action: Literal["enable", "disable"]):
        app_id = str(app_id)
        args = AnnotationReplyPayload.model_validate(console_ns.payload)
-        match action:
-            case "enable":
-                result = AppAnnotationService.enable_app_annotation(args.model_dump(), app_id)
-            case "disable":
-                result = AppAnnotationService.disable_app_annotation(app_id)
+        if action == "enable":
+            result = AppAnnotationService.enable_app_annotation(args.model_dump(), app_id)
+        elif action == "disable":
+            result = AppAnnotationService.disable_app_annotation(app_id)
        return result, 200


@@ -213,33 +201,33 @@ class AnnotationApi(Resource):

        app_id = str(app_id)
        annotation_list, total = AppAnnotationService.get_annotation_list_by_app_id(app_id, page, limit, keyword)
-        annotation_models = TypeAdapter(list[Annotation]).validate_python(annotation_list, from_attributes=True)
-        response = AnnotationList(
-            data=annotation_models,
-            has_more=len(annotation_list) == limit,
-            limit=limit,
-            total=total,
-            page=page,
-        )
-        return response.model_dump(mode="json"), 200
+        response = {
+            "data": marshal(annotation_list, annotation_fields),
+            "has_more": len(annotation_list) == limit,
+            "limit": limit,
+            "total": total,
+            "page": page,
+        }
+        return response, 200

    @console_ns.doc("create_annotation")
    @console_ns.doc(description="Create a new annotation for an app")
    @console_ns.doc(params={"app_id": "Application ID"})
    @console_ns.expect(console_ns.models[CreateAnnotationPayload.__name__])
-    @console_ns.response(201, "Annotation created successfully", console_ns.models[Annotation.__name__])
+    @console_ns.response(201, "Annotation created successfully", build_annotation_model(console_ns))
    @console_ns.response(403, "Insufficient permissions")
    @setup_required
    @login_required
    @account_initialization_required
    @cloud_edition_billing_resource_check("annotation")
+    @marshal_with(annotation_fields)
    @edit_permission_required
    def post(self, app_id):
        app_id = str(app_id)
        args = CreateAnnotationPayload.model_validate(console_ns.payload)
        data = args.model_dump(exclude_none=True)
        annotation = AppAnnotationService.up_insert_app_annotation_from_message(data, app_id)
-        return Annotation.model_validate(annotation, from_attributes=True).model_dump(mode="json")
+        return annotation

    @setup_required
    @login_required
@@ -276,7 +264,7 @@ class AnnotationExportApi(Resource):
    @console_ns.response(
        200,
        "Annotations exported successfully",
-        console_ns.models[AnnotationExportList.__name__],
+        console_ns.model("AnnotationList", {"data": fields.List(fields.Nested(build_annotation_model(console_ns)))}),
    )
    @console_ns.response(403, "Insufficient permissions")
    @setup_required
@@ -286,8 +274,7 @@ class AnnotationExportApi(Resource):
    def get(self, app_id):
        app_id = str(app_id)
        annotation_list = AppAnnotationService.export_annotation_list_by_app_id(app_id)
-        annotation_models = TypeAdapter(list[Annotation]).validate_python(annotation_list, from_attributes=True)
-        response_data = AnnotationExportList(data=annotation_models).model_dump(mode="json")
+        response_data = {"data": marshal(annotation_list, annotation_fields)}

        # Create response with secure headers for CSV export
        response = make_response(response_data, 200)
@@ -302,7 +289,7 @@ class AnnotationUpdateDeleteApi(Resource):
    @console_ns.doc("update_delete_annotation")
    @console_ns.doc(description="Update or delete an annotation")
    @console_ns.doc(params={"app_id": "Application ID", "annotation_id": "Annotation ID"})
-    @console_ns.response(200, "Annotation updated successfully", console_ns.models[Annotation.__name__])
+    @console_ns.response(200, "Annotation updated successfully", build_annotation_model(console_ns))
    @console_ns.response(204, "Annotation deleted successfully")
    @console_ns.response(403, "Insufficient permissions")
    @console_ns.expect(console_ns.models[UpdateAnnotationPayload.__name__])
@@ -311,6 +298,7 @@ class AnnotationUpdateDeleteApi(Resource):
    @account_initialization_required
    @cloud_edition_billing_resource_check("annotation")
    @edit_permission_required
+    @marshal_with(annotation_fields)
    def post(self, app_id, annotation_id):
        app_id = str(app_id)
        annotation_id = str(annotation_id)
@@ -318,7 +306,7 @@ class AnnotationUpdateDeleteApi(Resource):
        annotation = AppAnnotationService.update_app_annotation_directly(
            args.model_dump(exclude_none=True), app_id, annotation_id
        )
-        return Annotation.model_validate(annotation, from_attributes=True).model_dump(mode="json")
+        return annotation

    @setup_required
    @login_required
@@ -426,7 +414,14 @@ class AnnotationHitHistoryListApi(Resource):
    @console_ns.response(
        200,
        "Hit histories retrieved successfully",
-        console_ns.models[AnnotationHitHistoryList.__name__],
+        console_ns.model(
+            "AnnotationHitHistoryList",
+            {
+                "data": fields.List(
+                    fields.Nested(console_ns.model("AnnotationHitHistoryItem", annotation_hit_history_fields))
+                )
+            },
+        ),
    )
    @console_ns.response(403, "Insufficient permissions")
    @setup_required
@@ -441,14 +436,11 @@ class AnnotationHitHistoryListApi(Resource):
        annotation_hit_history_list, total = AppAnnotationService.get_annotation_hit_histories(
            app_id, annotation_id, page, limit
        )
-        history_models = TypeAdapter(list[AnnotationHitHistory]).validate_python(
-            annotation_hit_history_list, from_attributes=True
-        )
-        response = AnnotationHitHistoryList(
-            data=history_models,
-            has_more=len(annotation_hit_history_list) == limit,
-            limit=limit,
-            total=total,
-            page=page,
-        )
-        return response.model_dump(mode="json")
+        response = {
+            "data": marshal(annotation_hit_history_list, annotation_hit_history_fields),
+            "has_more": len(annotation_hit_history_list) == limit,
+            "limit": limit,
+            "total": total,
+            "page": page,
+        }
+        return response
@@ -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)

@@ -6,7 +6,6 @@ from pydantic import BaseModel, Field
 from werkzeug.exceptions import InternalServerError

 import services
-from controllers.common.schema import register_schema_models
 from controllers.console import console_ns
 from controllers.console.app.error import (
    AppUnavailableError,
@@ -34,6 +33,7 @@ from services.errors.audio import (
 )

 logger = logging.getLogger(__name__)
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"


 class TextToSpeechPayload(BaseModel):
@@ -47,11 +47,13 @@ class TextToSpeechVoiceQuery(BaseModel):
    language: str = Field(..., description="Language code")


-class AudioTranscriptResponse(BaseModel):
-    text: str = Field(description="Transcribed text from audio")
-
-
-register_schema_models(console_ns, AudioTranscriptResponse, TextToSpeechPayload, TextToSpeechVoiceQuery)
+console_ns.schema_model(
+    TextToSpeechPayload.__name__, TextToSpeechPayload.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0)
+)
+console_ns.schema_model(
+    TextToSpeechVoiceQuery.__name__,
+    TextToSpeechVoiceQuery.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0),
+)


@console_ns.route("/apps/<uuid:app_id>/audio-to-text")
@@ -62,7 +64,7 @@ class ChatMessageAudioApi(Resource):
    @console_ns.response(
        200,
        "Audio transcription successful",
-        console_ns.models[AudioTranscriptResponse.__name__],
+        console_ns.model("AudioTranscriptResponse", {"text": fields.String(description="Transcribed text from audio")}),
    )
    @console_ns.response(400, "Bad request - No audio uploaded or unsupported type")
    @console_ns.response(413, "Audio file too large")
@@ -508,19 +508,16 @@ class ChatConversationApi(Resource):
                case "created_at" | "-created_at" | _:
                    query = query.where(Conversation.created_at <= end_datetime_utc)

-        match args.annotation_status:
-            case "annotated":
-                query = query.options(joinedload(Conversation.message_annotations)).join(  # type: ignore
-                    MessageAnnotation, MessageAnnotation.conversation_id == Conversation.id
-                )
-            case "not_annotated":
-                query = (
-                    query.outerjoin(MessageAnnotation, MessageAnnotation.conversation_id == Conversation.id)
-                    .group_by(Conversation.id)
-                    .having(func.count(MessageAnnotation.id) == 0)
-                )
-            case "all":
-                pass
+        if args.annotation_status == "annotated":
+            query = query.options(joinedload(Conversation.message_annotations)).join(  # type: ignore
+                MessageAnnotation, MessageAnnotation.conversation_id == Conversation.id
+            )
+        elif args.annotation_status == "not_annotated":
+            query = (
+                query.outerjoin(MessageAnnotation, MessageAnnotation.conversation_id == Conversation.id)
+                .group_by(Conversation.id)
+                .having(func.count(MessageAnnotation.id) == 0)
+            )

        if app_model.mode == AppMode.ADVANCED_CHAT:
            query = query.where(Conversation.invoke_from != InvokeFrom.DEBUGGER)
@@ -1,4 +1,5 @@
 from collections.abc import Sequence
+from typing import Any

 from flask_restx import Resource
 from pydantic import BaseModel, Field
@@ -11,12 +12,10 @@ from controllers.console.app.error import (
    ProviderQuotaExceededError,
 )
 from controllers.console.wraps import account_initialization_required, setup_required
-from core.app.app_config.entities import ModelConfig
 from core.errors.error import ModelCurrentlyNotSupportError, ProviderTokenNotInitError, QuotaExceededError
 from core.helper.code_executor.code_node_provider import CodeNodeProvider
 from core.helper.code_executor.javascript.javascript_code_provider import JavascriptCodeProvider
 from core.helper.code_executor.python3.python3_code_provider import Python3CodeProvider
-from core.llm_generator.entities import RuleCodeGeneratePayload, RuleGeneratePayload, RuleStructuredOutputPayload
 from core.llm_generator.llm_generator import LLMGenerator
 from core.model_runtime.errors.invoke import InvokeError
 from extensions.ext_database import db
@@ -27,15 +26,29 @@ from services.workflow_service import WorkflowService
 DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"


+class RuleGeneratePayload(BaseModel):
+    instruction: str = Field(..., description="Rule generation instruction")
+    model_config_data: dict[str, Any] = Field(..., alias="model_config", description="Model configuration")
+    no_variable: bool = Field(default=False, description="Whether to exclude variables")
+
+
+class RuleCodeGeneratePayload(RuleGeneratePayload):
+    code_language: str = Field(default="javascript", description="Programming language for code generation")
+
+
+class RuleStructuredOutputPayload(BaseModel):
+    instruction: str = Field(..., description="Structured output generation instruction")
+    model_config_data: dict[str, Any] = Field(..., alias="model_config", description="Model configuration")
+
+
 class InstructionGeneratePayload(BaseModel):
    flow_id: str = Field(..., description="Workflow/Flow ID")
    node_id: str = Field(default="", description="Node ID for workflow context")
    current: str = Field(default="", description="Current instruction text")
    language: str = Field(default="javascript", description="Programming language (javascript/python)")
    instruction: str = Field(..., description="Instruction for generation")
-    model_config_data: ModelConfig = Field(..., alias="model_config", description="Model configuration")
+    model_config_data: dict[str, Any] = Field(..., alias="model_config", description="Model configuration")
    ideal_output: str = Field(default="", description="Expected ideal output")
-    app_id: str | None = Field(default=None, description="App ID for prompt generation tracing")


 class InstructionTemplatePayload(BaseModel):
@@ -51,7 +64,6 @@ reg(RuleCodeGeneratePayload)
 reg(RuleStructuredOutputPayload)
 reg(InstructionGeneratePayload)
 reg(InstructionTemplatePayload)
-reg(ModelConfig)


@console_ns.route("/rule-generate")
@@ -67,7 +79,7 @@ class RuleGenerateApi(Resource):
    @account_initialization_required
    def post(self):
        args = RuleGeneratePayload.model_validate(console_ns.payload)
-        account, current_tenant_id = current_account_with_tenant()
+        _, current_tenant_id = current_account_with_tenant()

        try:
            rules = LLMGenerator.generate_rule_config(
@@ -75,8 +87,6 @@ class RuleGenerateApi(Resource):
                instruction=args.instruction,
                model_config=args.model_config_data,
                no_variable=args.no_variable,
-                user_id=account.id,
-                app_id=args.app_id,
            )
        except ProviderTokenNotInitError as ex:
            raise ProviderNotInitializeError(ex.description)
@@ -103,7 +113,7 @@ class RuleCodeGenerateApi(Resource):
    @account_initialization_required
    def post(self):
        args = RuleCodeGeneratePayload.model_validate(console_ns.payload)
-        account, current_tenant_id = current_account_with_tenant()
+        _, current_tenant_id = current_account_with_tenant()

        try:
            code_result = LLMGenerator.generate_code(
@@ -111,8 +121,6 @@ class RuleCodeGenerateApi(Resource):
                instruction=args.instruction,
                model_config=args.model_config_data,
                code_language=args.code_language,
-                user_id=account.id,
-                app_id=args.app_id,
            )
        except ProviderTokenNotInitError as ex:
            raise ProviderNotInitializeError(ex.description)
@@ -139,15 +147,13 @@ class RuleStructuredOutputGenerateApi(Resource):
    @account_initialization_required
    def post(self):
        args = RuleStructuredOutputPayload.model_validate(console_ns.payload)
-        account, current_tenant_id = current_account_with_tenant()
+        _, current_tenant_id = current_account_with_tenant()

        try:
            structured_output = LLMGenerator.generate_structured_output(
                tenant_id=current_tenant_id,
                instruction=args.instruction,
                model_config=args.model_config_data,
-                user_id=account.id,
-                app_id=args.app_id,
            )
        except ProviderTokenNotInitError as ex:
            raise ProviderNotInitializeError(ex.description)
@@ -174,14 +180,14 @@ class InstructionGenerateApi(Resource):
    @account_initialization_required
    def post(self):
        args = InstructionGeneratePayload.model_validate(console_ns.payload)
-        account, current_tenant_id = current_account_with_tenant()
-        app_id = args.app_id or args.flow_id
+        _, current_tenant_id = current_account_with_tenant()
        providers: list[type[CodeNodeProvider]] = [Python3CodeProvider, JavascriptCodeProvider]
        code_provider: type[CodeNodeProvider] | None = next(
            (p for p in providers if p.is_accept_language(args.language)), None
        )
        code_template = code_provider.get_default_code() if code_provider else ""
        try:
+            # Generate from nothing for a workflow node
            if (args.current in (code_template, "")) and args.node_id != "":
                app = db.session.query(App).where(App.id == args.flow_id).first()
                if not app:
@@ -201,8 +207,6 @@ class InstructionGenerateApi(Resource):
                            instruction=args.instruction,
                            model_config=args.model_config_data,
                            no_variable=True,
-                            user_id=account.id,
-                            app_id=app_id,
                        )
                    case "agent":
                        return LLMGenerator.generate_rule_config(
@@ -210,8 +214,6 @@ class InstructionGenerateApi(Resource):
                            instruction=args.instruction,
                            model_config=args.model_config_data,
                            no_variable=True,
-                            user_id=account.id,
-                            app_id=app_id,
                        )
                    case "code":
                        return LLMGenerator.generate_code(
@@ -219,12 +221,10 @@ class InstructionGenerateApi(Resource):
                            instruction=args.instruction,
                            model_config=args.model_config_data,
                            code_language=args.language,
-                            user_id=account.id,
-                            app_id=app_id,
                        )
                    case _:
                        return {"error": f"invalid node type: {node_type}"}
-            if args.node_id == "" and args.current != "":
+            if args.node_id == "" and args.current != "":  # For legacy app without a workflow
                return LLMGenerator.instruction_modify_legacy(
                    tenant_id=current_tenant_id,
                    flow_id=args.flow_id,
@@ -232,10 +232,8 @@ class InstructionGenerateApi(Resource):
                    instruction=args.instruction,
                    model_config=args.model_config_data,
                    ideal_output=args.ideal_output,
-                    user_id=account.id,
-                    app_id=app_id,
                )
-            if args.node_id != "" and args.current != "":
+            if args.node_id != "" and args.current != "":  # For workflow node
                return LLMGenerator.instruction_modify_workflow(
                    tenant_id=current_tenant_id,
                    flow_id=args.flow_id,
@@ -245,8 +243,6 @@ class InstructionGenerateApi(Resource):
                    model_config=args.model_config_data,
                    ideal_output=args.ideal_output,
                    workflow_service=WorkflowService(),
-                    user_id=account.id,
-                    app_id=app_id,
                )
            return {"error": "incompatible parameters"}, 400
        except ProviderTokenNotInitError as ex:
@@ -7,7 +7,6 @@ from pydantic import BaseModel, Field, field_validator
 from sqlalchemy import exists, select
 from werkzeug.exceptions import InternalServerError, NotFound

-from controllers.common.schema import register_schema_models
 from controllers.console import console_ns
 from controllers.console.app.error import (
    CompletionRequestError,
@@ -36,6 +35,7 @@ from services.errors.message import MessageNotExistsError, SuggestedQuestionsAft
 from services.message_service import MessageService

 logger = logging.getLogger(__name__)
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"


 class ChatMessagesQuery(BaseModel):
@@ -90,22 +90,13 @@ class FeedbackExportQuery(BaseModel):
        raise ValueError("has_comment must be a boolean value")


-class AnnotationCountResponse(BaseModel):
-    count: int = Field(description="Number of annotations")
+def reg(cls: type[BaseModel]):
+    console_ns.schema_model(cls.__name__, cls.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0))


-class SuggestedQuestionsResponse(BaseModel):
-    data: list[str] = Field(description="Suggested question")
-
-
-register_schema_models(
-    console_ns,
-    ChatMessagesQuery,
-    MessageFeedbackPayload,
-    FeedbackExportQuery,
-    AnnotationCountResponse,
-    SuggestedQuestionsResponse,
-)
+reg(ChatMessagesQuery)
+reg(MessageFeedbackPayload)
+reg(FeedbackExportQuery)

 # Register models for flask_restx to avoid dict type issues in Swagger
 # Register in dependency order: base models first, then dependent models
@@ -240,7 +231,7 @@ class ChatMessageListApi(Resource):
    @marshal_with(message_infinite_scroll_pagination_model)
    @edit_permission_required
    def get(self, app_model):
-        args = ChatMessagesQuery.model_validate(request.args.to_dict())
+        args = ChatMessagesQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore

        conversation = (
            db.session.query(Conversation)
@@ -365,7 +356,7 @@ class MessageAnnotationCountApi(Resource):
    @console_ns.response(
        200,
        "Annotation count retrieved successfully",
-        console_ns.models[AnnotationCountResponse.__name__],
+        console_ns.model("AnnotationCountResponse", {"count": fields.Integer(description="Number of annotations")}),
    )
    @get_app_model
    @setup_required
@@ -385,7 +376,9 @@ class MessageSuggestedQuestionApi(Resource):
    @console_ns.response(
        200,
        "Suggested questions retrieved successfully",
-        console_ns.models[SuggestedQuestionsResponse.__name__],
+        console_ns.model(
+            "SuggestedQuestionsResponse", {"data": fields.List(fields.String(description="Suggested question"))}
+        ),
    )
    @console_ns.response(404, "Message or conversation not found")
    @setup_required
@@ -435,7 +428,7 @@ class MessageFeedbackExportApi(Resource):
    @login_required
    @account_initialization_required
    def get(self, app_model):
-        args = FeedbackExportQuery.model_validate(request.args.to_dict())
+        args = FeedbackExportQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore

        # Import the service function
        from services.feedback_service import FeedbackService
@@ -1,7 +1,6 @@
 from typing import Any

 from flask import request
-from flask_login import current_user
 from flask_restx import Resource, fields
 from pydantic import BaseModel, Field
 from werkzeug.exceptions import BadRequest
@@ -78,10 +77,7 @@ class TraceAppConfigApi(Resource):

        try:
            result = OpsService.create_tracing_app_config(
-                app_id=app_id,
-                tracing_provider=args.tracing_provider,
-                tracing_config=args.tracing_config,
-                account_id=current_user.id,
+                app_id=app_id, tracing_provider=args.tracing_provider, tracing_config=args.tracing_config
            )
            if not result:
                raise TracingConfigIsExist()
@@ -106,10 +102,7 @@ class TraceAppConfigApi(Resource):

        try:
            result = OpsService.update_tracing_app_config(
-                app_id=app_id,
-                tracing_provider=args.tracing_provider,
-                tracing_config=args.tracing_config,
-                account_id=current_user.id,
+                app_id=app_id, tracing_provider=args.tracing_provider, tracing_config=args.tracing_config
            )
            if not result:
                raise TracingConfigNotExist()
@@ -131,9 +124,7 @@ class TraceAppConfigApi(Resource):
        args = TraceProviderQuery.model_validate(request.args.to_dict(flat=True))  # type: ignore

        try:
-            result = OpsService.delete_tracing_app_config(
-                app_id=app_id, tracing_provider=args.tracing_provider, account_id=current_user.id
-            )
+            result = OpsService.delete_tracing_app_config(app_id=app_id, tracing_provider=args.tracing_provider)
            if not result:
                raise TracingConfigNotExist()
            return {"result": "success"}, 204
@@ -2,11 +2,9 @@ import logging

 import httpx
 from flask import current_app, redirect, request
-from flask_restx import Resource
-from pydantic import BaseModel, Field
+from flask_restx import Resource, fields

 from configs import dify_config
-from controllers.common.schema import register_schema_models
 from libs.login import login_required
 from libs.oauth_data_source import NotionOAuth

@@ -16,26 +14,6 @@ from ..wraps import account_initialization_required, is_admin_or_owner_required,
 logger = logging.getLogger(__name__)


-class OAuthDataSourceResponse(BaseModel):
-    data: str = Field(description="Authorization URL or 'internal' for internal setup")
-
-
-class OAuthDataSourceBindingResponse(BaseModel):
-    result: str = Field(description="Operation result")
-
-
-class OAuthDataSourceSyncResponse(BaseModel):
-    result: str = Field(description="Operation result")
-
-
-register_schema_models(
-    console_ns,
-    OAuthDataSourceResponse,
-    OAuthDataSourceBindingResponse,
-    OAuthDataSourceSyncResponse,
-)
-
-
 def get_oauth_providers():
    with current_app.app_context():
        notion_oauth = NotionOAuth(
@@ -56,7 +34,10 @@ class OAuthDataSource(Resource):
    @console_ns.response(
        200,
        "Authorization URL or internal setup success",
-        console_ns.models[OAuthDataSourceResponse.__name__],
+        console_ns.model(
+            "OAuthDataSourceResponse",
+            {"data": fields.Raw(description="Authorization URL or 'internal' for internal setup")},
+        ),
    )
    @console_ns.response(400, "Invalid provider")
    @console_ns.response(403, "Admin privileges required")
@@ -120,7 +101,7 @@ class OAuthDataSourceBinding(Resource):
    @console_ns.response(
        200,
        "Data source binding success",
-        console_ns.models[OAuthDataSourceBindingResponse.__name__],
+        console_ns.model("OAuthDataSourceBindingResponse", {"result": fields.String(description="Operation result")}),
    )
    @console_ns.response(400, "Invalid provider or code")
    def get(self, provider: str):
@@ -152,7 +133,7 @@ class OAuthDataSourceSync(Resource):
    @console_ns.response(
        200,
        "Data source sync success",
-        console_ns.models[OAuthDataSourceSyncResponse.__name__],
+        console_ns.model("OAuthDataSourceSyncResponse", {"result": fields.String(description="Operation result")}),
    )
    @console_ns.response(400, "Invalid provider or sync failed")
    @setup_required
@@ -2,11 +2,10 @@ import base64
 import secrets

 from flask import request
-from flask_restx import Resource
+from flask_restx import Resource, fields
 from pydantic import BaseModel, Field, field_validator
 from sqlalchemy.orm import Session

-from controllers.common.schema import register_schema_models
 from controllers.console import console_ns
 from controllers.console.auth.error import (
    EmailCodeError,
@@ -49,31 +48,8 @@ class ForgotPasswordResetPayload(BaseModel):
        return valid_password(value)


-class ForgotPasswordEmailResponse(BaseModel):
-    result: str = Field(description="Operation result")
-    data: str | None = Field(default=None, description="Reset token")
-    code: str | None = Field(default=None, description="Error code if account not found")
-
-
-class ForgotPasswordCheckResponse(BaseModel):
-    is_valid: bool = Field(description="Whether code is valid")
-    email: EmailStr = Field(description="Email address")
-    token: str = Field(description="New reset token")
-
-
-class ForgotPasswordResetResponse(BaseModel):
-    result: str = Field(description="Operation result")
-
-
-register_schema_models(
-    console_ns,
-    ForgotPasswordSendPayload,
-    ForgotPasswordCheckPayload,
-    ForgotPasswordResetPayload,
-    ForgotPasswordEmailResponse,
-    ForgotPasswordCheckResponse,
-    ForgotPasswordResetResponse,
-)
+for model in (ForgotPasswordSendPayload, ForgotPasswordCheckPayload, ForgotPasswordResetPayload):
+    console_ns.schema_model(model.__name__, model.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0))


@console_ns.route("/forgot-password")
@@ -84,7 +60,14 @@ class ForgotPasswordSendEmailApi(Resource):
    @console_ns.response(
        200,
        "Email sent successfully",
-        console_ns.models[ForgotPasswordEmailResponse.__name__],
+        console_ns.model(
+            "ForgotPasswordEmailResponse",
+            {
+                "result": fields.String(description="Operation result"),
+                "data": fields.String(description="Reset token"),
+                "code": fields.String(description="Error code if account not found"),
+            },
+        ),
    )
    @console_ns.response(400, "Invalid email or rate limit exceeded")
    @setup_required
@@ -123,7 +106,14 @@ class ForgotPasswordCheckApi(Resource):
    @console_ns.response(
        200,
        "Code verified successfully",
-        console_ns.models[ForgotPasswordCheckResponse.__name__],
+        console_ns.model(
+            "ForgotPasswordCheckResponse",
+            {
+                "is_valid": fields.Boolean(description="Whether code is valid"),
+                "email": fields.String(description="Email address"),
+                "token": fields.String(description="New reset token"),
+            },
+        ),
    )
    @console_ns.response(400, "Invalid code or token")
    @setup_required
@@ -173,7 +163,7 @@ class ForgotPasswordResetApi(Resource):
    @console_ns.response(
        200,
        "Password reset successfully",
-        console_ns.models[ForgotPasswordResetResponse.__name__],
+        console_ns.model("ForgotPasswordResetResponse", {"result": fields.String(description="Operation result")}),
    )
    @console_ns.response(400, "Invalid token or password mismatch")
    @setup_required
@@ -155,43 +155,43 @@ class OAuthServerUserTokenApi(Resource):
            grant_type = OAuthGrantType(payload.grant_type)
        except ValueError:
            raise BadRequest("invalid grant_type")
-        match grant_type:
-            case OAuthGrantType.AUTHORIZATION_CODE:
-                if not payload.code:
-                    raise BadRequest("code is required")

-                if payload.client_secret != oauth_provider_app.client_secret:
-                    raise BadRequest("client_secret is invalid")
+        if grant_type == OAuthGrantType.AUTHORIZATION_CODE:
+            if not payload.code:
+                raise BadRequest("code is required")

-                if payload.redirect_uri not in oauth_provider_app.redirect_uris:
-                    raise BadRequest("redirect_uri is invalid")
+            if payload.client_secret != oauth_provider_app.client_secret:
+                raise BadRequest("client_secret is invalid")

-                access_token, refresh_token = OAuthServerService.sign_oauth_access_token(
-                    grant_type, code=payload.code, client_id=oauth_provider_app.client_id
-                )
-                return jsonable_encoder(
-                    {
-                        "access_token": access_token,
-                        "token_type": "Bearer",
-                        "expires_in": OAUTH_ACCESS_TOKEN_EXPIRES_IN,
-                        "refresh_token": refresh_token,
-                    }
-                )
-            case OAuthGrantType.REFRESH_TOKEN:
-                if not payload.refresh_token:
-                    raise BadRequest("refresh_token is required")
+            if payload.redirect_uri not in oauth_provider_app.redirect_uris:
+                raise BadRequest("redirect_uri is invalid")

-                access_token, refresh_token = OAuthServerService.sign_oauth_access_token(
-                    grant_type, refresh_token=payload.refresh_token, client_id=oauth_provider_app.client_id
-                )
-                return jsonable_encoder(
-                    {
-                        "access_token": access_token,
-                        "token_type": "Bearer",
-                        "expires_in": OAUTH_ACCESS_TOKEN_EXPIRES_IN,
-                        "refresh_token": refresh_token,
-                    }
-                )
+            access_token, refresh_token = OAuthServerService.sign_oauth_access_token(
+                grant_type, code=payload.code, client_id=oauth_provider_app.client_id
+            )
+            return jsonable_encoder(
+                {
+                    "access_token": access_token,
+                    "token_type": "Bearer",
+                    "expires_in": OAUTH_ACCESS_TOKEN_EXPIRES_IN,
+                    "refresh_token": refresh_token,
+                }
+            )
+        elif grant_type == OAuthGrantType.REFRESH_TOKEN:
+            if not payload.refresh_token:
+                raise BadRequest("refresh_token is required")
+
+            access_token, refresh_token = OAuthServerService.sign_oauth_access_token(
+                grant_type, refresh_token=payload.refresh_token, client_id=oauth_provider_app.client_id
+            )
+            return jsonable_encoder(
+                {
+                    "access_token": access_token,
+                    "token_type": "Bearer",
+                    "expires_in": OAUTH_ACCESS_TOKEN_EXPIRES_IN,
+                    "refresh_token": refresh_token,
+                }
+            )


@console_ns.route("/oauth/provider/account")
@@ -1,6 +1,6 @@
 import json
 from collections.abc import Generator
-from typing import Any, Literal, cast
+from typing import Any, cast

 from flask import request
 from flask_restx import Resource, fields, marshal_with
@@ -157,8 +157,9 @@ class DataSourceApi(Resource):
    @setup_required
    @login_required
    @account_initialization_required
-    def patch(self, binding_id, action: Literal["enable", "disable"]):
+    def patch(self, binding_id, action):
        binding_id = str(binding_id)
+        action = str(action)
        with Session(db.engine) as session:
            data_source_binding = session.execute(
                select(DataSourceOauthBinding).filter_by(id=binding_id)
@@ -166,24 +167,23 @@ class DataSourceApi(Resource):
        if data_source_binding is None:
            raise NotFound("Data source binding not found.")
        # enable binding
-        match action:
-            case "enable":
-                if data_source_binding.disabled:
-                    data_source_binding.disabled = False
-                    data_source_binding.updated_at = naive_utc_now()
-                    db.session.add(data_source_binding)
-                    db.session.commit()
-                else:
-                    raise ValueError("Data source is not disabled.")
-            # disable binding
-            case "disable":
-                if not data_source_binding.disabled:
-                    data_source_binding.disabled = True
-                    data_source_binding.updated_at = naive_utc_now()
-                    db.session.add(data_source_binding)
-                    db.session.commit()
-                else:
-                    raise ValueError("Data source is disabled.")
+        if action == "enable":
+            if data_source_binding.disabled:
+                data_source_binding.disabled = False
+                data_source_binding.updated_at = naive_utc_now()
+                db.session.add(data_source_binding)
+                db.session.commit()
+            else:
+                raise ValueError("Data source is not disabled.")
+        # disable binding
+        if action == "disable":
+            if not data_source_binding.disabled:
+                data_source_binding.disabled = True
+                data_source_binding.updated_at = naive_utc_now()
+                db.session.add(data_source_binding)
+                db.session.commit()
+            else:
+                raise ValueError("Data source is disabled.")
        return {"result": "success"}, 200


@@ -148,7 +148,6 @@ class DatasetUpdatePayload(BaseModel):
    embedding_model: str | None = None
    embedding_model_provider: str | None = None
    retrieval_model: dict[str, Any] | None = None
-    summary_index_setting: dict[str, Any] | None = None
    partial_member_list: list[dict[str, str]] | None = None
    external_retrieval_model: dict[str, Any] | None = None
    external_knowledge_id: str | None = None
@@ -289,14 +288,7 @@ class DatasetListApi(Resource):
    @enterprise_license_required
    def get(self):
        current_user, current_tenant_id = current_account_with_tenant()
-        # Convert query parameters to dict, handling list parameters correctly
-        query_params: dict[str, str | list[str]] = dict(request.args.to_dict())
-        # Handle ids and tag_ids as lists (Flask request.args.getlist returns list even for single value)
-        if "ids" in request.args:
-            query_params["ids"] = request.args.getlist("ids")
-        if "tag_ids" in request.args:
-            query_params["tag_ids"] = request.args.getlist("tag_ids")
-        query = ConsoleDatasetListQuery.model_validate(query_params)
+        query = ConsoleDatasetListQuery.model_validate(request.args.to_dict())
        # provider = request.args.get("provider", default="vendor")
        if query.ids:
            datasets, total = DatasetService.get_datasets_by_ids(query.ids, current_tenant_id)
@@ -45,7 +45,6 @@ from models.dataset import DocumentPipelineExecutionLog
 from services.dataset_service import DatasetService, DocumentService
 from services.entities.knowledge_entities.knowledge_entities import KnowledgeConfig, ProcessRule, RetrievalModel
 from services.file_service import FileService
-from tasks.generate_summary_index_task import generate_summary_index_task

 from ..app.error import (
    ProviderModelCurrentlyNotSupportError,
@@ -104,10 +103,6 @@ class DocumentRenamePayload(BaseModel):
    name: str


-class GenerateSummaryPayload(BaseModel):
-    document_list: list[str]
-
-
 class DocumentBatchDownloadZipPayload(BaseModel):
    """Request payload for bulk downloading documents as a zip archive."""

@@ -130,7 +125,6 @@ register_schema_models(
    RetrievalModel,
    DocumentRetryPayload,
    DocumentRenamePayload,
-    GenerateSummaryPayload,
    DocumentBatchDownloadZipPayload,
 )

@@ -318,13 +312,6 @@ class DatasetDocumentListApi(Resource):

        paginated_documents = db.paginate(select=query, page=page, per_page=limit, max_per_page=100, error_out=False)
        documents = paginated_documents.items
-
-        DocumentService.enrich_documents_with_summary_index_status(
-            documents=documents,
-            dataset=dataset,
-            tenant_id=current_tenant_id,
-        )
-
        if fetch:
            for document in documents:
                completed_segments = (
@@ -576,62 +563,63 @@ class DocumentBatchIndexingEstimateApi(DocumentResource):
            if document.indexing_status in {"completed", "error"}:
                raise DocumentAlreadyFinishedError()
            data_source_info = document.data_source_info_dict
-            match document.data_source_type:
-                case "upload_file":
-                    if not data_source_info:
-                        continue
-                    file_id = data_source_info["upload_file_id"]
-                    file_detail = (
-                        db.session.query(UploadFile)
-                        .where(UploadFile.tenant_id == current_tenant_id, UploadFile.id == file_id)
-                        .first()
-                    )

-                    if file_detail is None:
-                        raise NotFound("File not found.")
+            if document.data_source_type == "upload_file":
+                if not data_source_info:
+                    continue
+                file_id = data_source_info["upload_file_id"]
+                file_detail = (
+                    db.session.query(UploadFile)
+                    .where(UploadFile.tenant_id == current_tenant_id, UploadFile.id == file_id)
+                    .first()
+                )

-                    extract_setting = ExtractSetting(
-                        datasource_type=DatasourceType.FILE, upload_file=file_detail, document_model=document.doc_form
-                    )
-                    extract_settings.append(extract_setting)
-                case "notion_import":
-                    if not data_source_info:
-                        continue
-                    extract_setting = ExtractSetting(
-                        datasource_type=DatasourceType.NOTION,
-                        notion_info=NotionInfo.model_validate(
-                            {
-                                "credential_id": data_source_info.get("credential_id"),
-                                "notion_workspace_id": data_source_info["notion_workspace_id"],
-                                "notion_obj_id": data_source_info["notion_page_id"],
-                                "notion_page_type": data_source_info["type"],
-                                "tenant_id": current_tenant_id,
-                            }
-                        ),
-                        document_model=document.doc_form,
-                    )
-                    extract_settings.append(extract_setting)
-                case "website_crawl":
-                    if not data_source_info:
-                        continue
-                    extract_setting = ExtractSetting(
-                        datasource_type=DatasourceType.WEBSITE,
-                        website_info=WebsiteInfo.model_validate(
-                            {
-                                "provider": data_source_info["provider"],
-                                "job_id": data_source_info["job_id"],
-                                "url": data_source_info["url"],
-                                "tenant_id": current_tenant_id,
-                                "mode": data_source_info["mode"],
-                                "only_main_content": data_source_info["only_main_content"],
-                            }
-                        ),
-                        document_model=document.doc_form,
-                    )
-                    extract_settings.append(extract_setting)
+                if file_detail is None:
+                    raise NotFound("File not found.")

-                case _:
-                    raise ValueError("Data source type not support")
+                extract_setting = ExtractSetting(
+                    datasource_type=DatasourceType.FILE, upload_file=file_detail, document_model=document.doc_form
+                )
+                extract_settings.append(extract_setting)
+
+            elif document.data_source_type == "notion_import":
+                if not data_source_info:
+                    continue
+                extract_setting = ExtractSetting(
+                    datasource_type=DatasourceType.NOTION,
+                    notion_info=NotionInfo.model_validate(
+                        {
+                            "credential_id": data_source_info.get("credential_id"),
+                            "notion_workspace_id": data_source_info["notion_workspace_id"],
+                            "notion_obj_id": data_source_info["notion_page_id"],
+                            "notion_page_type": data_source_info["type"],
+                            "tenant_id": current_tenant_id,
+                        }
+                    ),
+                    document_model=document.doc_form,
+                )
+                extract_settings.append(extract_setting)
+            elif document.data_source_type == "website_crawl":
+                if not data_source_info:
+                    continue
+                extract_setting = ExtractSetting(
+                    datasource_type=DatasourceType.WEBSITE,
+                    website_info=WebsiteInfo.model_validate(
+                        {
+                            "provider": data_source_info["provider"],
+                            "job_id": data_source_info["job_id"],
+                            "url": data_source_info["url"],
+                            "tenant_id": current_tenant_id,
+                            "mode": data_source_info["mode"],
+                            "only_main_content": data_source_info["only_main_content"],
+                        }
+                    ),
+                    document_model=document.doc_form,
+                )
+                extract_settings.append(extract_setting)
+
+            else:
+                raise ValueError("Data source type not support")
            indexing_runner = IndexingRunner()
            try:
                response = indexing_runner.indexing_estimate(
@@ -809,7 +797,6 @@ class DocumentApi(DocumentResource):
                "display_status": document.display_status,
                "doc_form": document.doc_form,
                "doc_language": document.doc_language,
-                "need_summary": document.need_summary if document.need_summary is not None else False,
            }
        else:
            dataset_process_rules = DatasetService.get_process_rules(dataset_id)
@@ -845,7 +832,6 @@ class DocumentApi(DocumentResource):
                "display_status": document.display_status,
                "doc_form": document.doc_form,
                "doc_language": document.doc_language,
-                "need_summary": document.need_summary if document.need_summary is not None else False,
            }

        return response, 200
@@ -953,24 +939,23 @@ class DocumentProcessingApi(DocumentResource):
        if not current_user.is_dataset_editor:
            raise Forbidden()

-        match action:
-            case "pause":
-                if document.indexing_status != "indexing":
-                    raise InvalidActionError("Document not in indexing state.")
+        if action == "pause":
+            if document.indexing_status != "indexing":
+                raise InvalidActionError("Document not in indexing state.")

-                document.paused_by = current_user.id
-                document.paused_at = naive_utc_now()
-                document.is_paused = True
-                db.session.commit()
+            document.paused_by = current_user.id
+            document.paused_at = naive_utc_now()
+            document.is_paused = True
+            db.session.commit()

-            case "resume":
-                if document.indexing_status not in {"paused", "error"}:
-                    raise InvalidActionError("Document not in paused or error state.")
+        elif action == "resume":
+            if document.indexing_status not in {"paused", "error"}:
+                raise InvalidActionError("Document not in paused or error state.")

-                document.paused_by = None
-                document.paused_at = None
-                document.is_paused = False
-                db.session.commit()
+            document.paused_by = None
+            document.paused_at = None
+            document.is_paused = False
+            db.session.commit()

        return {"result": "success"}, 200

@@ -1270,149 +1255,3 @@ class DocumentPipelineExecutionLogApi(DocumentResource):
            "input_data": log.input_data,
            "datasource_node_id": log.datasource_node_id,
        }, 200
-
-
-@console_ns.route("/datasets/<uuid:dataset_id>/documents/generate-summary")
-class DocumentGenerateSummaryApi(Resource):
-    @console_ns.doc("generate_summary_for_documents")
-    @console_ns.doc(description="Generate summary index for documents")
-    @console_ns.doc(params={"dataset_id": "Dataset ID"})
-    @console_ns.expect(console_ns.models[GenerateSummaryPayload.__name__])
-    @console_ns.response(200, "Summary generation started successfully")
-    @console_ns.response(400, "Invalid request or dataset configuration")
-    @console_ns.response(403, "Permission denied")
-    @console_ns.response(404, "Dataset not found")
-    @setup_required
-    @login_required
-    @account_initialization_required
-    @cloud_edition_billing_rate_limit_check("knowledge")
-    def post(self, dataset_id):
-        """
-        Generate summary index for specified documents.
-
-        This endpoint checks if the dataset configuration supports summary generation
-        (indexing_technique must be 'high_quality' and summary_index_setting.enable must be true),
-        then asynchronously generates summary indexes for the provided documents.
-        """
-        current_user, _ = current_account_with_tenant()
-        dataset_id = str(dataset_id)
-
-        # Get dataset
-        dataset = DatasetService.get_dataset(dataset_id)
-        if not dataset:
-            raise NotFound("Dataset not found.")
-
-        # Check permissions
-        if not current_user.is_dataset_editor:
-            raise Forbidden()
-
-        try:
-            DatasetService.check_dataset_permission(dataset, current_user)
-        except services.errors.account.NoPermissionError as e:
-            raise Forbidden(str(e))
-
-        # Validate request payload
-        payload = GenerateSummaryPayload.model_validate(console_ns.payload or {})
-        document_list = payload.document_list
-
-        if not document_list:
-            from werkzeug.exceptions import BadRequest
-
-            raise BadRequest("document_list cannot be empty.")
-
-        # Check if dataset configuration supports summary generation
-        if dataset.indexing_technique != "high_quality":
-            raise ValueError(
-                f"Summary generation is only available for 'high_quality' indexing technique. "
-                f"Current indexing technique: {dataset.indexing_technique}"
-            )
-
-        summary_index_setting = dataset.summary_index_setting
-        if not summary_index_setting or not summary_index_setting.get("enable"):
-            raise ValueError("Summary index is not enabled for this dataset. Please enable it in the dataset settings.")
-
-        # Verify all documents exist and belong to the dataset
-        documents = DocumentService.get_documents_by_ids(dataset_id, document_list)
-
-        if len(documents) != len(document_list):
-            found_ids = {doc.id for doc in documents}
-            missing_ids = set(document_list) - found_ids
-            raise NotFound(f"Some documents not found: {list(missing_ids)}")
-
-        # Update need_summary to True for documents that don't have it set
-        # This handles the case where documents were created when summary_index_setting was disabled
-        documents_to_update = [doc for doc in documents if not doc.need_summary and doc.doc_form != "qa_model"]
-
-        if documents_to_update:
-            document_ids_to_update = [str(doc.id) for doc in documents_to_update]
-            DocumentService.update_documents_need_summary(
-                dataset_id=dataset_id,
-                document_ids=document_ids_to_update,
-                need_summary=True,
-            )
-
-        # Dispatch async tasks for each document
-        for document in documents:
-            # Skip qa_model documents as they don't generate summaries
-            if document.doc_form == "qa_model":
-                logger.info("Skipping summary generation for qa_model document %s", document.id)
-                continue
-
-            # Dispatch async task
-            generate_summary_index_task.delay(dataset_id, document.id)
-            logger.info(
-                "Dispatched summary generation task for document %s in dataset %s",
-                document.id,
-                dataset_id,
-            )
-
-        return {"result": "success"}, 200
-
-
-@console_ns.route("/datasets/<uuid:dataset_id>/documents/<uuid:document_id>/summary-status")
-class DocumentSummaryStatusApi(DocumentResource):
-    @console_ns.doc("get_document_summary_status")
-    @console_ns.doc(description="Get summary index generation status for a document")
-    @console_ns.doc(params={"dataset_id": "Dataset ID", "document_id": "Document ID"})
-    @console_ns.response(200, "Summary status retrieved successfully")
-    @console_ns.response(404, "Document not found")
-    @setup_required
-    @login_required
-    @account_initialization_required
-    def get(self, dataset_id, document_id):
-        """
-        Get summary index generation status for a document.
-
-        Returns:
-        - total_segments: Total number of segments in the document
-        - summary_status: Dictionary with status counts
-          - completed: Number of summaries completed
-          - generating: Number of summaries being generated
-          - error: Number of summaries with errors
-          - not_started: Number of segments without summary records
-        - summaries: List of summary records with status and content preview
-        """
-        current_user, _ = current_account_with_tenant()
-        dataset_id = str(dataset_id)
-        document_id = str(document_id)
-
-        # Get dataset
-        dataset = DatasetService.get_dataset(dataset_id)
-        if not dataset:
-            raise NotFound("Dataset not found.")
-
-        # Check permissions
-        try:
-            DatasetService.check_dataset_permission(dataset, current_user)
-        except services.errors.account.NoPermissionError as e:
-            raise Forbidden(str(e))
-
-        # Get summary status detail from service
-        from services.summary_index_service import SummaryIndexService
-
-        result = SummaryIndexService.get_document_summary_status_detail(
-            document_id=document_id,
-            dataset_id=dataset_id,
-        )
-
-        return result, 200
@@ -41,17 +41,6 @@ from services.errors.chunk import ChildChunkIndexingError as ChildChunkIndexingS
 from tasks.batch_create_segment_to_index_task import batch_create_segment_to_index_task


-def _get_segment_with_summary(segment, dataset_id):
-    """Helper function to marshal segment and add summary information."""
-    from services.summary_index_service import SummaryIndexService
-
-    segment_dict = dict(marshal(segment, segment_fields))
-    # Query summary for this segment (only enabled summaries)
-    summary = SummaryIndexService.get_segment_summary(segment_id=segment.id, dataset_id=dataset_id)
-    segment_dict["summary"] = summary.summary_content if summary else None
-    return segment_dict
-
-
 class SegmentListQuery(BaseModel):
    limit: int = Field(default=20, ge=1, le=100)
    status: list[str] = Field(default_factory=list)
@@ -74,7 +63,6 @@ class SegmentUpdatePayload(BaseModel):
    keywords: list[str] | None = None
    regenerate_child_chunks: bool = False
    attachment_ids: list[str] | None = None
-    summary: str | None = None  # Summary content for summary index


 class BatchImportPayload(BaseModel):
@@ -193,25 +181,8 @@ class DatasetDocumentSegmentListApi(Resource):

        segments = db.paginate(select=query, page=page, per_page=limit, max_per_page=100, error_out=False)

-        # Query summaries for all segments in this page (batch query for efficiency)
-        segment_ids = [segment.id for segment in segments.items]
-        summaries = {}
-        if segment_ids:
-            from services.summary_index_service import SummaryIndexService
-
-            summary_records = SummaryIndexService.get_segments_summaries(segment_ids=segment_ids, dataset_id=dataset_id)
-            # Only include enabled summaries (already filtered by service)
-            summaries = {chunk_id: summary.summary_content for chunk_id, summary in summary_records.items()}
-
-        # Add summary to each segment
-        segments_with_summary = []
-        for segment in segments.items:
-            segment_dict = dict(marshal(segment, segment_fields))
-            segment_dict["summary"] = summaries.get(segment.id)
-            segments_with_summary.append(segment_dict)
-
        response = {
-            "data": segments_with_summary,
+            "data": marshal(segments.items, segment_fields),
            "limit": limit,
            "total": segments.total,
            "total_pages": segments.pages,
@@ -357,7 +328,7 @@ class DatasetDocumentSegmentAddApi(Resource):
        payload_dict = payload.model_dump(exclude_none=True)
        SegmentService.segment_create_args_validate(payload_dict, document)
        segment = SegmentService.create_segment(payload_dict, document, dataset)
-        return {"data": _get_segment_with_summary(segment, dataset_id), "doc_form": document.doc_form}, 200
+        return {"data": marshal(segment, segment_fields), "doc_form": document.doc_form}, 200


@console_ns.route("/datasets/<uuid:dataset_id>/documents/<uuid:document_id>/segments/<uuid:segment_id>")
@@ -419,12 +390,10 @@ class DatasetDocumentSegmentUpdateApi(Resource):
        payload = SegmentUpdatePayload.model_validate(console_ns.payload or {})
        payload_dict = payload.model_dump(exclude_none=True)
        SegmentService.segment_create_args_validate(payload_dict, document)
-
-        # Update segment (summary update with change detection is handled in SegmentService.update_segment)
        segment = SegmentService.update_segment(
            SegmentUpdateArgs.model_validate(payload.model_dump(exclude_none=True)), segment, document, dataset
        )
-        return {"data": _get_segment_with_summary(segment, dataset_id), "doc_form": document.doc_form}, 200
+        return {"data": marshal(segment, segment_fields), "doc_form": document.doc_form}, 200

    @setup_required
    @login_required
@@ -1,13 +1,6 @@
-from flask_restx import Resource, fields
+from flask_restx import Resource

 from controllers.common.schema import register_schema_model
-from fields.hit_testing_fields import (
-    child_chunk_fields,
-    document_fields,
-    files_fields,
-    hit_testing_record_fields,
-    segment_fields,
-)
 from libs.login import login_required

 from .. import console_ns
@@ -21,45 +14,13 @@ from ..wraps import (
 register_schema_model(console_ns, HitTestingPayload)


-def _get_or_create_model(model_name: str, field_def):
-    """Get or create a flask_restx model to avoid dict type issues in Swagger."""
-    existing = console_ns.models.get(model_name)
-    if existing is None:
-        existing = console_ns.model(model_name, field_def)
-    return existing
-
-
-# Register models for flask_restx to avoid dict type issues in Swagger
-document_model = _get_or_create_model("HitTestingDocument", document_fields)
-
-segment_fields_copy = segment_fields.copy()
-segment_fields_copy["document"] = fields.Nested(document_model)
-segment_model = _get_or_create_model("HitTestingSegment", segment_fields_copy)
-
-child_chunk_model = _get_or_create_model("HitTestingChildChunk", child_chunk_fields)
-files_model = _get_or_create_model("HitTestingFile", files_fields)
-
-hit_testing_record_fields_copy = hit_testing_record_fields.copy()
-hit_testing_record_fields_copy["segment"] = fields.Nested(segment_model)
-hit_testing_record_fields_copy["child_chunks"] = fields.List(fields.Nested(child_chunk_model))
-hit_testing_record_fields_copy["files"] = fields.List(fields.Nested(files_model))
-hit_testing_record_model = _get_or_create_model("HitTestingRecord", hit_testing_record_fields_copy)
-
-# Response model for hit testing API
-hit_testing_response_fields = {
-    "query": fields.String,
-    "records": fields.List(fields.Nested(hit_testing_record_model)),
-}
-hit_testing_response_model = _get_or_create_model("HitTestingResponse", hit_testing_response_fields)
-
-
@console_ns.route("/datasets/<uuid:dataset_id>/hit-testing")
 class HitTestingApi(Resource, DatasetsHitTestingBase):
    @console_ns.doc("test_dataset_retrieval")
    @console_ns.doc(description="Test dataset knowledge retrieval")
    @console_ns.doc(params={"dataset_id": "Dataset ID"})
    @console_ns.expect(console_ns.models[HitTestingPayload.__name__])
-    @console_ns.response(200, "Hit testing completed successfully", model=hit_testing_response_model)
+    @console_ns.response(200, "Hit testing completed successfully")
    @console_ns.response(404, "Dataset not found")
    @console_ns.response(400, "Invalid parameters")
    @setup_required
@@ -126,11 +126,10 @@ class DatasetMetadataBuiltInFieldActionApi(Resource):
            raise NotFound("Dataset not found.")
        DatasetService.check_dataset_permission(dataset, current_user)

-        match action:
-            case "enable":
-                MetadataService.enable_built_in_field(dataset)
-            case "disable":
-                MetadataService.disable_built_in_field(dataset)
+        if action == "enable":
+            MetadataService.enable_built_in_field(dataset)
+        elif action == "disable":
+            MetadataService.disable_built_in_field(dataset)
        return {"result": "success"}, 200


@@ -1,9 +1,10 @@
 import json
 import logging
 from typing import Any, Literal, cast
+from uuid import UUID

 from flask import abort, request
-from flask_restx import Resource, marshal_with  # type: ignore
+from flask_restx import Resource, marshal_with, reqparse  # type: ignore
 from pydantic import BaseModel, Field
 from sqlalchemy.orm import Session
 from werkzeug.exceptions import Forbidden, InternalServerError, NotFound
@@ -37,7 +38,7 @@ from core.model_runtime.utils.encoders import jsonable_encoder
 from extensions.ext_database import db
 from factories import variable_factory
 from libs import helper
-from libs.helper import TimestampField, UUIDStrOrEmpty
+from libs.helper import TimestampField
 from libs.login import current_account_with_tenant, current_user, login_required
 from models import Account
 from models.dataset import Pipeline
@@ -109,7 +110,7 @@ class NodeIdQuery(BaseModel):


 class WorkflowRunQuery(BaseModel):
-    last_id: UUIDStrOrEmpty | None = None
+    last_id: UUID | None = None
    limit: int = Field(default=20, ge=1, le=100)


@@ -120,10 +121,6 @@ class DatasourceVariablesPayload(BaseModel):
    start_node_title: str


-class RagPipelineRecommendedPluginQuery(BaseModel):
-    type: str = "all"
-
-
 register_schema_models(
    console_ns,
    DraftWorkflowSyncPayload,
@@ -138,7 +135,6 @@ register_schema_models(
    NodeIdQuery,
    WorkflowRunQuery,
    DatasourceVariablesPayload,
-    RagPipelineRecommendedPluginQuery,
 )


@@ -979,8 +975,11 @@ class RagPipelineRecommendedPluginApi(Resource):
    @login_required
    @account_initialization_required
    def get(self):
-        query = RagPipelineRecommendedPluginQuery.model_validate(request.args.to_dict())
+        parser = reqparse.RequestParser()
+        parser.add_argument("type", type=str, location="args", required=False, default="all")
+        args = parser.parse_args()
+        type = args["type"]

        rag_pipeline_service = RagPipelineService()
-        recommended_plugins = rag_pipeline_service.get_recommended_plugins(query.type)
+        recommended_plugins = rag_pipeline_service.get_recommended_plugins(type)
        return recommended_plugins
@@ -9,7 +9,7 @@ import services
 from controllers.common.fields import Parameters as ParametersResponse
 from controllers.common.fields import Site as SiteResponse
 from controllers.common.schema import get_or_create_model
-from controllers.console import api
+from controllers.console import api, console_ns
 from controllers.console.app.error import (
    AppUnavailableError,
    AudioTooLargeError,
@@ -51,7 +51,7 @@ from fields.app_fields import (
    tag_fields,
 )
 from fields.dataset_fields import dataset_fields
-from fields.member_fields import simple_account_fields
+from fields.member_fields import build_simple_account_model
 from fields.workflow_fields import (
    conversation_variable_fields,
    pipeline_variable_fields,
@@ -103,7 +103,7 @@ app_detail_fields_with_site_copy["tags"] = fields.List(fields.Nested(tag_model))
 app_detail_fields_with_site_copy["site"] = fields.Nested(site_model)
 app_detail_with_site_model = get_or_create_model("TrialAppDetailWithSite", app_detail_fields_with_site_copy)

-simple_account_model = get_or_create_model("SimpleAccount", simple_account_fields)
+simple_account_model = build_simple_account_model(console_ns)
 conversation_variable_model = get_or_create_model("TrialConversationVariable", conversation_variable_fields)
 pipeline_variable_model = get_or_create_model("TrialPipelineVariable", pipeline_variable_fields)

@@ -1,74 +1,87 @@
 import os
-from typing import Literal

 from flask import session
+from flask_restx import Resource, fields
 from pydantic import BaseModel, Field
 from sqlalchemy import select
 from sqlalchemy.orm import Session

 from configs import dify_config
-from controllers.fastopenapi import console_router
 from extensions.ext_database import db
 from models.model import DifySetup
 from services.account_service import TenantService

+from . import console_ns
 from .error import AlreadySetupError, InitValidateFailedError
 from .wraps import only_edition_self_hosted

+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
+

 class InitValidatePayload(BaseModel):
-    password: str = Field(..., max_length=30, description="Initialization password")
+    password: str = Field(..., max_length=30)


-class InitStatusResponse(BaseModel):
-    status: Literal["finished", "not_started"] = Field(..., description="Initialization status")
-
-
-class InitValidateResponse(BaseModel):
-    result: str = Field(description="Operation result", examples=["success"])
-
-
-@console_router.get(
-    "/init",
-    response_model=InitStatusResponse,
-    tags=["console"],
+console_ns.schema_model(
+    InitValidatePayload.__name__,
+    InitValidatePayload.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0),
 )
-def get_init_status() -> InitStatusResponse:
-    """Get initialization validation status."""
-    init_status = get_init_validate_status()
-    if init_status:
-        return InitStatusResponse(status="finished")
-    return InitStatusResponse(status="not_started")


-@console_router.post(
-    "/init",
-    response_model=InitValidateResponse,
-    tags=["console"],
-    status_code=201,
-)
-@only_edition_self_hosted
-def validate_init_password(payload: InitValidatePayload) -> InitValidateResponse:
-    """Validate initialization password."""
-    tenant_count = TenantService.get_tenant_count()
-    if tenant_count > 0:
-        raise AlreadySetupError()
+@console_ns.route("/init")
+class InitValidateAPI(Resource):
+    @console_ns.doc("get_init_status")
+    @console_ns.doc(description="Get initialization validation status")
+    @console_ns.response(
+        200,
+        "Success",
+        model=console_ns.model(
+            "InitStatusResponse",
+            {"status": fields.String(description="Initialization status", enum=["finished", "not_started"])},
+        ),
+    )
+    def get(self):
+        """Get initialization validation status"""
+        init_status = get_init_validate_status()
+        if init_status:
+            return {"status": "finished"}
+        return {"status": "not_started"}

-    if payload.password != os.environ.get("INIT_PASSWORD"):
-        session["is_init_validated"] = False
-        raise InitValidateFailedError()
+    @console_ns.doc("validate_init_password")
+    @console_ns.doc(description="Validate initialization password for self-hosted edition")
+    @console_ns.expect(console_ns.models[InitValidatePayload.__name__])
+    @console_ns.response(
+        201,
+        "Success",
+        model=console_ns.model("InitValidateResponse", {"result": fields.String(description="Operation result")}),
+    )
+    @console_ns.response(400, "Already setup or validation failed")
+    @only_edition_self_hosted
+    def post(self):
+        """Validate initialization password"""
+        # is tenant created
+        tenant_count = TenantService.get_tenant_count()
+        if tenant_count > 0:
+            raise AlreadySetupError()

-    session["is_init_validated"] = True
-    return InitValidateResponse(result="success")
+        payload = InitValidatePayload.model_validate(console_ns.payload)
+        input_password = payload.password
+
+        if input_password != os.environ.get("INIT_PASSWORD"):
+            session["is_init_validated"] = False
+            raise InitValidateFailedError()
+
+        session["is_init_validated"] = True
+        return {"result": "success"}, 201


-def get_init_validate_status() -> bool:
+def get_init_validate_status():
    if dify_config.EDITION == "SELF_HOSTED":
        if os.environ.get("INIT_PASSWORD"):
            if session.get("is_init_validated"):
                return True

            with Session(db.engine) as db_session:
-                return db_session.execute(select(DifySetup)).scalar_one_or_none() is not None
+                return db_session.execute(select(DifySetup)).scalar_one_or_none()

    return True
@@ -1,6 +1,7 @@
 import urllib.parse

 import httpx
+from flask_restx import Resource
 from pydantic import BaseModel, Field

 import services
@@ -10,7 +11,7 @@ from controllers.common.errors import (
    RemoteFileUploadError,
    UnsupportedFileTypeError,
 )
-from controllers.fastopenapi import console_router
+from controllers.common.schema import register_schema_models
 from core.file import helpers as file_helpers
 from core.helper import ssrf_proxy
 from extensions.ext_database import db
@@ -18,74 +19,84 @@ from fields.file_fields import FileWithSignedUrl, RemoteFileInfo
 from libs.login import current_account_with_tenant
 from services.file_service import FileService

+from . import console_ns
+
+register_schema_models(console_ns, RemoteFileInfo, FileWithSignedUrl)
+
+
+@console_ns.route("/remote-files/<path:url>")
+class RemoteFileInfoApi(Resource):
+    @console_ns.response(200, "Remote file info", console_ns.models[RemoteFileInfo.__name__])
+    def get(self, url):
+        decoded_url = urllib.parse.unquote(url)
+        resp = ssrf_proxy.head(decoded_url)
+        if resp.status_code != httpx.codes.OK:
+            # failed back to get method
+            resp = ssrf_proxy.get(decoded_url, timeout=3)
+        resp.raise_for_status()
+        info = RemoteFileInfo(
+            file_type=resp.headers.get("Content-Type", "application/octet-stream"),
+            file_length=int(resp.headers.get("Content-Length", 0)),
+        )
+        return info.model_dump(mode="json")
+

 class RemoteFileUploadPayload(BaseModel):
    url: str = Field(..., description="URL to fetch")


-@console_router.get(
-    "/remote-files/<path:url>",
-    response_model=RemoteFileInfo,
-    tags=["console"],
+console_ns.schema_model(
+    RemoteFileUploadPayload.__name__,
+    RemoteFileUploadPayload.model_json_schema(ref_template="#/definitions/{model}"),
 )
-def get_remote_file_info(url: str) -> RemoteFileInfo:
-    decoded_url = urllib.parse.unquote(url)
-    resp = ssrf_proxy.head(decoded_url)
-    if resp.status_code != httpx.codes.OK:
-        resp = ssrf_proxy.get(decoded_url, timeout=3)
-    resp.raise_for_status()
-    return RemoteFileInfo(
-        file_type=resp.headers.get("Content-Type", "application/octet-stream"),
-        file_length=int(resp.headers.get("Content-Length", 0)),
-    )


-@console_router.post(
-    "/remote-files/upload",
-    response_model=FileWithSignedUrl,
-    tags=["console"],
-    status_code=201,
-)
-def upload_remote_file(payload: RemoteFileUploadPayload) -> FileWithSignedUrl:
-    url = payload.url
+@console_ns.route("/remote-files/upload")
+class RemoteFileUploadApi(Resource):
+    @console_ns.expect(console_ns.models[RemoteFileUploadPayload.__name__])
+    @console_ns.response(201, "Remote file uploaded", console_ns.models[FileWithSignedUrl.__name__])
+    def post(self):
+        args = RemoteFileUploadPayload.model_validate(console_ns.payload)
+        url = args.url

-    try:
-        resp = ssrf_proxy.head(url=url)
-        if resp.status_code != httpx.codes.OK:
-            resp = ssrf_proxy.get(url=url, timeout=3, follow_redirects=True)
-        if resp.status_code != httpx.codes.OK:
-            raise RemoteFileUploadError(f"Failed to fetch file from {url}: {resp.text}")
-    except httpx.RequestError as e:
-        raise RemoteFileUploadError(f"Failed to fetch file from {url}: {str(e)}")
+        try:
+            resp = ssrf_proxy.head(url=url)
+            if resp.status_code != httpx.codes.OK:
+                resp = ssrf_proxy.get(url=url, timeout=3, follow_redirects=True)
+            if resp.status_code != httpx.codes.OK:
+                raise RemoteFileUploadError(f"Failed to fetch file from {url}: {resp.text}")
+        except httpx.RequestError as e:
+            raise RemoteFileUploadError(f"Failed to fetch file from {url}: {str(e)}")

-    file_info = helpers.guess_file_info_from_response(resp)
+        file_info = helpers.guess_file_info_from_response(resp)

-    if not FileService.is_file_size_within_limit(extension=file_info.extension, file_size=file_info.size):
-        raise FileTooLargeError
+        if not FileService.is_file_size_within_limit(extension=file_info.extension, file_size=file_info.size):
+            raise FileTooLargeError

-    content = resp.content if resp.request.method == "GET" else ssrf_proxy.get(url).content
+        content = resp.content if resp.request.method == "GET" else ssrf_proxy.get(url).content

-    try:
-        user, _ = current_account_with_tenant()
-        upload_file = FileService(db.engine).upload_file(
-            filename=file_info.filename,
-            content=content,
-            mimetype=file_info.mimetype,
-            user=user,
-            source_url=url,
+        try:
+            user, _ = current_account_with_tenant()
+            upload_file = FileService(db.engine).upload_file(
+                filename=file_info.filename,
+                content=content,
+                mimetype=file_info.mimetype,
+                user=user,
+                source_url=url,
+            )
+        except services.errors.file.FileTooLargeError as file_too_large_error:
+            raise FileTooLargeError(file_too_large_error.description)
+        except services.errors.file.UnsupportedFileTypeError:
+            raise UnsupportedFileTypeError()
+
+        payload = FileWithSignedUrl(
+            id=upload_file.id,
+            name=upload_file.name,
+            size=upload_file.size,
+            extension=upload_file.extension,
+            url=file_helpers.get_signed_file_url(upload_file_id=upload_file.id),
+            mime_type=upload_file.mime_type,
+            created_by=upload_file.created_by,
+            created_at=int(upload_file.created_at.timestamp()),
        )
-    except services.errors.file.FileTooLargeError as file_too_large_error:
-        raise FileTooLargeError(file_too_large_error.description)
-    except services.errors.file.UnsupportedFileTypeError:
-        raise UnsupportedFileTypeError()
-
-    return FileWithSignedUrl(
-        id=upload_file.id,
-        name=upload_file.name,
-        size=upload_file.size,
-        extension=upload_file.extension,
-        url=file_helpers.get_signed_file_url(upload_file_id=upload_file.id),
-        mime_type=upload_file.mime_type,
-        created_by=upload_file.created_by,
-        created_at=int(upload_file.created_at.timestamp()),
-    )
+        return payload.model_dump(mode="json"), 201
@@ -1,27 +1,17 @@
 from typing import Literal

 from flask import request
-from flask_restx import Namespace, Resource, fields, marshal_with
+from flask_restx import Resource, 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 fields.tag_fields import dataset_tag_fields
 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)
@@ -12,7 +12,6 @@ from sqlalchemy.orm import Session

 from configs import dify_config
 from constants.languages import supported_language
-from controllers.common.schema import register_schema_models
 from controllers.console import console_ns
 from controllers.console.auth.error import (
    EmailAlreadyInUseError,
@@ -38,7 +37,7 @@ from controllers.console.wraps import (
    setup_required,
 )
 from extensions.ext_database import db
-from fields.member_fields import Account as AccountResponse
+from fields.member_fields import account_fields
 from libs.datetime_utils import naive_utc_now
 from libs.helper import EmailStr, TimestampField, extract_remote_ip, timezone
 from libs.login import current_account_with_tenant, login_required
@@ -171,12 +170,6 @@ reg(ChangeEmailSendPayload)
 reg(ChangeEmailValidityPayload)
 reg(ChangeEmailResetPayload)
 reg(CheckEmailUniquePayload)
-register_schema_models(console_ns, AccountResponse)
-
-
-def _serialize_account(account) -> dict:
-    return AccountResponse.model_validate(account, from_attributes=True).model_dump(mode="json")
-

 integrate_fields = {
    "provider": fields.String,
@@ -243,11 +236,11 @@ class AccountProfileApi(Resource):
    @setup_required
    @login_required
    @account_initialization_required
-    @console_ns.response(200, "Success", console_ns.models[AccountResponse.__name__])
+    @marshal_with(account_fields)
    @enterprise_license_required
    def get(self):
        current_user, _ = current_account_with_tenant()
-        return _serialize_account(current_user)
+        return current_user


@console_ns.route("/account/name")
@@ -256,14 +249,14 @@ class AccountNameApi(Resource):
    @setup_required
    @login_required
    @account_initialization_required
-    @console_ns.response(200, "Success", console_ns.models[AccountResponse.__name__])
+    @marshal_with(account_fields)
    def post(self):
        current_user, _ = current_account_with_tenant()
        payload = console_ns.payload or {}
        args = AccountNamePayload.model_validate(payload)
        updated_account = AccountService.update_account(current_user, name=args.name)

-        return _serialize_account(updated_account)
+        return updated_account


@console_ns.route("/account/avatar")
@@ -272,7 +265,7 @@ class AccountAvatarApi(Resource):
    @setup_required
    @login_required
    @account_initialization_required
-    @console_ns.response(200, "Success", console_ns.models[AccountResponse.__name__])
+    @marshal_with(account_fields)
    def post(self):
        current_user, _ = current_account_with_tenant()
        payload = console_ns.payload or {}
@@ -280,7 +273,7 @@ class AccountAvatarApi(Resource):

        updated_account = AccountService.update_account(current_user, avatar=args.avatar)

-        return _serialize_account(updated_account)
+        return updated_account


@console_ns.route("/account/interface-language")
@@ -289,7 +282,7 @@ class AccountInterfaceLanguageApi(Resource):
    @setup_required
    @login_required
    @account_initialization_required
-    @console_ns.response(200, "Success", console_ns.models[AccountResponse.__name__])
+    @marshal_with(account_fields)
    def post(self):
        current_user, _ = current_account_with_tenant()
        payload = console_ns.payload or {}
@@ -297,7 +290,7 @@ class AccountInterfaceLanguageApi(Resource):

        updated_account = AccountService.update_account(current_user, interface_language=args.interface_language)

-        return _serialize_account(updated_account)
+        return updated_account


@console_ns.route("/account/interface-theme")
@@ -306,7 +299,7 @@ class AccountInterfaceThemeApi(Resource):
    @setup_required
    @login_required
    @account_initialization_required
-    @console_ns.response(200, "Success", console_ns.models[AccountResponse.__name__])
+    @marshal_with(account_fields)
    def post(self):
        current_user, _ = current_account_with_tenant()
        payload = console_ns.payload or {}
@@ -314,7 +307,7 @@ class AccountInterfaceThemeApi(Resource):

        updated_account = AccountService.update_account(current_user, interface_theme=args.interface_theme)

-        return _serialize_account(updated_account)
+        return updated_account


@console_ns.route("/account/timezone")
@@ -323,7 +316,7 @@ class AccountTimezoneApi(Resource):
    @setup_required
    @login_required
    @account_initialization_required
-    @console_ns.response(200, "Success", console_ns.models[AccountResponse.__name__])
+    @marshal_with(account_fields)
    def post(self):
        current_user, _ = current_account_with_tenant()
        payload = console_ns.payload or {}
@@ -331,7 +324,7 @@ class AccountTimezoneApi(Resource):

        updated_account = AccountService.update_account(current_user, timezone=args.timezone)

-        return _serialize_account(updated_account)
+        return updated_account


@console_ns.route("/account/password")
@@ -340,7 +333,7 @@ class AccountPasswordApi(Resource):
    @setup_required
    @login_required
    @account_initialization_required
-    @console_ns.response(200, "Success", console_ns.models[AccountResponse.__name__])
+    @marshal_with(account_fields)
    def post(self):
        current_user, _ = current_account_with_tenant()
        payload = console_ns.payload or {}
@@ -351,7 +344,7 @@ class AccountPasswordApi(Resource):
        except ServiceCurrentPasswordIncorrectError:
            raise CurrentPasswordIncorrectError()

-        return _serialize_account(current_user)
+        return {"result": "success"}


@console_ns.route("/account/integrates")
@@ -627,7 +620,7 @@ class ChangeEmailResetApi(Resource):
    @setup_required
    @login_required
    @account_initialization_required
-    @console_ns.response(200, "Success", console_ns.models[AccountResponse.__name__])
+    @marshal_with(account_fields)
    def post(self):
        payload = console_ns.payload or {}
        args = ChangeEmailResetPayload.model_validate(payload)
@@ -656,7 +649,7 @@ class ChangeEmailResetApi(Resource):
            email=normalized_new_email,
        )

-        return _serialize_account(updated_account)
+        return updated_account


@console_ns.route("/account/change-email/check-email-unique")
@@ -1,10 +1,9 @@
 from typing import Any

 from flask import request
-from flask_restx import Resource
+from flask_restx import Resource, fields
 from pydantic import BaseModel, Field

-from controllers.common.schema import register_schema_models
 from controllers.console import console_ns
 from controllers.console.wraps import account_initialization_required, is_admin_or_owner_required, setup_required
 from core.model_runtime.utils.encoders import jsonable_encoder
@@ -39,53 +38,15 @@ class EndpointListForPluginQuery(EndpointListQuery):
    plugin_id: str


-class EndpointCreateResponse(BaseModel):
-    success: bool = Field(description="Operation success")
-
-
-class EndpointListResponse(BaseModel):
-    endpoints: list[dict[str, Any]] = Field(description="Endpoint information")
-
-
-class PluginEndpointListResponse(BaseModel):
-    endpoints: list[dict[str, Any]] = Field(description="Endpoint information")
-
-
-class EndpointDeleteResponse(BaseModel):
-    success: bool = Field(description="Operation success")
-
-
-class EndpointUpdateResponse(BaseModel):
-    success: bool = Field(description="Operation success")
-
-
-class EndpointEnableResponse(BaseModel):
-    success: bool = Field(description="Operation success")
-
-
-class EndpointDisableResponse(BaseModel):
-    success: bool = Field(description="Operation success")
-
-
 def reg(cls: type[BaseModel]):
    console_ns.schema_model(cls.__name__, cls.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0))


-register_schema_models(
-    console_ns,
-    EndpointCreatePayload,
-    EndpointIdPayload,
-    EndpointUpdatePayload,
-    EndpointListQuery,
-    EndpointListForPluginQuery,
-    EndpointCreateResponse,
-    EndpointListResponse,
-    PluginEndpointListResponse,
-    EndpointDeleteResponse,
-    EndpointUpdateResponse,
-    EndpointEnableResponse,
-    EndpointDisableResponse,
-)
+reg(EndpointCreatePayload)
+reg(EndpointIdPayload)
+reg(EndpointUpdatePayload)
+reg(EndpointListQuery)
+reg(EndpointListForPluginQuery)


@console_ns.route("/workspaces/current/endpoints/create")
@@ -96,7 +57,7 @@ class EndpointCreateApi(Resource):
    @console_ns.response(
        200,
        "Endpoint created successfully",
-        console_ns.models[EndpointCreateResponse.__name__],
+        console_ns.model("EndpointCreateResponse", {"success": fields.Boolean(description="Operation success")}),
    )
    @console_ns.response(403, "Admin privileges required")
    @setup_required
@@ -130,7 +91,9 @@ class EndpointListApi(Resource):
    @console_ns.response(
        200,
        "Success",
-        console_ns.models[EndpointListResponse.__name__],
+        console_ns.model(
+            "EndpointListResponse", {"endpoints": fields.List(fields.Raw(description="Endpoint information"))}
+        ),
    )
    @setup_required
    @login_required
@@ -163,7 +126,9 @@ class EndpointListForSinglePluginApi(Resource):
    @console_ns.response(
        200,
        "Success",
-        console_ns.models[PluginEndpointListResponse.__name__],
+        console_ns.model(
+            "PluginEndpointListResponse", {"endpoints": fields.List(fields.Raw(description="Endpoint information"))}
+        ),
    )
    @setup_required
    @login_required
@@ -198,7 +163,7 @@ class EndpointDeleteApi(Resource):
    @console_ns.response(
        200,
        "Endpoint deleted successfully",
-        console_ns.models[EndpointDeleteResponse.__name__],
+        console_ns.model("EndpointDeleteResponse", {"success": fields.Boolean(description="Operation success")}),
    )
    @console_ns.response(403, "Admin privileges required")
    @setup_required
@@ -225,7 +190,7 @@ class EndpointUpdateApi(Resource):
    @console_ns.response(
        200,
        "Endpoint updated successfully",
-        console_ns.models[EndpointUpdateResponse.__name__],
+        console_ns.model("EndpointUpdateResponse", {"success": fields.Boolean(description="Operation success")}),
    )
    @console_ns.response(403, "Admin privileges required")
    @setup_required
@@ -256,7 +221,7 @@ class EndpointEnableApi(Resource):
    @console_ns.response(
        200,
        "Endpoint enabled successfully",
-        console_ns.models[EndpointEnableResponse.__name__],
+        console_ns.model("EndpointEnableResponse", {"success": fields.Boolean(description="Operation success")}),
    )
    @console_ns.response(403, "Admin privileges required")
    @setup_required
@@ -283,7 +248,7 @@ class EndpointDisableApi(Resource):
    @console_ns.response(
        200,
        "Endpoint disabled successfully",
-        console_ns.models[EndpointDisableResponse.__name__],
+        console_ns.model("EndpointDisableResponse", {"success": fields.Boolean(description="Operation success")}),
    )
    @console_ns.response(403, "Admin privileges required")
    @setup_required
@@ -1,12 +1,12 @@
 from urllib import parse

 from flask import abort, request
-from flask_restx import Resource
-from pydantic import BaseModel, Field, TypeAdapter
+from flask_restx import Resource, fields, marshal_with
+from pydantic import BaseModel, Field

 import services
 from configs import dify_config
-from controllers.common.schema import register_enum_models, register_schema_models
+from controllers.common.schema import get_or_create_model, register_enum_models
 from controllers.console import console_ns
 from controllers.console.auth.error import (
    CannotTransferOwnerToSelfError,
@@ -25,7 +25,7 @@ from controllers.console.wraps import (
    setup_required,
 )
 from extensions.ext_database import db
-from fields.member_fields import AccountWithRole, AccountWithRoleList
+from fields.member_fields import account_with_role_fields, account_with_role_list_fields
 from libs.helper import extract_remote_ip
 from libs.login import current_account_with_tenant, login_required
 from models.account import Account, TenantAccountRole
@@ -69,7 +69,12 @@ reg(OwnerTransferEmailPayload)
 reg(OwnerTransferCheckPayload)
 reg(OwnerTransferPayload)
 register_enum_models(console_ns, TenantAccountRole)
-register_schema_models(console_ns, AccountWithRole, AccountWithRoleList)
+
+account_with_role_model = get_or_create_model("AccountWithRole", account_with_role_fields)
+
+account_with_role_list_fields_copy = account_with_role_list_fields.copy()
+account_with_role_list_fields_copy["accounts"] = fields.List(fields.Nested(account_with_role_model))
+account_with_role_list_model = get_or_create_model("AccountWithRoleList", account_with_role_list_fields_copy)


@console_ns.route("/workspaces/current/members")
@@ -79,15 +84,13 @@ class MemberListApi(Resource):
    @setup_required
    @login_required
    @account_initialization_required
-    @console_ns.response(200, "Success", console_ns.models[AccountWithRoleList.__name__])
+    @marshal_with(account_with_role_list_model)
    def get(self):
        current_user, _ = current_account_with_tenant()
        if not current_user.current_tenant:
            raise ValueError("No current tenant")
        members = TenantService.get_tenant_members(current_user.current_tenant)
-        member_models = TypeAdapter(list[AccountWithRole]).validate_python(members, from_attributes=True)
-        response = AccountWithRoleList(accounts=member_models)
-        return response.model_dump(mode="json"), 200
+        return {"result": "success", "accounts": members}, 200


@console_ns.route("/workspaces/current/members/invite-email")
@@ -232,15 +235,13 @@ class DatasetOperatorMemberListApi(Resource):
    @setup_required
    @login_required
    @account_initialization_required
-    @console_ns.response(200, "Success", console_ns.models[AccountWithRoleList.__name__])
+    @marshal_with(account_with_role_list_model)
    def get(self):
        current_user, _ = current_account_with_tenant()
        if not current_user.current_tenant:
            raise ValueError("No current tenant")
        members = TenantService.get_dataset_operator_members(current_user.current_tenant)
-        member_models = TypeAdapter(list[AccountWithRole]).validate_python(members, from_attributes=True)
-        response = AccountWithRoleList(accounts=member_models)
-        return response.model_dump(mode="json"), 200
+        return {"result": "success", "accounts": members}, 200


@console_ns.route("/workspaces/current/members/send-owner-transfer-confirm-email")
@@ -1,16 +1,16 @@
 from typing import Literal

 from flask import request
-from flask_restx import Resource
+from flask_restx import Namespace, Resource, fields
 from flask_restx.api import HTTPStatus
-from pydantic import BaseModel, Field, TypeAdapter
+from pydantic import BaseModel, Field

 from controllers.common.schema import register_schema_models
 from controllers.console.wraps import edit_permission_required
 from controllers.service_api import service_api_ns
 from controllers.service_api.wraps import validate_app_token
 from extensions.ext_redis import redis_client
-from fields.annotation_fields import Annotation, AnnotationList
+from fields.annotation_fields import annotation_fields, build_annotation_model
 from models.model import App
 from services.annotation_service import AppAnnotationService

@@ -26,9 +26,7 @@ class AnnotationReplyActionPayload(BaseModel):
    embedding_model_name: str = Field(description="Embedding model name")


-register_schema_models(
-    service_api_ns, AnnotationCreatePayload, AnnotationReplyActionPayload, Annotation, AnnotationList
-)
+register_schema_models(service_api_ns, AnnotationCreatePayload, AnnotationReplyActionPayload)


@service_api_ns.route("/apps/annotation-reply/<string:action>")
@@ -47,11 +45,10 @@ class AnnotationReplyActionApi(Resource):
    def post(self, app_model: App, action: Literal["enable", "disable"]):
        """Enable or disable annotation reply feature."""
        args = AnnotationReplyActionPayload.model_validate(service_api_ns.payload or {}).model_dump()
-        match action:
-            case "enable":
-                result = AppAnnotationService.enable_app_annotation(args, app_model.id)
-            case "disable":
-                result = AppAnnotationService.disable_app_annotation(app_model.id)
+        if action == "enable":
+            result = AppAnnotationService.enable_app_annotation(args, app_model.id)
+        elif action == "disable":
+            result = AppAnnotationService.disable_app_annotation(app_model.id)
        return result, 200


@@ -85,6 +82,23 @@ class AnnotationReplyActionStatusApi(Resource):
        return {"job_id": job_id, "job_status": job_status, "error_msg": error_msg}, 200


+# Define annotation list response model
+annotation_list_fields = {
+    "data": fields.List(fields.Nested(annotation_fields)),
+    "has_more": fields.Boolean,
+    "limit": fields.Integer,
+    "total": fields.Integer,
+    "page": fields.Integer,
+}
+
+
+def build_annotation_list_model(api_or_ns: Namespace):
+    """Build the annotation list model for the API or Namespace."""
+    copied_annotation_list_fields = annotation_list_fields.copy()
+    copied_annotation_list_fields["data"] = fields.List(fields.Nested(build_annotation_model(api_or_ns)))
+    return api_or_ns.model("AnnotationList", copied_annotation_list_fields)
+
+
@service_api_ns.route("/apps/annotations")
 class AnnotationListApi(Resource):
    @service_api_ns.doc("list_annotations")
@@ -95,12 +109,8 @@ class AnnotationListApi(Resource):
            401: "Unauthorized - invalid API token",
        }
    )
-    @service_api_ns.response(
-        200,
-        "Annotations retrieved successfully",
-        service_api_ns.models[AnnotationList.__name__],
-    )
    @validate_app_token
+    @service_api_ns.marshal_with(build_annotation_list_model(service_api_ns))
    def get(self, app_model: App):
        """List annotations for the application."""
        page = request.args.get("page", default=1, type=int)
@@ -108,15 +118,13 @@ class AnnotationListApi(Resource):
        keyword = request.args.get("keyword", default="", type=str)

        annotation_list, total = AppAnnotationService.get_annotation_list_by_app_id(app_model.id, page, limit, keyword)
-        annotation_models = TypeAdapter(list[Annotation]).validate_python(annotation_list, from_attributes=True)
-        response = AnnotationList(
-            data=annotation_models,
-            has_more=len(annotation_list) == limit,
-            limit=limit,
-            total=total,
-            page=page,
-        )
-        return response.model_dump(mode="json")
+        return {
+            "data": annotation_list,
+            "has_more": len(annotation_list) == limit,
+            "limit": limit,
+            "total": total,
+            "page": page,
+        }

    @service_api_ns.expect(service_api_ns.models[AnnotationCreatePayload.__name__])
    @service_api_ns.doc("create_annotation")
@@ -127,18 +135,13 @@ class AnnotationListApi(Resource):
            401: "Unauthorized - invalid API token",
        }
    )
-    @service_api_ns.response(
-        HTTPStatus.CREATED,
-        "Annotation created successfully",
-        service_api_ns.models[Annotation.__name__],
-    )
    @validate_app_token
+    @service_api_ns.marshal_with(build_annotation_model(service_api_ns), code=HTTPStatus.CREATED)
    def post(self, app_model: App):
        """Create a new annotation."""
        args = AnnotationCreatePayload.model_validate(service_api_ns.payload or {}).model_dump()
        annotation = AppAnnotationService.insert_app_annotation_directly(args, app_model.id)
-        response = Annotation.model_validate(annotation, from_attributes=True)
-        return response.model_dump(mode="json"), HTTPStatus.CREATED
+        return annotation, 201


@service_api_ns.route("/apps/annotations/<uuid:annotation_id>")
@@ -155,19 +158,14 @@ class AnnotationUpdateDeleteApi(Resource):
            404: "Annotation not found",
        }
    )
-    @service_api_ns.response(
-        200,
-        "Annotation updated successfully",
-        service_api_ns.models[Annotation.__name__],
-    )
    @validate_app_token
    @edit_permission_required
+    @service_api_ns.marshal_with(build_annotation_model(service_api_ns))
    def put(self, app_model: App, annotation_id: str):
        """Update an existing annotation."""
        args = AnnotationCreatePayload.model_validate(service_api_ns.payload or {}).model_dump()
        annotation = AppAnnotationService.update_app_annotation_directly(args, app_model.id, annotation_id)
-        response = Annotation.model_validate(annotation, from_attributes=True)
-        return response.model_dump(mode="json")
+        return annotation

    @service_api_ns.doc("delete_annotation")
    @service_api_ns.doc(description="Delete an annotation")
@@ -30,7 +30,6 @@ from core.errors.error import (
 from core.helper.trace_id_helper import get_external_trace_id
 from core.model_runtime.errors.invoke import InvokeError
 from libs import helper
-from libs.helper import UUIDStrOrEmpty
 from models.model import App, AppMode, EndUser
 from services.app_generate_service import AppGenerateService
 from services.app_task_service import AppTaskService
@@ -53,7 +52,7 @@ class ChatRequestPayload(BaseModel):
    query: str
    files: list[dict[str, Any]] | None = None
    response_mode: Literal["blocking", "streaming"] | None = None
-    conversation_id: UUIDStrOrEmpty | None = Field(default=None, description="Conversation UUID")
+    conversation_id: str | None = Field(default=None, description="Conversation UUID")
    retriever_from: str = Field(default="dev")
    auto_generate_name: bool = Field(default=True, description="Auto generate conversation name")
    workflow_id: str | None = Field(default=None, description="Workflow ID for advanced chat")
@@ -1,4 +1,5 @@
 from typing import Any, Literal
+from uuid import UUID

 from flask import request
 from flask_restx import Resource
@@ -22,13 +23,12 @@ from fields.conversation_variable_fields import (
    build_conversation_variable_infinite_scroll_pagination_model,
    build_conversation_variable_model,
 )
-from libs.helper import UUIDStrOrEmpty
 from models.model import App, AppMode, EndUser
 from services.conversation_service import ConversationService


 class ConversationListQuery(BaseModel):
-    last_id: UUIDStrOrEmpty | None = Field(default=None, description="Last conversation ID for pagination")
+    last_id: UUID | None = Field(default=None, description="Last conversation ID for pagination")
    limit: int = Field(default=20, ge=1, le=100, description="Number of conversations to return")
    sort_by: Literal["created_at", "-created_at", "updated_at", "-updated_at"] = Field(
        default="-updated_at", description="Sort order for conversations"
@@ -48,7 +48,7 @@ class ConversationRenamePayload(BaseModel):


 class ConversationVariablesQuery(BaseModel):
-    last_id: UUIDStrOrEmpty | None = Field(default=None, description="Last variable ID for pagination")
+    last_id: UUID | None = Field(default=None, description="Last variable ID for pagination")
    limit: int = Field(default=20, ge=1, le=100, description="Number of variables to return")
    variable_name: str | None = Field(
        default=None, description="Filter variables by name", min_length=1, max_length=255
@@ -1,5 +1,6 @@
 import logging
 from typing import Literal
+from uuid import UUID

 from flask import request
 from flask_restx import Resource
@@ -14,7 +15,6 @@ from controllers.service_api.wraps import FetchUserArg, WhereisUserArg, validate
 from core.app.entities.app_invoke_entities import InvokeFrom
 from fields.conversation_fields import ResultResponse
 from fields.message_fields import MessageInfiniteScrollPagination, MessageListItem
-from libs.helper import UUIDStrOrEmpty
 from models.model import App, AppMode, EndUser
 from services.errors.message import (
    FirstMessageNotExistsError,
@@ -27,8 +27,8 @@ logger = logging.getLogger(__name__)


 class MessageListQuery(BaseModel):
-    conversation_id: UUIDStrOrEmpty
-    first_id: UUIDStrOrEmpty | None = None
+    conversation_id: UUID
+    first_id: UUID | None = None
    limit: int = Field(default=20, ge=1, le=100, description="Number of messages to return")


@@ -17,7 +17,7 @@ from controllers.service_api.wraps import (
 from core.model_runtime.entities.model_entities import ModelType
 from core.provider_manager import ProviderManager
 from fields.dataset_fields import dataset_detail_fields
-from fields.tag_fields import DataSetTag
+from fields.tag_fields import build_dataset_tag_fields
 from libs.login import current_user
 from models.account import Account
 from models.dataset import DatasetPermissionEnum
@@ -46,7 +46,6 @@ class DatasetCreatePayload(BaseModel):
    retrieval_model: RetrievalModel | None = None
    embedding_model: str | None = None
    embedding_model_provider: str | None = None
-    summary_index_setting: dict | None = None


 class DatasetUpdatePayload(BaseModel):
@@ -114,7 +113,6 @@ register_schema_models(
    TagBindingPayload,
    TagUnbindingPayload,
    DatasetListQuery,
-    DataSetTag,
 )


@@ -219,7 +217,6 @@ class DatasetListApi(DatasetApiResource):
                embedding_model_provider=payload.embedding_model_provider,
                embedding_model_name=payload.embedding_model,
                retrieval_model=payload.retrieval_model,
-                summary_index_setting=payload.summary_index_setting,
            )
        except services.errors.dataset.DatasetNameDuplicateError:
            raise DatasetNameDuplicateError()
@@ -481,14 +478,15 @@ class DatasetTagsApi(DatasetApiResource):
            401: "Unauthorized - invalid API token",
        }
    )
+    @service_api_ns.marshal_with(build_dataset_tag_fields(service_api_ns))
    def get(self, _):
        """Get all knowledge type tags."""
        assert isinstance(current_user, Account)
        cid = current_user.current_tenant_id
        assert cid is not None
        tags = TagService.get_tags("knowledge", cid)
-        tag_models = TypeAdapter(list[DataSetTag]).validate_python(tags, from_attributes=True)
-        return [tag.model_dump(mode="json") for tag in tag_models], 200
+
+        return tags, 200

    @service_api_ns.expect(service_api_ns.models[TagCreatePayload.__name__])
    @service_api_ns.doc("create_dataset_tag")
@@ -500,6 +498,7 @@ class DatasetTagsApi(DatasetApiResource):
            403: "Forbidden - insufficient permissions",
        }
    )
+    @service_api_ns.marshal_with(build_dataset_tag_fields(service_api_ns))
    def post(self, _):
        """Add a knowledge type tag."""
        assert isinstance(current_user, Account)
@@ -509,9 +508,7 @@ class DatasetTagsApi(DatasetApiResource):
        payload = TagCreatePayload.model_validate(service_api_ns.payload or {})
        tag = TagService.save_tags({"name": payload.name, "type": "knowledge"})

-        response = DataSetTag.model_validate(
-            {"id": tag.id, "name": tag.name, "type": tag.type, "binding_count": 0}
-        ).model_dump(mode="json")
+        response = {"id": tag.id, "name": tag.name, "type": tag.type, "binding_count": 0}
        return response, 200

    @service_api_ns.expect(service_api_ns.models[TagUpdatePayload.__name__])
@@ -524,6 +521,7 @@ class DatasetTagsApi(DatasetApiResource):
            403: "Forbidden - insufficient permissions",
        }
    )
+    @service_api_ns.marshal_with(build_dataset_tag_fields(service_api_ns))
    def patch(self, _):
        assert isinstance(current_user, Account)
        if not (current_user.has_edit_permission or current_user.is_dataset_editor):
@@ -536,9 +534,8 @@ class DatasetTagsApi(DatasetApiResource):

        binding_count = TagService.get_tag_binding_count(tag_id)

-        response = DataSetTag.model_validate(
-            {"id": tag.id, "name": tag.name, "type": tag.type, "binding_count": binding_count}
-        ).model_dump(mode="json")
+        response = {"id": tag.id, "name": tag.name, "type": tag.type, "binding_count": binding_count}
+
        return response, 200

    @service_api_ns.expect(service_api_ns.models[TagDeletePayload.__name__])
@@ -45,7 +45,6 @@ from services.entities.knowledge_entities.knowledge_entities import (
    Segmentation,
 )
 from services.file_service import FileService
-from services.summary_index_service import SummaryIndexService


 class DocumentTextCreatePayload(BaseModel):
@@ -509,12 +508,6 @@ class DocumentListApi(DatasetApiResource):
        )
        documents = paginated_documents.items

-        DocumentService.enrich_documents_with_summary_index_status(
-            documents=documents,
-            dataset=dataset,
-            tenant_id=tenant_id,
-        )
-
        response = {
            "data": marshal(documents, document_fields),
            "has_more": len(documents) == query_params.limit,
@@ -619,16 +612,6 @@ class DocumentApi(DatasetApiResource):
        if metadata not in self.METADATA_CHOICES:
            raise InvalidMetadataError(f"Invalid metadata value: {metadata}")

-        # Calculate summary_index_status if needed
-        summary_index_status = None
-        has_summary_index = dataset.summary_index_setting and dataset.summary_index_setting.get("enable") is True
-        if has_summary_index and document.need_summary is True:
-            summary_index_status = SummaryIndexService.get_document_summary_index_status(
-                document_id=document_id,
-                dataset_id=dataset_id,
-                tenant_id=tenant_id,
-            )
-
        if metadata == "only":
            response = {"id": document.id, "doc_type": document.doc_type, "doc_metadata": document.doc_metadata_details}
        elif metadata == "without":
@@ -663,8 +646,6 @@ class DocumentApi(DatasetApiResource):
                "display_status": document.display_status,
                "doc_form": document.doc_form,
                "doc_language": document.doc_language,
-                "summary_index_status": summary_index_status,
-                "need_summary": document.need_summary if document.need_summary is not None else False,
            }
        else:
            dataset_process_rules = DatasetService.get_process_rules(dataset_id)
@@ -700,8 +681,6 @@ class DocumentApi(DatasetApiResource):
                "display_status": document.display_status,
                "doc_form": document.doc_form,
                "doc_language": document.doc_language,
-                "summary_index_status": summary_index_status,
-                "need_summary": document.need_summary if document.need_summary is not None else False,
            }

        return response
@@ -1,10 +1,7 @@
-from controllers.common.schema import register_schema_model
-from controllers.console.datasets.hit_testing_base import DatasetsHitTestingBase, HitTestingPayload
+from controllers.console.datasets.hit_testing_base import DatasetsHitTestingBase
 from controllers.service_api import service_api_ns
 from controllers.service_api.wraps import DatasetApiResource, cloud_edition_billing_rate_limit_check

-register_schema_model(service_api_ns, HitTestingPayload)
-

@service_api_ns.route("/datasets/<uuid:dataset_id>/hit-testing", "/datasets/<uuid:dataset_id>/retrieve")
 class HitTestingApi(DatasetApiResource, DatasetsHitTestingBase):
@@ -18,7 +15,6 @@ class HitTestingApi(DatasetApiResource, DatasetsHitTestingBase):
            404: "Dataset not found",
        }
    )
-    @service_api_ns.expect(service_api_ns.models[HitTestingPayload.__name__])
    @cloud_edition_billing_rate_limit_check("knowledge", "dataset")
    def post(self, tenant_id, dataset_id):
        """Perform hit testing on a dataset.
@@ -168,11 +168,10 @@ class DatasetMetadataBuiltInFieldActionServiceApi(DatasetApiResource):
            raise NotFound("Dataset not found.")
        DatasetService.check_dataset_permission(dataset, current_user)

-        match action:
-            case "enable":
-                MetadataService.enable_built_in_field(dataset)
-            case "disable":
-                MetadataService.disable_built_in_field(dataset)
+        if action == "enable":
+            MetadataService.enable_built_in_field(dataset)
+        elif action == "disable":
+            MetadataService.disable_built_in_field(dataset)
        return {"result": "success"}, 200


@@ -73,14 +73,14 @@ def validate_app_token(view: Callable[P, R] | None = None, *, fetch_user_arg: Fe

            # If caller needs end-user context, attach EndUser to current_user
            if fetch_user_arg:
-                user_id = None
-                match fetch_user_arg.fetch_from:
-                    case WhereisUserArg.QUERY:
-                        user_id = request.args.get("user")
-                    case WhereisUserArg.JSON:
-                        user_id = request.get_json().get("user")
-                    case WhereisUserArg.FORM:
-                        user_id = request.form.get("user")
+                if fetch_user_arg.fetch_from == WhereisUserArg.QUERY:
+                    user_id = request.args.get("user")
+                elif fetch_user_arg.fetch_from == WhereisUserArg.JSON:
+                    user_id = request.get_json().get("user")
+                elif fetch_user_arg.fetch_from == WhereisUserArg.FORM:
+                    user_id = request.form.get("user")
+                else:
+                    user_id = None

                if not user_id and fetch_user_arg.required:
                    raise ValueError("Arg user must be provided.")
@@ -79,7 +79,7 @@ class BaseAgentRunner(AppRunner):
        self.model_instance = model_instance

        # init callback
-        self.agent_callback = DifyAgentCallbackHandler(tenant_id=tenant_id)
+        self.agent_callback = DifyAgentCallbackHandler()
        # init dataset tools
        hit_callback = DatasetIndexToolCallbackHandler(
            queue_manager=queue_manager,
@@ -14,17 +14,16 @@ class AgentConfigManager:
            agent_dict = config.get("agent_mode", {})
            agent_strategy = agent_dict.get("strategy", "cot")

-            match agent_strategy:
-                case "function_call":
+            if agent_strategy == "function_call":
+                strategy = AgentEntity.Strategy.FUNCTION_CALLING
+            elif agent_strategy in {"cot", "react"}:
+                strategy = AgentEntity.Strategy.CHAIN_OF_THOUGHT
+            else:
+                # old configs, try to detect default strategy
+                if config["model"]["provider"] == "openai":
                    strategy = AgentEntity.Strategy.FUNCTION_CALLING
-                case "cot" | "react":
+                else:
                    strategy = AgentEntity.Strategy.CHAIN_OF_THOUGHT
-                case _:
-                    # old configs, try to detect default strategy
-                    if config["model"]["provider"] == "openai":
-                        strategy = AgentEntity.Strategy.FUNCTION_CALLING
-                    else:
-                        strategy = AgentEntity.Strategy.CHAIN_OF_THOUGHT

            agent_tools = []
            for tool in agent_dict.get("tools", []):
@@ -63,8 +63,6 @@ from core.base.tts import AppGeneratorTTSPublisher, AudioTrunk
 from core.model_runtime.entities.llm_entities import LLMUsage
 from core.model_runtime.utils.encoders import jsonable_encoder
 from core.ops.ops_trace_manager import TraceQueueManager
-from core.telemetry import TelemetryContext, TelemetryEvent, TraceTaskName
-from core.telemetry import emit as telemetry_emit
 from core.workflow.enums import WorkflowExecutionStatus
 from core.workflow.nodes import NodeType
 from core.workflow.repositories.draft_variable_repository import DraftVariableSaverFactory
@@ -566,6 +564,7 @@ class AdvancedChatAppGenerateTaskPipeline(GraphRuntimeStateSupport):
        **kwargs,
    ) -> Generator[StreamResponse, None, None]:
        """Handle stop events."""
+        _ = trace_manager
        resolved_state = None
        if self._workflow_run_id:
            resolved_state = self._resolve_graph_runtime_state(graph_runtime_state)
@@ -580,7 +579,8 @@ class AdvancedChatAppGenerateTaskPipeline(GraphRuntimeStateSupport):
            )

            with self._database_session() as session:
-                self._save_message(session=session, graph_runtime_state=resolved_state, trace_manager=trace_manager)
+                # Save message
+                self._save_message(session=session, graph_runtime_state=resolved_state)

            yield workflow_finish_resp
        elif event.stopped_by in (
@@ -589,7 +589,8 @@ class AdvancedChatAppGenerateTaskPipeline(GraphRuntimeStateSupport):
        ):
            # When hitting input-moderation or annotation-reply, the workflow will not start
            with self._database_session() as session:
-                self._save_message(session=session, trace_manager=trace_manager)
+                # Save message
+                self._save_message(session=session)

        yield self._message_end_to_stream_response()

@@ -598,7 +599,6 @@ class AdvancedChatAppGenerateTaskPipeline(GraphRuntimeStateSupport):
        event: QueueAdvancedChatMessageEndEvent,
        *,
        graph_runtime_state: GraphRuntimeState | None = None,
-        trace_manager: TraceQueueManager | None = None,
        **kwargs,
    ) -> Generator[StreamResponse, None, None]:
        """Handle advanced chat message end events."""
@@ -616,7 +616,7 @@ class AdvancedChatAppGenerateTaskPipeline(GraphRuntimeStateSupport):

        # Save message
        with self._database_session() as session:
-            self._save_message(session=session, graph_runtime_state=resolved_state, trace_manager=trace_manager)
+            self._save_message(session=session, graph_runtime_state=resolved_state)

        yield self._message_end_to_stream_response()

@@ -770,13 +770,7 @@ class AdvancedChatAppGenerateTaskPipeline(GraphRuntimeStateSupport):
        if self._conversation_name_generate_thread:
            logger.debug("Conversation name generation running as daemon thread")

-    def _save_message(
-        self,
-        *,
-        session: Session,
-        graph_runtime_state: GraphRuntimeState | None = None,
-        trace_manager: TraceQueueManager | None = None,
-    ):
+    def _save_message(self, *, session: Session, graph_runtime_state: GraphRuntimeState | None = None):
        message = self._get_message(session=session)

        # If there are assistant files, remove markdown image links from answer
@@ -832,22 +826,6 @@ class AdvancedChatAppGenerateTaskPipeline(GraphRuntimeStateSupport):
        ]
        session.add_all(message_files)

-        if trace_manager:
-            telemetry_emit(
-                TelemetryEvent(
-                    name=TraceTaskName.MESSAGE_TRACE,
-                    context=TelemetryContext(
-                        tenant_id=self._application_generate_entity.app_config.tenant_id,
-                        app_id=self._application_generate_entity.app_config.app_id,
-                    ),
-                    payload={
-                        "conversation_id": str(message.conversation_id),
-                        "message_id": str(message.id),
-                    },
-                ),
-                trace_manager=trace_manager,
-            )
-
    def _seed_graph_runtime_state_from_queue_manager(self) -> None:
        """Bootstrap the cached runtime state from the queue manager when present."""
        candidate = self._base_task_pipeline.queue_manager.graph_runtime_state
@@ -79,7 +79,6 @@ class AppGenerateResponseConverter(ABC):
                        "document_name": resource["document_name"],
                        "score": resource["score"],
                        "content": resource["content"],
-                        "summary": resource.get("summary"),
                    }
                )
            metadata["retriever_resources"] = updated_resources
@@ -250,7 +250,7 @@ class WorkflowResponseConverter:
            data=WorkflowFinishStreamResponse.Data(
                id=run_id,
                workflow_id=workflow_id,
-                status=status,
+                status=status.value,
                outputs=encoded_outputs,
                error=error,
                elapsed_time=elapsed_time,
@@ -340,13 +340,13 @@ class WorkflowResponseConverter:
        metadata = self._merge_metadata(event.execution_metadata, snapshot)

        if isinstance(event, QueueNodeSucceededEvent):
-            status = WorkflowNodeExecutionStatus.SUCCEEDED
+            status = WorkflowNodeExecutionStatus.SUCCEEDED.value
            error_message = event.error
        elif isinstance(event, QueueNodeFailedEvent):
-            status = WorkflowNodeExecutionStatus.FAILED
+            status = WorkflowNodeExecutionStatus.FAILED.value
            error_message = event.error
        else:
-            status = WorkflowNodeExecutionStatus.EXCEPTION
+            status = WorkflowNodeExecutionStatus.EXCEPTION.value
            error_message = event.error

        return NodeFinishStreamResponse(
@@ -413,7 +413,7 @@ class WorkflowResponseConverter:
                process_data_truncated=process_data_truncated,
                outputs=outputs,
                outputs_truncated=outputs_truncated,
-                status=WorkflowNodeExecutionStatus.RETRY,
+                status=WorkflowNodeExecutionStatus.RETRY.value,
                error=event.error,
                elapsed_time=elapsed_time,
                execution_metadata=metadata,
@@ -120,7 +120,7 @@ class PipelineGenerator(BaseAppGenerator):
                raise ValueError("Pipeline dataset is required")
        inputs: Mapping[str, Any] = args["inputs"]
        start_node_id: str = args["start_node_id"]
-        datasource_type = DatasourceProviderType(args["datasource_type"])
+        datasource_type: str = args["datasource_type"]
        datasource_info_list: list[Mapping[str, Any]] = self._format_datasource_info_list(
            datasource_type, args["datasource_info_list"], pipeline, workflow, start_node_id, user
        )
@@ -660,7 +660,7 @@ class PipelineGenerator(BaseAppGenerator):
        tenant_id: str,
        dataset_id: str,
        built_in_field_enabled: bool,
-        datasource_type: DatasourceProviderType,
+        datasource_type: str,
        datasource_info: Mapping[str, Any],
        created_from: str,
        position: int,
@@ -668,17 +668,17 @@ class PipelineGenerator(BaseAppGenerator):
        batch: str,
        document_form: str,
    ):
-        match datasource_type:
-            case DatasourceProviderType.LOCAL_FILE:
-                name = datasource_info.get("name", "untitled")
-            case DatasourceProviderType.ONLINE_DOCUMENT:
-                name = datasource_info.get("page", {}).get("page_name", "untitled")
-            case DatasourceProviderType.WEBSITE_CRAWL:
-                name = datasource_info.get("title", "untitled")
-            case DatasourceProviderType.ONLINE_DRIVE:
-                name = datasource_info.get("name", "untitled")
-            case _:
-                raise ValueError(f"Unsupported datasource type: {datasource_type}")
+        if datasource_type == "local_file":
+            name = datasource_info.get("name", "untitled")
+        elif datasource_type == "online_document":
+            name = datasource_info.get("page", {}).get("page_name", "untitled")
+        elif datasource_type == "website_crawl":
+            name = datasource_info.get("title", "untitled")
+        elif datasource_type == "online_drive":
+            name = datasource_info.get("name", "untitled")
+        else:
+            raise ValueError(f"Unsupported datasource type: {datasource_type}")
+
        document = Document(
            tenant_id=tenant_id,
            dataset_id=dataset_id,
@@ -706,7 +706,7 @@ class PipelineGenerator(BaseAppGenerator):

    def _format_datasource_info_list(
        self,
-        datasource_type: DatasourceProviderType,
+        datasource_type: str,
        datasource_info_list: list[Mapping[str, Any]],
        pipeline: Pipeline,
        workflow: Workflow,
@@ -716,7 +716,7 @@ class PipelineGenerator(BaseAppGenerator):
        """
        Format datasource info list.
        """
-        if datasource_type == DatasourceProviderType.ONLINE_DRIVE:
+        if datasource_type == "online_drive":
            all_files: list[Mapping[str, Any]] = []
            datasource_node_data = None
            datasource_nodes = workflow.graph_dict.get("nodes", [])
@@ -147,12 +147,9 @@ class WorkflowAppGenerator(BaseAppGenerator):

        inputs: Mapping[str, Any] = args["inputs"]

-        extras: dict[str, Any] = {
+        extras = {
            **extract_external_trace_id_from_args(args),
        }
-        parent_trace_context = args.get("_parent_trace_context")
-        if parent_trace_context:
-            extras["parent_trace_context"] = parent_trace_context
        workflow_run_id = str(uuid.uuid4())
        # FIXME (Yeuoly): we need to remove the SKIP_PREPARE_USER_INPUTS_KEY from the args
        # trigger shouldn't prepare user inputs
@@ -7,7 +7,7 @@ from pydantic import BaseModel, ConfigDict, Field
 from core.model_runtime.entities.llm_entities import LLMResult, LLMUsage
 from core.rag.entities.citation_metadata import RetrievalSourceMetadata
 from core.workflow.entities import AgentNodeStrategyInit
-from core.workflow.enums import WorkflowExecutionStatus, WorkflowNodeExecutionMetadataKey, WorkflowNodeExecutionStatus
+from core.workflow.enums import WorkflowNodeExecutionMetadataKey, WorkflowNodeExecutionStatus


 class AnnotationReplyAccount(BaseModel):
@@ -223,7 +223,7 @@ class WorkflowFinishStreamResponse(StreamResponse):

        id: str
        workflow_id: str
-        status: WorkflowExecutionStatus
+        status: str
        outputs: Mapping[str, Any] | None = None
        error: str | None = None
        elapsed_time: float
@@ -311,7 +311,7 @@ class NodeFinishStreamResponse(StreamResponse):
        process_data_truncated: bool = False
        outputs: Mapping[str, Any] | None = None
        outputs_truncated: bool = True
-        status: WorkflowNodeExecutionStatus
+        status: str
        error: str | None = None
        elapsed_time: float
        execution_metadata: Mapping[WorkflowNodeExecutionMetadataKey, Any] | None = None
@@ -375,7 +375,7 @@ class NodeRetryStreamResponse(StreamResponse):
        process_data_truncated: bool = False
        outputs: Mapping[str, Any] | None = None
        outputs_truncated: bool = False
-        status: WorkflowNodeExecutionStatus
+        status: str
        error: str | None = None
        elapsed_time: float
        execution_metadata: Mapping[WorkflowNodeExecutionMetadataKey, Any] | None = None
@@ -719,7 +719,7 @@ class WorkflowAppBlockingResponse(AppBlockingResponse):

        id: str
        workflow_id: str
-        status: WorkflowExecutionStatus
+        status: str
        outputs: Mapping[str, Any] | None = None
        error: str | None = None
        elapsed_time: float
@@ -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 (
@@ -54,16 +52,14 @@ from core.model_runtime.entities.message_entities import (
    TextPromptMessageContent,
 )
 from core.model_runtime.model_providers.__base.large_language_model import LargeLanguageModel
-from core.ops.ops_trace_manager import TraceQueueManager
+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.telemetry import TelemetryContext, TelemetryEvent, TraceTaskName
-from core.telemetry import emit as telemetry_emit
-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__)

@@ -413,19 +409,10 @@ class EasyUIBasedGenerateTaskPipeline(BasedGenerateTaskPipeline):
        message.message_metadata = self._task_state.metadata.model_dump_json()

        if trace_manager:
-            telemetry_emit(
-                TelemetryEvent(
-                    name=TraceTaskName.MESSAGE_TRACE,
-                    context=TelemetryContext(
-                        tenant_id=self._application_generate_entity.app_config.tenant_id,
-                        app_id=self._application_generate_entity.app_config.app_id,
-                    ),
-                    payload={
-                        "conversation_id": self._conversation_id,
-                        "message_id": self._message_id,
-                    },
-                ),
-                trace_manager=trace_manager,
+            trace_manager.add_trace_task(
+                TraceTask(
+                    TraceTaskName.MESSAGE_TRACE, conversation_id=self._conversation_id, message_id=self._message_id
+                )
            )

        message_was_created.send(
@@ -476,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)
@@ -15,7 +15,8 @@ from datetime import datetime
 from typing import Any, Union

 from core.app.entities.app_invoke_entities import AdvancedChatAppGenerateEntity, WorkflowAppGenerateEntity
-from core.ops.ops_trace_manager import TraceQueueManager
+from core.ops.entities.trace_entity import TraceTaskName
+from core.ops.ops_trace_manager import TraceQueueManager, TraceTask
 from core.workflow.constants import SYSTEM_VARIABLE_NODE_ID
 from core.workflow.entities import WorkflowExecution, WorkflowNodeExecution
 from core.workflow.enums import (
@@ -372,7 +373,6 @@ class WorkflowPersistenceLayer(GraphEngineLayer):

        self._workflow_node_execution_repository.save(domain_execution)
        self._workflow_node_execution_repository.save_execution_data(domain_execution)
-        self._enqueue_node_trace_task(domain_execution)

    def _fail_running_node_executions(self, *, error_message: str) -> None:
        now = naive_utc_now()
@@ -390,138 +390,17 @@ class WorkflowPersistenceLayer(GraphEngineLayer):

        conversation_id = self._system_variables().get(SystemVariableKey.CONVERSATION_ID.value)
        external_trace_id = None
-        parent_trace_context = None
        if isinstance(self._application_generate_entity, (WorkflowAppGenerateEntity, AdvancedChatAppGenerateEntity)):
            external_trace_id = self._application_generate_entity.extras.get("external_trace_id")
-            parent_trace_context = self._application_generate_entity.extras.get("parent_trace_context")

-        from core.telemetry import TelemetryContext, TelemetryEvent, TraceTaskName
-        from core.telemetry import emit as telemetry_emit
-
-        telemetry_emit(
-            TelemetryEvent(
-                name=TraceTaskName.WORKFLOW_TRACE,
-                context=TelemetryContext(
-                    tenant_id=self._application_generate_entity.app_config.tenant_id,
-                    user_id=self._trace_manager.user_id,
-                    app_id=self._application_generate_entity.app_config.app_id,
-                ),
-                payload={
-                    "workflow_execution": execution,
-                    "conversation_id": conversation_id,
-                    "user_id": self._trace_manager.user_id,
-                    "external_trace_id": external_trace_id,
-                    "parent_trace_context": parent_trace_context,
-                },
-            ),
-            trace_manager=self._trace_manager,
-        )
-
-    def _enqueue_node_trace_task(self, domain_execution: WorkflowNodeExecution) -> None:
-        if not self._trace_manager:
-            return
-
-        execution = self._get_workflow_execution()
-        meta = domain_execution.metadata or {}
-
-        parent_trace_context = None
-        if isinstance(self._application_generate_entity, (WorkflowAppGenerateEntity, AdvancedChatAppGenerateEntity)):
-            parent_trace_context = self._application_generate_entity.extras.get("parent_trace_context")
-
-        node_data: dict[str, Any] = {
-            "workflow_id": domain_execution.workflow_id,
-            "workflow_execution_id": execution.id_,
-            "tenant_id": self._application_generate_entity.app_config.tenant_id,
-            "app_id": self._application_generate_entity.app_config.app_id,
-            "node_execution_id": domain_execution.id,
-            "node_id": domain_execution.node_id,
-            "node_type": str(domain_execution.node_type.value),
-            "title": domain_execution.title,
-            "status": str(domain_execution.status.value),
-            "error": domain_execution.error,
-            "elapsed_time": domain_execution.elapsed_time,
-            "index": domain_execution.index,
-            "predecessor_node_id": domain_execution.predecessor_node_id,
-            "created_at": domain_execution.created_at,
-            "finished_at": domain_execution.finished_at,
-            "total_tokens": meta.get(WorkflowNodeExecutionMetadataKey.TOTAL_TOKENS, 0),
-            "prompt_tokens": meta.get(WorkflowNodeExecutionMetadataKey.PROMPT_TOKENS),
-            "completion_tokens": meta.get(WorkflowNodeExecutionMetadataKey.COMPLETION_TOKENS),
-            "total_price": meta.get(WorkflowNodeExecutionMetadataKey.TOTAL_PRICE, 0.0),
-            "currency": meta.get(WorkflowNodeExecutionMetadataKey.CURRENCY),
-            "tool_name": (meta.get(WorkflowNodeExecutionMetadataKey.TOOL_INFO) or {}).get("tool_name")
-            if isinstance(meta.get(WorkflowNodeExecutionMetadataKey.TOOL_INFO), dict)
-            else None,
-            "iteration_id": meta.get(WorkflowNodeExecutionMetadataKey.ITERATION_ID),
-            "iteration_index": meta.get(WorkflowNodeExecutionMetadataKey.ITERATION_INDEX),
-            "loop_id": meta.get(WorkflowNodeExecutionMetadataKey.LOOP_ID),
-            "loop_index": meta.get(WorkflowNodeExecutionMetadataKey.LOOP_INDEX),
-            "parallel_id": meta.get(WorkflowNodeExecutionMetadataKey.PARALLEL_ID),
-            "node_inputs": dict(domain_execution.inputs) if domain_execution.inputs else None,
-            "node_outputs": dict(domain_execution.outputs) if domain_execution.outputs else None,
-            "process_data": dict(domain_execution.process_data) if domain_execution.process_data else None,
-        }
-        node_data["invoke_from"] = self._application_generate_entity.invoke_from.value
-        node_data["user_id"] = self._system_variables().get(SystemVariableKey.USER_ID.value)
-
-        # Extract model info from process_data — LLM nodes store provider/model there,
-        if domain_execution.process_data:
-            if mp := domain_execution.process_data.get("model_provider"):
-                node_data["model_provider"] = mp
-            if mn := domain_execution.process_data.get("model_name"):
-                node_data["model_name"] = mn
-
-        if domain_execution.node_type.value == "knowledge-retrieval" and domain_execution.outputs:
-            results = domain_execution.outputs.get("result") or []
-            dataset_ids: list[str] = []
-            dataset_names: list[str] = []
-            for doc in results:
-                if not isinstance(doc, dict):
-                    continue
-                doc_meta = doc.get("metadata") or {}
-                did = doc_meta.get("dataset_id")
-                dname = doc_meta.get("dataset_name")
-                if did and did not in dataset_ids:
-                    dataset_ids.append(did)
-                if dname and dname not in dataset_names:
-                    dataset_names.append(dname)
-            if dataset_ids:
-                node_data["dataset_ids"] = dataset_ids
-            if dataset_names:
-                node_data["dataset_names"] = dataset_names
-
-        tool_info = meta.get(WorkflowNodeExecutionMetadataKey.TOOL_INFO)
-        if isinstance(tool_info, dict):
-            plugin_id = tool_info.get("plugin_unique_identifier")
-            if plugin_id:
-                node_data["plugin_name"] = plugin_id
-            credential_id = tool_info.get("credential_id")
-            if credential_id:
-                node_data["credential_id"] = credential_id
-                node_data["credential_provider_type"] = tool_info.get("provider_type")
-
-        conversation_id = self._system_variables().get(SystemVariableKey.CONVERSATION_ID.value)
-        if conversation_id:
-            node_data["conversation_id"] = conversation_id
-
-        if parent_trace_context:
-            node_data["parent_trace_context"] = parent_trace_context
-
-        from core.telemetry import TelemetryContext, TelemetryEvent, TraceTaskName
-        from core.telemetry import emit as telemetry_emit
-
-        telemetry_emit(
-            TelemetryEvent(
-                name=TraceTaskName.NODE_EXECUTION_TRACE,
-                context=TelemetryContext(
-                    tenant_id=node_data.get("tenant_id"),
-                    user_id=node_data.get("user_id"),
-                    app_id=node_data.get("app_id"),
-                ),
-                payload={"node_execution_data": node_data},
-            ),
-            trace_manager=self._trace_manager,
+        trace_task = TraceTask(
+            TraceTaskName.WORKFLOW_TRACE,
+            workflow_execution=execution,
+            conversation_id=conversation_id,
+            user_id=self._trace_manager.user_id,
+            external_trace_id=external_trace_id,
        )
+        self._trace_manager.add_trace_task(trace_task)

    def _system_variables(self) -> Mapping[str, Any]:
        runtime_state = self.graph_runtime_state
@@ -4,14 +4,13 @@ from typing import TYPE_CHECKING, final
 from typing_extensions import override

 from configs import dify_config
-from core.file.file_manager import file_manager
+from core.file import file_manager
+from core.helper import ssrf_proxy
 from core.helper.code_executor.code_executor import CodeExecutor
 from core.helper.code_executor.code_node_provider import CodeNodeProvider
-from core.helper.ssrf_proxy import ssrf_proxy
 from core.tools.tool_file_manager import ToolFileManager
-from core.workflow.entities.graph_config import NodeConfigDict
 from core.workflow.enums import NodeType
-from core.workflow.graph.graph import NodeFactory
+from core.workflow.graph import NodeFactory
 from core.workflow.nodes.base.node import Node
 from core.workflow.nodes.code.code_node import CodeNode
 from core.workflow.nodes.code.limits import CodeNodeLimits
@@ -23,6 +22,7 @@ from core.workflow.nodes.template_transform.template_renderer import (
    Jinja2TemplateRenderer,
 )
 from core.workflow.nodes.template_transform.template_transform_node import TemplateTransformNode
+from libs.typing import is_str, is_str_dict

 if TYPE_CHECKING:
    from core.workflow.entities import GraphInitParams
@@ -47,9 +47,9 @@ class DifyNodeFactory(NodeFactory):
        code_providers: Sequence[type[CodeNodeProvider]] | None = None,
        code_limits: CodeNodeLimits | None = None,
        template_renderer: Jinja2TemplateRenderer | None = None,
-        http_request_http_client: HttpClientProtocol | None = None,
+        http_request_http_client: HttpClientProtocol = ssrf_proxy,
        http_request_tool_file_manager_factory: Callable[[], ToolFileManager] = ToolFileManager,
-        http_request_file_manager: FileManagerProtocol | None = None,
+        http_request_file_manager: FileManagerProtocol = file_manager,
    ) -> None:
        self.graph_init_params = graph_init_params
        self.graph_runtime_state = graph_runtime_state
@@ -68,12 +68,12 @@ class DifyNodeFactory(NodeFactory):
            max_object_array_length=dify_config.CODE_MAX_OBJECT_ARRAY_LENGTH,
        )
        self._template_renderer = template_renderer or CodeExecutorJinja2TemplateRenderer()
-        self._http_request_http_client = http_request_http_client or ssrf_proxy
+        self._http_request_http_client = http_request_http_client
        self._http_request_tool_file_manager_factory = http_request_tool_file_manager_factory
-        self._http_request_file_manager = http_request_file_manager or file_manager
+        self._http_request_file_manager = http_request_file_manager

    @override
-    def create_node(self, node_config: NodeConfigDict) -> Node:
+    def create_node(self, node_config: dict[str, object]) -> Node:
        """
        Create a Node instance from node configuration data using the traditional mapping.

@@ -82,14 +82,23 @@ class DifyNodeFactory(NodeFactory):
        :raises ValueError: if node type is unknown or configuration is invalid
        """
        # Get node_id from config
-        node_id = node_config["id"]
+        node_id = node_config.get("id")
+        if not is_str(node_id):
+            raise ValueError("Node config missing id")

        # Get node type from config
-        node_data = node_config["data"]
+        node_data = node_config.get("data", {})
+        if not is_str_dict(node_data):
+            raise ValueError(f"Node {node_id} missing data information")
+
+        node_type_str = node_data.get("type")
+        if not is_str(node_type_str):
+            raise ValueError(f"Node {node_id} missing or invalid type information")
+
        try:
-            node_type = NodeType(node_data["type"])
+            node_type = NodeType(node_type_str)
        except ValueError:
-            raise ValueError(f"Unknown node type: {node_data['type']}")
+            raise ValueError(f"Unknown node type: {node_type_str}")

        # Get node class
        node_mapping = NODE_TYPE_CLASSES_MAPPING.get(node_type)
@@ -4,9 +4,8 @@ from typing import Any, TextIO, Union
 from pydantic import BaseModel

 from configs import dify_config
-from core.ops.ops_trace_manager import TraceQueueManager
-from core.telemetry import TelemetryContext, TelemetryEvent, TraceTaskName
-from core.telemetry import emit as telemetry_emit
+from core.ops.entities.trace_entity import TraceTaskName
+from core.ops.ops_trace_manager import TraceQueueManager, TraceTask
 from core.tools.entities.tool_entities import ToolInvokeMessage

 _TEXT_COLOR_MAPPING = {
@@ -37,15 +36,13 @@ class DifyAgentCallbackHandler(BaseModel):

    color: str | None = ""
    current_loop: int = 1
-    tenant_id: str | None = None

-    def __init__(self, color: str | None = None, tenant_id: str | None = None):
+    def __init__(self, color: str | None = None):
        super().__init__()
        """Initialize callback handler."""
        # use a specific color is not specified
        self.color = color or "green"
        self.current_loop = 1
-        self.tenant_id = tenant_id

    def on_tool_start(
        self,
@@ -74,23 +71,15 @@ class DifyAgentCallbackHandler(BaseModel):
            print_text("\n")

        if trace_manager:
-            telemetry_emit(
-                TelemetryEvent(
-                    name=TraceTaskName.TOOL_TRACE,
-                    context=TelemetryContext(
-                        tenant_id=self.tenant_id,
-                        app_id=trace_manager.app_id,
-                        user_id=trace_manager.user_id,
-                    ),
-                    payload={
-                        "message_id": message_id,
-                        "tool_name": tool_name,
-                        "tool_inputs": tool_inputs,
-                        "tool_outputs": tool_outputs,
-                        "timer": timer,
-                    },
-                ),
-                trace_manager=trace_manager,
+            trace_manager.add_trace_task(
+                TraceTask(
+                    TraceTaskName.TOOL_TRACE,
+                    message_id=message_id,
+                    tool_name=tool_name,
+                    tool_inputs=tool_inputs,
+                    tool_outputs=tool_outputs,
+                    timer=timer,
+                )
            )

    def on_tool_error(self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any):
@@ -3,7 +3,6 @@ from pydantic import BaseModel, Field, field_validator

 class PreviewDetail(BaseModel):
    content: str
-    summary: str | None = None
    child_chunks: list[str] | None = None


@@ -104,8 +104,6 @@ def download(f: File, /):
    ):
        return _download_file_content(f.storage_key)
    elif f.transfer_method == FileTransferMethod.REMOTE_URL:
-        if f.remote_url is None:
-            raise ValueError("Missing file remote_url")
        response = ssrf_proxy.get(f.remote_url, follow_redirects=True)
        response.raise_for_status()
        return response.content
@@ -136,8 +134,6 @@ def _download_file_content(path: str, /):
 def _get_encoded_string(f: File, /):
    match f.transfer_method:
        case FileTransferMethod.REMOTE_URL:
-            if f.remote_url is None:
-                raise ValueError("Missing file remote_url")
            response = ssrf_proxy.get(f.remote_url, follow_redirects=True)
            response.raise_for_status()
            data = response.content
@@ -168,18 +164,3 @@ def _to_url(f: File, /):
        return sign_tool_file(tool_file_id=f.related_id, extension=f.extension)
    else:
        raise ValueError(f"Unsupported transfer method: {f.transfer_method}")
-
-
-class FileManager:
-    """
-    Adapter exposing file manager helpers behind FileManagerProtocol.
-
-    This is intentionally a thin wrapper over the existing module-level functions so callers can inject it
-    where a protocol-typed file manager is expected.
-    """
-
-    def download(self, f: File, /) -> bytes:
-        return download(f)
-
-
-file_manager = FileManager()
@@ -47,16 +47,15 @@ class CodeNodeProvider(BaseModel, ABC):

    @classmethod
    def get_default_config(cls) -> DefaultConfig:
-        variables: list[VariableConfig] = [
-            {"variable": "arg1", "value_selector": []},
-            {"variable": "arg2", "value_selector": []},
-        ]
-        outputs: dict[str, OutputConfig] = {"result": {"type": "string", "children": None}}
-
-        config: CodeConfig = {
-            "variables": variables,
-            "code_language": cls.get_language(),
-            "code": cls.get_default_code(),
-            "outputs": outputs,
+        return {
+            "type": "code",
+            "config": {
+                "variables": [
+                    {"variable": "arg1", "value_selector": []},
+                    {"variable": "arg2", "value_selector": []},
+                ],
+                "code_language": cls.get_language(),
+                "code": cls.get_default_code(),
+                "outputs": {"result": {"type": "string", "children": None}},
+            },
        }
-        return {"type": "code", "config": config}
@@ -4,10 +4,8 @@ Proxy requests to avoid SSRF

 import logging
 import time
-from typing import Any, TypeAlias

 import httpx
-from pydantic import TypeAdapter, ValidationError

 from configs import dify_config
 from core.helper.http_client_pooling import get_pooled_http_client
@@ -20,9 +18,6 @@ SSRF_DEFAULT_MAX_RETRIES = dify_config.SSRF_DEFAULT_MAX_RETRIES
 BACKOFF_FACTOR = 0.5
 STATUS_FORCELIST = [429, 500, 502, 503, 504]

-Headers: TypeAlias = dict[str, str]
-_HEADERS_ADAPTER = TypeAdapter(Headers)
-
 _SSL_VERIFIED_POOL_KEY = "ssrf:verified"
 _SSL_UNVERIFIED_POOL_KEY = "ssrf:unverified"
 _SSRF_CLIENT_LIMITS = httpx.Limits(
@@ -81,7 +76,7 @@ def _get_ssrf_client(ssl_verify_enabled: bool) -> httpx.Client:
    )


-def _get_user_provided_host_header(headers: Headers | None) -> str | None:
+def _get_user_provided_host_header(headers: dict | None) -> str | None:
    """
    Extract the user-provided Host header from the headers dict.

@@ -97,7 +92,7 @@ def _get_user_provided_host_header(headers: Headers | None) -> str | None:
    return None


-def _inject_trace_headers(headers: Headers | None) -> Headers:
+def _inject_trace_headers(headers: dict | None) -> dict:
    """
    Inject W3C traceparent header for distributed tracing.

@@ -130,7 +125,7 @@ def _inject_trace_headers(headers: Headers | None) -> Headers:
    return headers


-def make_request(method: str, url: str, max_retries: int = SSRF_DEFAULT_MAX_RETRIES, **kwargs: Any) -> httpx.Response:
+def make_request(method, url, max_retries=SSRF_DEFAULT_MAX_RETRIES, **kwargs):
    # Convert requests-style allow_redirects to httpx-style follow_redirects
    if "allow_redirects" in kwargs:
        allow_redirects = kwargs.pop("allow_redirects")
@@ -147,15 +142,10 @@ def make_request(method: str, url: str, max_retries: int = SSRF_DEFAULT_MAX_RETR

    # prioritize per-call option, which can be switched on and off inside the HTTP node on the web UI
    verify_option = kwargs.pop("ssl_verify", dify_config.HTTP_REQUEST_NODE_SSL_VERIFY)
-    if not isinstance(verify_option, bool):
-        raise ValueError("ssl_verify must be a boolean")
    client = _get_ssrf_client(verify_option)

    # Inject traceparent header for distributed tracing (when OTEL is not enabled)
-    try:
-        headers: Headers = _HEADERS_ADAPTER.validate_python(kwargs.get("headers") or {})
-    except ValidationError as e:
-        raise ValueError("headers must be a mapping of string keys to string values") from e
+    headers = kwargs.get("headers") or {}
    headers = _inject_trace_headers(headers)
    kwargs["headers"] = headers

@@ -208,63 +198,25 @@ def make_request(method: str, url: str, max_retries: int = SSRF_DEFAULT_MAX_RETR
    raise MaxRetriesExceededError(f"Reached maximum retries ({max_retries}) for URL {url}")


-def get(url: str, max_retries: int = SSRF_DEFAULT_MAX_RETRIES, **kwargs: Any) -> httpx.Response:
+def get(url, max_retries=SSRF_DEFAULT_MAX_RETRIES, **kwargs):
    return make_request("GET", url, max_retries=max_retries, **kwargs)


-def post(url: str, max_retries: int = SSRF_DEFAULT_MAX_RETRIES, **kwargs: Any) -> httpx.Response:
+def post(url, max_retries=SSRF_DEFAULT_MAX_RETRIES, **kwargs):
    return make_request("POST", url, max_retries=max_retries, **kwargs)


-def put(url: str, max_retries: int = SSRF_DEFAULT_MAX_RETRIES, **kwargs: Any) -> httpx.Response:
+def put(url, max_retries=SSRF_DEFAULT_MAX_RETRIES, **kwargs):
    return make_request("PUT", url, max_retries=max_retries, **kwargs)


-def patch(url: str, max_retries: int = SSRF_DEFAULT_MAX_RETRIES, **kwargs: Any) -> httpx.Response:
+def patch(url, max_retries=SSRF_DEFAULT_MAX_RETRIES, **kwargs):
    return make_request("PATCH", url, max_retries=max_retries, **kwargs)


-def delete(url: str, max_retries: int = SSRF_DEFAULT_MAX_RETRIES, **kwargs: Any) -> httpx.Response:
+def delete(url, max_retries=SSRF_DEFAULT_MAX_RETRIES, **kwargs):
    return make_request("DELETE", url, max_retries=max_retries, **kwargs)


-def head(url: str, max_retries: int = SSRF_DEFAULT_MAX_RETRIES, **kwargs: Any) -> httpx.Response:
+def head(url, max_retries=SSRF_DEFAULT_MAX_RETRIES, **kwargs):
    return make_request("HEAD", url, max_retries=max_retries, **kwargs)
-
-
-class SSRFProxy:
-    """
-    Adapter exposing SSRF-protected HTTP helpers behind HttpClientProtocol.
-
-    This is intentionally a thin wrapper over the existing module-level functions so callers can inject it
-    where a protocol-typed HTTP client is expected.
-    """
-
-    @property
-    def max_retries_exceeded_error(self) -> type[Exception]:
-        return max_retries_exceeded_error
-
-    @property
-    def request_error(self) -> type[Exception]:
-        return request_error
-
-    def get(self, url: str, max_retries: int = SSRF_DEFAULT_MAX_RETRIES, **kwargs: Any) -> httpx.Response:
-        return get(url=url, max_retries=max_retries, **kwargs)
-
-    def head(self, url: str, max_retries: int = SSRF_DEFAULT_MAX_RETRIES, **kwargs: Any) -> httpx.Response:
-        return head(url=url, max_retries=max_retries, **kwargs)
-
-    def post(self, url: str, max_retries: int = SSRF_DEFAULT_MAX_RETRIES, **kwargs: Any) -> httpx.Response:
-        return post(url=url, max_retries=max_retries, **kwargs)
-
-    def put(self, url: str, max_retries: int = SSRF_DEFAULT_MAX_RETRIES, **kwargs: Any) -> httpx.Response:
-        return put(url=url, max_retries=max_retries, **kwargs)
-
-    def delete(self, url: str, max_retries: int = SSRF_DEFAULT_MAX_RETRIES, **kwargs: Any) -> httpx.Response:
-        return delete(url=url, max_retries=max_retries, **kwargs)
-
-    def patch(self, url: str, max_retries: int = SSRF_DEFAULT_MAX_RETRIES, **kwargs: Any) -> httpx.Response:
-        return patch(url=url, max_retries=max_retries, **kwargs)
-
-
-ssrf_proxy = SSRFProxy()
@@ -311,18 +311,14 @@ class IndexingRunner:
        qa_preview_texts: list[QAPreviewDetail] = []

        total_segments = 0
-        # doc_form represents the segmentation method (general, parent-child, QA)
        index_type = doc_form
        index_processor = IndexProcessorFactory(index_type).init_index_processor()
-        # one extract_setting is one source document
        for extract_setting in extract_settings:
            # extract
            processing_rule = DatasetProcessRule(
                mode=tmp_processing_rule["mode"], rules=json.dumps(tmp_processing_rule["rules"])
            )
-            # Extract document content
            text_docs = index_processor.extract(extract_setting, process_rule_mode=tmp_processing_rule["mode"])
-            # Cleaning and segmentation
            documents = index_processor.transform(
                text_docs,
                current_user=None,
@@ -365,82 +361,75 @@ class IndexingRunner:

        if doc_form and doc_form == "qa_model":
            return IndexingEstimate(total_segments=total_segments * 20, qa_preview=qa_preview_texts, preview=[])
-
-        # Generate summary preview
-        summary_index_setting = tmp_processing_rule.get("summary_index_setting")
-        if summary_index_setting and summary_index_setting.get("enable") and preview_texts:
-            preview_texts = index_processor.generate_summary_preview(
-                tenant_id, preview_texts, summary_index_setting, doc_language
-            )
-
        return IndexingEstimate(total_segments=total_segments, preview=preview_texts)

    def _extract(
        self, index_processor: BaseIndexProcessor, dataset_document: DatasetDocument, process_rule: dict
    ) -> list[Document]:
+        # load file
+        if dataset_document.data_source_type not in {"upload_file", "notion_import", "website_crawl"}:
+            return []
+
        data_source_info = dataset_document.data_source_info_dict
        text_docs = []
-        match dataset_document.data_source_type:
-            case "upload_file":
-                if not data_source_info or "upload_file_id" not in data_source_info:
-                    raise ValueError("no upload file found")
-                stmt = select(UploadFile).where(UploadFile.id == data_source_info["upload_file_id"])
-                file_detail = db.session.scalars(stmt).one_or_none()
+        if dataset_document.data_source_type == "upload_file":
+            if not data_source_info or "upload_file_id" not in data_source_info:
+                raise ValueError("no upload file found")
+            stmt = select(UploadFile).where(UploadFile.id == data_source_info["upload_file_id"])
+            file_detail = db.session.scalars(stmt).one_or_none()

-                if file_detail:
-                    extract_setting = ExtractSetting(
-                        datasource_type=DatasourceType.FILE,
-                        upload_file=file_detail,
-                        document_model=dataset_document.doc_form,
-                    )
-                    text_docs = index_processor.extract(extract_setting, process_rule_mode=process_rule["mode"])
-            case "notion_import":
-                if (
-                    not data_source_info
-                    or "notion_workspace_id" not in data_source_info
-                    or "notion_page_id" not in data_source_info
-                ):
-                    raise ValueError("no notion import info found")
+            if file_detail:
                extract_setting = ExtractSetting(
-                    datasource_type=DatasourceType.NOTION,
-                    notion_info=NotionInfo.model_validate(
-                        {
-                            "credential_id": data_source_info.get("credential_id"),
-                            "notion_workspace_id": data_source_info["notion_workspace_id"],
-                            "notion_obj_id": data_source_info["notion_page_id"],
-                            "notion_page_type": data_source_info["type"],
-                            "document": dataset_document,
-                            "tenant_id": dataset_document.tenant_id,
-                        }
-                    ),
+                    datasource_type=DatasourceType.FILE,
+                    upload_file=file_detail,
                    document_model=dataset_document.doc_form,
                )
                text_docs = index_processor.extract(extract_setting, process_rule_mode=process_rule["mode"])
-            case "website_crawl":
-                if (
-                    not data_source_info
-                    or "provider" not in data_source_info
-                    or "url" not in data_source_info
-                    or "job_id" not in data_source_info
-                ):
-                    raise ValueError("no website import info found")
-                extract_setting = ExtractSetting(
-                    datasource_type=DatasourceType.WEBSITE,
-                    website_info=WebsiteInfo.model_validate(
-                        {
-                            "provider": data_source_info["provider"],
-                            "job_id": data_source_info["job_id"],
-                            "tenant_id": dataset_document.tenant_id,
-                            "url": data_source_info["url"],
-                            "mode": data_source_info["mode"],
-                            "only_main_content": data_source_info["only_main_content"],
-                        }
-                    ),
-                    document_model=dataset_document.doc_form,
-                )
-                text_docs = index_processor.extract(extract_setting, process_rule_mode=process_rule["mode"])
-            case _:
-                return []
+        elif dataset_document.data_source_type == "notion_import":
+            if (
+                not data_source_info
+                or "notion_workspace_id" not in data_source_info
+                or "notion_page_id" not in data_source_info
+            ):
+                raise ValueError("no notion import info found")
+            extract_setting = ExtractSetting(
+                datasource_type=DatasourceType.NOTION,
+                notion_info=NotionInfo.model_validate(
+                    {
+                        "credential_id": data_source_info.get("credential_id"),
+                        "notion_workspace_id": data_source_info["notion_workspace_id"],
+                        "notion_obj_id": data_source_info["notion_page_id"],
+                        "notion_page_type": data_source_info["type"],
+                        "document": dataset_document,
+                        "tenant_id": dataset_document.tenant_id,
+                    }
+                ),
+                document_model=dataset_document.doc_form,
+            )
+            text_docs = index_processor.extract(extract_setting, process_rule_mode=process_rule["mode"])
+        elif dataset_document.data_source_type == "website_crawl":
+            if (
+                not data_source_info
+                or "provider" not in data_source_info
+                or "url" not in data_source_info
+                or "job_id" not in data_source_info
+            ):
+                raise ValueError("no website import info found")
+            extract_setting = ExtractSetting(
+                datasource_type=DatasourceType.WEBSITE,
+                website_info=WebsiteInfo.model_validate(
+                    {
+                        "provider": data_source_info["provider"],
+                        "job_id": data_source_info["job_id"],
+                        "tenant_id": dataset_document.tenant_id,
+                        "url": data_source_info["url"],
+                        "mode": data_source_info["mode"],
+                        "only_main_content": data_source_info["only_main_content"],
+                    }
+                ),
+                document_model=dataset_document.doc_form,
+            )
+            text_docs = index_processor.extract(extract_setting, process_rule_mode=process_rule["mode"])
        # update document status to splitting
        self._update_document_index_status(
            document_id=dataset_document.id,
@@ -1,22 +0,0 @@
-"""Shared payload models for LLM generator helpers and controllers."""
-
-from pydantic import BaseModel, Field
-
-from core.app.app_config.entities import ModelConfig
-
-
-class RuleGeneratePayload(BaseModel):
-    instruction: str = Field(..., description="Rule generation instruction")
-    model_config_data: ModelConfig = Field(..., alias="model_config", description="Model configuration")
-    no_variable: bool = Field(default=False, description="Whether to exclude variables")
-    app_id: str | None = Field(default=None, description="App ID for prompt generation tracing")
-
-
-class RuleCodeGeneratePayload(RuleGeneratePayload):
-    code_language: str = Field(default="javascript", description="Programming language for code generation")
-
-
-class RuleStructuredOutputPayload(BaseModel):
-    instruction: str = Field(..., description="Structured output generation instruction")
-    model_config_data: ModelConfig = Field(..., alias="model_config", description="Model configuration")
-    app_id: str | None = Field(default=None, description="App ID for prompt generation tracing")
@@ -6,7 +6,6 @@ from typing import Protocol, cast

 import json_repair

-from core.app.app_config.entities import ModelConfig
 from core.llm_generator.output_parser.rule_config_generator import RuleConfigGeneratorOutputParser
 from core.llm_generator.output_parser.suggested_questions_after_answer import SuggestedQuestionsAfterAnswerOutputParser
 from core.llm_generator.prompts import (
@@ -26,11 +25,10 @@ from core.model_runtime.entities.llm_entities import LLMResult
 from core.model_runtime.entities.message_entities import PromptMessage, SystemPromptMessage, UserPromptMessage
 from core.model_runtime.entities.model_entities import ModelType
 from core.model_runtime.errors.invoke import InvokeAuthorizationError, InvokeError
-from core.ops.entities.trace_entity import OperationType
+from core.ops.entities.trace_entity import TraceTaskName
+from core.ops.ops_trace_manager import TraceQueueManager, TraceTask
 from core.ops.utils import measure_time
 from core.prompt.utils.prompt_template_parser import PromptTemplateParser
-from core.telemetry import TelemetryContext, TelemetryEvent, TraceTaskName
-from core.telemetry import emit as telemetry_emit
 from core.workflow.entities.workflow_node_execution import WorkflowNodeExecutionMetadataKey
 from extensions.ext_database import db
 from extensions.ext_storage import storage
@@ -74,7 +72,7 @@ class LLMGenerator:
                prompt_messages=list(prompts), model_parameters={"max_tokens": 500, "temperature": 1}, stream=False
            )
        answer = response.message.get_text_content()
-        if answer is None:
+        if answer == "":
            return ""
        try:
            result_dict = json.loads(answer)
@@ -96,17 +94,15 @@ class LLMGenerator:
            name = name[:75] + "..."

        # get tracing instance
-        telemetry_emit(
-            TelemetryEvent(
-                name=TraceTaskName.GENERATE_NAME_TRACE,
-                context=TelemetryContext(tenant_id=tenant_id, app_id=app_id),
-                payload={
-                    "conversation_id": conversation_id,
-                    "generate_conversation_name": name,
-                    "inputs": prompt,
-                    "timer": timer,
-                    "tenant_id": tenant_id,
-                },
+        trace_manager = TraceQueueManager(app_id=app_id)
+        trace_manager.add_trace_task(
+            TraceTask(
+                TraceTaskName.GENERATE_NAME_TRACE,
+                conversation_id=conversation_id,
+                generate_conversation_name=name,
+                inputs=prompt,
+                timer=timer,
+                tenant_id=tenant_id,
            )
        )

@@ -155,21 +151,13 @@ class LLMGenerator:
        return questions

    @classmethod
-    def generate_rule_config(
-        cls,
-        tenant_id: str,
-        instruction: str,
-        model_config: ModelConfig,
-        no_variable: bool,
-        user_id: str | None = None,
-        app_id: str | None = None,
-    ):
+    def generate_rule_config(cls, tenant_id: str, instruction: str, model_config: dict, no_variable: bool):
        output_parser = RuleConfigGeneratorOutputParser()

        error = ""
        error_step = ""
        rule_config = {"prompt": "", "variables": [], "opening_statement": "", "error": ""}
-        model_parameters = model_config.completion_params
+        model_parameters = model_config.get("completion_params", {})
        if no_variable:
            prompt_template = PromptTemplateParser(WORKFLOW_RULE_CONFIG_PROMPT_GENERATE_TEMPLATE)

@@ -187,45 +175,26 @@ class LLMGenerator:
            model_instance = model_manager.get_model_instance(
                tenant_id=tenant_id,
                model_type=ModelType.LLM,
-                provider=model_config.provider,
-                model=model_config.name,
+                provider=model_config.get("provider", ""),
+                model=model_config.get("name", ""),
            )

-            llm_result = None
-            with measure_time() as timer:
-                try:
-                    llm_result = model_instance.invoke_llm(
-                        prompt_messages=list(prompt_messages), model_parameters=model_parameters, stream=False
-                    )
+            try:
+                response: LLMResult = model_instance.invoke_llm(
+                    prompt_messages=list(prompt_messages), model_parameters=model_parameters, stream=False
+                )

-                    rule_config["prompt"] = llm_result.message.get_text_content() or ""
+                rule_config["prompt"] = response.message.get_text_content()

-                except InvokeError as e:
-                    error = str(e)
-                    error_step = "generate rule config"
-                except Exception as e:
-                    logger.exception("Failed to generate rule config, model: %s", model_config.name)
-                    rule_config["error"] = str(e)
-                    error = str(e)
+            except InvokeError as e:
+                error = str(e)
+                error_step = "generate rule config"
+            except Exception as e:
+                logger.exception("Failed to generate rule config, model: %s", model_config.get("name"))
+                rule_config["error"] = str(e)

            rule_config["error"] = f"Failed to {error_step}. Error: {error}" if error else ""

-            if user_id:
-                prompt_value = rule_config.get("prompt", "")
-                generated_output = str(prompt_value) if prompt_value else ""
-                cls._emit_prompt_generation_trace(
-                    tenant_id=tenant_id,
-                    user_id=user_id,
-                    app_id=app_id,
-                    operation_type=OperationType.RULE_GENERATE,
-                    instruction=instruction,
-                    generated_output=generated_output,
-                    llm_result=llm_result,
-                    model_config=model_config,
-                    timer=timer,
-                    error=error or None,
-                )
-
            return rule_config

        # get rule config prompt, parameter and statement
@@ -251,116 +220,71 @@ class LLMGenerator:
        model_instance = model_manager.get_model_instance(
            tenant_id=tenant_id,
            model_type=ModelType.LLM,
-            provider=model_config.provider,
-            model=model_config.name,
+            provider=model_config.get("provider", ""),
+            model=model_config.get("name", ""),
        )

-        llm_result = None
-        with measure_time() as timer:
+        try:
            try:
-                try:
-                    # the first step to generate the task prompt
-                    prompt_content: LLMResult = model_instance.invoke_llm(
-                        prompt_messages=list(prompt_messages), model_parameters=model_parameters, stream=False
-                    )
-                    llm_result = prompt_content
-                except InvokeError as e:
-                    error = str(e)
-                    error_step = "generate prefix prompt"
-                    rule_config["error"] = f"Failed to {error_step}. Error: {error}" if error else ""
-
-                    if user_id:
-                        cls._emit_prompt_generation_trace(
-                            tenant_id=tenant_id,
-                            user_id=user_id,
-                            app_id=app_id,
-                            operation_type=OperationType.RULE_GENERATE,
-                            instruction=instruction,
-                            generated_output="",
-                            llm_result=llm_result,
-                            model_config=model_config,
-                            timer=timer,
-                            error=error,
-                        )
-
-                    return rule_config
-
-                rule_config["prompt"] = prompt_content.message.get_text_content() or ""
-
-                if not isinstance(prompt_content.message.content, str):
-                    raise NotImplementedError("prompt content is not a string")
-                parameter_generate_prompt = parameter_template.format(
-                    inputs={
-                        "INPUT_TEXT": prompt_content.message.content,
-                    },
-                    remove_template_variables=False,
+                # the first step to generate the task prompt
+                prompt_content: LLMResult = model_instance.invoke_llm(
+                    prompt_messages=list(prompt_messages), model_parameters=model_parameters, stream=False
                )
-                parameter_messages = [UserPromptMessage(content=parameter_generate_prompt)]
-
-                # the second step to generate the task_parameter and task_statement
-                statement_generate_prompt = statement_template.format(
-                    inputs={
-                        "TASK_DESCRIPTION": instruction,
-                        "INPUT_TEXT": prompt_content.message.content,
-                    },
-                    remove_template_variables=False,
-                )
-                statement_messages = [UserPromptMessage(content=statement_generate_prompt)]
-
-                try:
-                    parameter_content: LLMResult = model_instance.invoke_llm(
-                        prompt_messages=list(parameter_messages), model_parameters=model_parameters, stream=False
-                    )
-                    rule_config["variables"] = re.findall(
-                        r'"\s*([^"]+)\s*"', prompt_content.message.get_text_content() or ""
-                    )
-                except InvokeError as e:
-                    error = str(e)
-                    error_step = "generate variables"
-
-                try:
-                    statement_content: LLMResult = model_instance.invoke_llm(
-                        prompt_messages=list(statement_messages), model_parameters=model_parameters, stream=False
-                    )
-                    rule_config["opening_statement"] = statement_content.message.get_text_content() or ""
-                except InvokeError as e:
-                    error = str(e)
-                    error_step = "generate conversation opener"
-
-            except Exception as e:
-                logger.exception("Failed to generate rule config, model: %s", model_config.name)
-                rule_config["error"] = str(e)
+            except InvokeError as e:
                error = str(e)
+                error_step = "generate prefix prompt"
+                rule_config["error"] = f"Failed to {error_step}. Error: {error}" if error else ""
+
+                return rule_config
+
+            rule_config["prompt"] = prompt_content.message.get_text_content()
+
+            parameter_generate_prompt = parameter_template.format(
+                inputs={
+                    "INPUT_TEXT": prompt_content.message.get_text_content(),
+                },
+                remove_template_variables=False,
+            )
+            parameter_messages = [UserPromptMessage(content=parameter_generate_prompt)]
+
+            # the second step to generate the task_parameter and task_statement
+            statement_generate_prompt = statement_template.format(
+                inputs={
+                    "TASK_DESCRIPTION": instruction,
+                    "INPUT_TEXT": prompt_content.message.get_text_content(),
+                },
+                remove_template_variables=False,
+            )
+            statement_messages = [UserPromptMessage(content=statement_generate_prompt)]
+
+            try:
+                parameter_content: LLMResult = model_instance.invoke_llm(
+                    prompt_messages=list(parameter_messages), model_parameters=model_parameters, stream=False
+                )
+                rule_config["variables"] = re.findall(r'"\s*([^"]+)\s*"', parameter_content.message.get_text_content())
+            except InvokeError as e:
+                error = str(e)
+                error_step = "generate variables"
+
+            try:
+                statement_content: LLMResult = model_instance.invoke_llm(
+                    prompt_messages=list(statement_messages), model_parameters=model_parameters, stream=False
+                )
+                rule_config["opening_statement"] = statement_content.message.get_text_content()
+            except InvokeError as e:
+                error = str(e)
+                error_step = "generate conversation opener"
+
+        except Exception as e:
+            logger.exception("Failed to generate rule config, model: %s", model_config.get("name"))
+            rule_config["error"] = str(e)

        rule_config["error"] = f"Failed to {error_step}. Error: {error}" if error else ""

-        if user_id:
-            generated_output = rule_config.get("prompt", "")
-            cls._emit_prompt_generation_trace(
-                tenant_id=tenant_id,
-                user_id=user_id,
-                app_id=app_id,
-                operation_type=OperationType.RULE_GENERATE,
-                instruction=instruction,
-                generated_output=str(generated_output) if generated_output else "",
-                llm_result=llm_result,
-                model_config=model_config,
-                timer=timer,
-                error=error or None,
-            )
-
        return rule_config

    @classmethod
-    def generate_code(
-        cls,
-        tenant_id: str,
-        instruction: str,
-        model_config: ModelConfig,
-        code_language: str = "javascript",
-        user_id: str | None = None,
-        app_id: str | None = None,
-    ):
+    def generate_code(cls, tenant_id: str, instruction: str, model_config: dict, code_language: str = "javascript"):
        if code_language == "python":
            prompt_template = PromptTemplateParser(PYTHON_CODE_GENERATOR_PROMPT_TEMPLATE)
        else:
@@ -378,49 +302,28 @@ class LLMGenerator:
        model_instance = model_manager.get_model_instance(
            tenant_id=tenant_id,
            model_type=ModelType.LLM,
-            provider=model_config.provider,
-            model=model_config.name,
+            provider=model_config.get("provider", ""),
+            model=model_config.get("name", ""),
        )

        prompt_messages = [UserPromptMessage(content=prompt)]
-        model_parameters = model_config.completion_params
-
-        llm_result = None
-        error = None
-        with measure_time() as timer:
-            try:
-                llm_result = model_instance.invoke_llm(
-                    prompt_messages=list(prompt_messages), model_parameters=model_parameters, stream=False
-                )
-
-                generated_code = llm_result.message.get_text_content() or ""
-                result = {"code": generated_code, "language": code_language, "error": ""}
-
-            except InvokeError as e:
-                error = str(e)
-                result = {"code": "", "language": code_language, "error": f"Failed to generate code. Error: {error}"}
-            except Exception as e:
-                logger.exception(
-                    "Failed to invoke LLM model, model: %s, language: %s", model_config.name, code_language
-                )
-                error = str(e)
-                result = {"code": "", "language": code_language, "error": f"An unexpected error occurred: {str(e)}"}
-
-        if user_id:
-            cls._emit_prompt_generation_trace(
-                tenant_id=tenant_id,
-                user_id=user_id,
-                app_id=app_id,
-                operation_type=OperationType.CODE_GENERATE,
-                instruction=instruction,
-                generated_output=result.get("code", ""),
-                llm_result=llm_result,
-                model_config=model_config,
-                timer=timer,
-                error=error,
+        model_parameters = model_config.get("completion_params", {})
+        try:
+            response: LLMResult = model_instance.invoke_llm(
+                prompt_messages=list(prompt_messages), model_parameters=model_parameters, stream=False
            )

-        return result
+            generated_code = response.message.get_text_content()
+            return {"code": generated_code, "language": code_language, "error": ""}
+
+        except InvokeError as e:
+            error = str(e)
+            return {"code": "", "language": code_language, "error": f"Failed to generate code. Error: {error}"}
+        except Exception as e:
+            logger.exception(
+                "Failed to invoke LLM model, model: %s, language: %s", model_config.get("name"), code_language
+            )
+            return {"code": "", "language": code_language, "error": f"An unexpected error occurred: {str(e)}"}

    @classmethod
    def generate_qa_document(cls, tenant_id: str, query, document_language: str):
@@ -446,98 +349,59 @@ class LLMGenerator:
            raise TypeError("Expected LLMResult when stream=False")
        response = result

-        answer = response.message.get_text_content() or ""
+        answer = response.message.get_text_content()
        return answer.strip()

    @classmethod
-    def generate_structured_output(
-        cls,
-        tenant_id: str,
-        instruction: str,
-        model_config: ModelConfig,
-        user_id: str | None = None,
-        app_id: str | None = None,
-    ):
+    def generate_structured_output(cls, tenant_id: str, instruction: str, model_config: dict):
        model_manager = ModelManager()
        model_instance = model_manager.get_model_instance(
            tenant_id=tenant_id,
            model_type=ModelType.LLM,
-            provider=model_config.provider,
-            model=model_config.name,
+            provider=model_config.get("provider", ""),
+            model=model_config.get("name", ""),
        )

        prompt_messages = [
            SystemPromptMessage(content=SYSTEM_STRUCTURED_OUTPUT_GENERATE),
            UserPromptMessage(content=instruction),
        ]
-        model_parameters = model_config.completion_params
+        model_parameters = model_config.get("model_parameters", {})

-        llm_result = None
-        error = None
-        result = {"output": "", "error": ""}
-
-        with measure_time() as timer:
-            try:
-                llm_result = model_instance.invoke_llm(
-                    prompt_messages=list(prompt_messages), model_parameters=model_parameters, stream=False
-                )
-
-                raw_content = llm_result.message.content
-
-                if not isinstance(raw_content, str):
-                    raise ValueError(f"LLM response content must be a string, got: {type(raw_content)}")
-
-                try:
-                    parsed_content = json.loads(raw_content)
-                except json.JSONDecodeError:
-                    parsed_content = json_repair.loads(raw_content)
-
-                if not isinstance(parsed_content, dict | list):
-                    raise ValueError(f"Failed to parse structured output from llm: {raw_content}")
-
-                generated_json_schema = json.dumps(parsed_content, indent=2, ensure_ascii=False)
-                result = {"output": generated_json_schema, "error": ""}
-
-            except InvokeError as e:
-                error = str(e)
-                result = {"output": "", "error": f"Failed to generate JSON Schema. Error: {error}"}
-            except Exception as e:
-                logger.exception("Failed to invoke LLM model, model: %s", model_config.name)
-                error = str(e)
-                result = {"output": "", "error": f"An unexpected error occurred: {str(e)}"}
-
-        if user_id:
-            cls._emit_prompt_generation_trace(
-                tenant_id=tenant_id,
-                user_id=user_id,
-                app_id=app_id,
-                operation_type=OperationType.STRUCTURED_OUTPUT,
-                instruction=instruction,
-                generated_output=result.get("output", ""),
-                llm_result=llm_result,
-                model_config=model_config,
-                timer=timer,
-                error=error,
+        try:
+            response: LLMResult = model_instance.invoke_llm(
+                prompt_messages=list(prompt_messages), model_parameters=model_parameters, stream=False
            )

-        return result
+            raw_content = response.message.get_text_content()
+
+            try:
+                parsed_content = json.loads(raw_content)
+            except json.JSONDecodeError:
+                parsed_content = json_repair.loads(raw_content)
+
+            if not isinstance(parsed_content, dict | list):
+                raise ValueError(f"Failed to parse structured output from llm: {raw_content}")
+
+            generated_json_schema = json.dumps(parsed_content, indent=2, ensure_ascii=False)
+            return {"output": generated_json_schema, "error": ""}
+
+        except InvokeError as e:
+            error = str(e)
+            return {"output": "", "error": f"Failed to generate JSON Schema. Error: {error}"}
+        except Exception as e:
+            logger.exception("Failed to invoke LLM model, model: %s", model_config.get("name"))
+            return {"output": "", "error": f"An unexpected error occurred: {str(e)}"}

    @staticmethod
    def instruction_modify_legacy(
-        tenant_id: str,
-        flow_id: str,
-        current: str,
-        instruction: str,
-        model_config: ModelConfig,
-        ideal_output: str | None,
-        user_id: str | None = None,
-        app_id: str | None = None,
+        tenant_id: str, flow_id: str, current: str, instruction: str, model_config: dict, ideal_output: str | None
    ):
        last_run: Message | None = (
            db.session.query(Message).where(Message.app_id == flow_id).order_by(Message.created_at.desc()).first()
        )
        if not last_run:
-            result = LLMGenerator.__instruction_modify_common(
+            return LLMGenerator.__instruction_modify_common(
                tenant_id=tenant_id,
                model_config=model_config,
                last_run=None,
@@ -546,28 +410,22 @@ class LLMGenerator:
                instruction=instruction,
                node_type="llm",
                ideal_output=ideal_output,
-                user_id=user_id,
-                app_id=app_id,
            )
-        else:
-            last_run_dict = {
-                "query": last_run.query,
-                "answer": last_run.answer,
-                "error": last_run.error,
-            }
-            result = LLMGenerator.__instruction_modify_common(
-                tenant_id=tenant_id,
-                model_config=model_config,
-                last_run=last_run_dict,
-                current=current,
-                error_message=str(last_run.error),
-                instruction=instruction,
-                node_type="llm",
-                ideal_output=ideal_output,
-                user_id=user_id,
-                app_id=app_id,
-            )
-        return result
+        last_run_dict = {
+            "query": last_run.query,
+            "answer": last_run.answer,
+            "error": last_run.error,
+        }
+        return LLMGenerator.__instruction_modify_common(
+            tenant_id=tenant_id,
+            model_config=model_config,
+            last_run=last_run_dict,
+            current=current,
+            error_message=str(last_run.error),
+            instruction=instruction,
+            node_type="llm",
+            ideal_output=ideal_output,
+        )

    @staticmethod
    def instruction_modify_workflow(
@@ -576,11 +434,9 @@ class LLMGenerator:
        node_id: str,
        current: str,
        instruction: str,
-        model_config: ModelConfig,
+        model_config: dict,
        ideal_output: str | None,
        workflow_service: WorkflowServiceInterface,
-        user_id: str | None = None,
-        app_id: str | None = None,
    ):
        session = db.session()

@@ -611,8 +467,6 @@ class LLMGenerator:
                instruction=instruction,
                node_type=node_type,
                ideal_output=ideal_output,
-                user_id=user_id,
-                app_id=app_id,
            )

        def agent_log_of(node_execution: WorkflowNodeExecutionModel) -> Sequence:
@@ -646,22 +500,18 @@ class LLMGenerator:
            instruction=instruction,
            node_type=last_run.node_type,
            ideal_output=ideal_output,
-            user_id=user_id,
-            app_id=app_id,
        )

    @staticmethod
    def __instruction_modify_common(
        tenant_id: str,
-        model_config: ModelConfig,
+        model_config: dict,
        last_run: dict | None,
        current: str | None,
        error_message: str | None,
        instruction: str,
        node_type: str,
        ideal_output: str | None,
-        user_id: str | None = None,
-        app_id: str | None = None,
    ):
        LAST_RUN = "{{#last_run#}}"
        CURRENT = "{{#current#}}"
@@ -676,8 +526,8 @@ class LLMGenerator:
        model_instance = ModelManager().get_model_instance(
            tenant_id=tenant_id,
            model_type=ModelType.LLM,
-            provider=model_config.provider,
-            model=model_config.name,
+            provider=model_config.get("provider", ""),
+            model=model_config.get("name", ""),
        )
        match node_type:
            case "llm" | "agent":
@@ -701,120 +551,26 @@ class LLMGenerator:
        ]
        model_parameters = {"temperature": 0.4}

-        llm_result = None
-        error = None
-        result = {}
-
-        with measure_time() as timer:
-            try:
-                llm_result = model_instance.invoke_llm(
-                    prompt_messages=list(prompt_messages), model_parameters=model_parameters, stream=False
-                )
-
-                generated_raw = llm_result.message.get_text_content()
-                first_brace = generated_raw.find("{")
-                last_brace = generated_raw.rfind("}")
-                if first_brace == -1 or last_brace == -1 or last_brace < first_brace:
-                    raise ValueError(f"Could not find a valid JSON object in response: {generated_raw}")
-                json_str = generated_raw[first_brace : last_brace + 1]
-                data = json_repair.loads(json_str)
-                if not isinstance(data, dict):
-                    raise TypeError(f"Expected a JSON object, but got {type(data).__name__}")
-                result = data
-            except InvokeError as e:
-                error = str(e)
-                result = {"error": f"Failed to generate code. Error: {error}"}
-            except Exception as e:
-                logger.exception("Failed to invoke LLM model, model: %s", json.dumps(model_config.name), exc_info=True)
-                error = str(e)
-                result = {"error": f"An unexpected error occurred: {str(e)}"}
-
-        if user_id:
-            generated_output = ""
-            if isinstance(result, dict):
-                for key in ["prompt", "code", "output", "modified"]:
-                    if result.get(key):
-                        generated_output = str(result[key])
-                        break
-
-            LLMGenerator._emit_prompt_generation_trace(
-                tenant_id=tenant_id,
-                user_id=user_id,
-                app_id=app_id,
-                operation_type=OperationType.INSTRUCTION_MODIFY,
-                instruction=instruction,
-                generated_output=generated_output,
-                llm_result=llm_result,
-                model_config=model_config,
-                timer=timer,
-                error=error,
+        try:
+            response: LLMResult = model_instance.invoke_llm(
+                prompt_messages=list(prompt_messages), model_parameters=model_parameters, stream=False
            )

-        return result
-
-    @classmethod
-    def _emit_prompt_generation_trace(
-        cls,
-        tenant_id: str,
-        user_id: str,
-        app_id: str | None,
-        operation_type: OperationType,
-        instruction: str,
-        generated_output: str,
-        llm_result: LLMResult | None,
-        model_config: ModelConfig | None = None,
-        timer=None,
-        error: str | None = None,
-    ):
-        if llm_result:
-            prompt_tokens = llm_result.usage.prompt_tokens
-            completion_tokens = llm_result.usage.completion_tokens
-            total_tokens = llm_result.usage.total_tokens
-            model_name = llm_result.model
-            # Extract provider from model_config if available, otherwise fall back to parsing model name
-            if model_config and model_config.provider:
-                model_provider = model_config.provider
-            else:
-                model_provider = model_name.split("/")[0] if "/" in model_name else ""
-            latency = llm_result.usage.latency
-            total_price = float(llm_result.usage.total_price) if llm_result.usage.total_price else None
-            currency = llm_result.usage.currency
-        else:
-            prompt_tokens = 0
-            completion_tokens = 0
-            total_tokens = 0
-            model_provider = model_config.provider if model_config else ""
-            model_name = model_config.name if model_config else ""
-            latency = 0.0
-            if timer:
-                start_time = timer.get("start")
-                end_time = timer.get("end")
-                if start_time and end_time:
-                    latency = (end_time - start_time).total_seconds()
-            total_price = None
-            currency = None
-
-        telemetry_emit(
-            TelemetryEvent(
-                name=TraceTaskName.PROMPT_GENERATION_TRACE,
-                context=TelemetryContext(tenant_id=tenant_id, user_id=user_id, app_id=app_id),
-                payload={
-                    "tenant_id": tenant_id,
-                    "user_id": user_id,
-                    "app_id": app_id,
-                    "operation_type": operation_type,
-                    "instruction": instruction,
-                    "generated_output": generated_output,
-                    "prompt_tokens": prompt_tokens,
-                    "completion_tokens": completion_tokens,
-                    "total_tokens": total_tokens,
-                    "model_provider": model_provider,
-                    "model_name": model_name,
-                    "latency": latency,
-                    "total_price": total_price,
-                    "currency": currency,
-                    "timer": timer,
-                    "error": error,
-                },
+            generated_raw = response.message.get_text_content()
+            first_brace = generated_raw.find("{")
+            last_brace = generated_raw.rfind("}")
+            if first_brace == -1 or last_brace == -1 or last_brace < first_brace:
+                raise ValueError(f"Could not find a valid JSON object in response: {generated_raw}")
+            json_str = generated_raw[first_brace : last_brace + 1]
+            data = json_repair.loads(json_str)
+            if not isinstance(data, dict):
+                raise TypeError(f"Expected a JSON object, but got {type(data).__name__}")
+            return data
+        except InvokeError as e:
+            error = str(e)
+            return {"error": f"Failed to generate code. Error: {error}"}
+        except Exception as e:
+            logger.exception(
+                "Failed to invoke LLM model, model: %s", json.dumps(model_config.get("name")), exc_info=True
            )
-        )
+            return {"error": f"An unexpected error occurred: {str(e)}"}
@@ -434,22 +434,3 @@ INSTRUCTION_GENERATE_TEMPLATE_PROMPT = """The output of this prompt is not as ex
 You should edit the prompt according to the IDEAL OUTPUT."""

 INSTRUCTION_GENERATE_TEMPLATE_CODE = """Please fix the errors in the {{#error_message#}}."""
-
-DEFAULT_GENERATOR_SUMMARY_PROMPT = (
-    """Summarize the following content. Extract only the key information and main points. """
-    """Remove redundant details.
-
-Requirements:
-1. Write a concise summary in plain text
-2. You must write in {language}. No language other than {language} should be used.
-3. Focus on important facts, concepts, and details
-4. If images are included, describe their key information
-5. Do not use words like "好的", "ok", "I understand", "This text discusses", "The content mentions"
-6. Write directly without extra words
-7. If there is not enough content to generate a meaningful summary, 
-   return an empty string without any explanation or prompt
-
-Output only the summary text. Start summarizing now:
-
-"""
-)
@@ -15,23 +15,16 @@ class TraceContextFilter(logging.Filter):
    """

    def filter(self, record: logging.LogRecord) -> bool:
-        # Preserve explicit trace_id set by the caller (e.g. emit_metric_only_event)
-        existing_trace_id = getattr(record, "trace_id", "")
-        if not existing_trace_id:
-            # Get trace context from OpenTelemetry
-            trace_id, span_id = self._get_otel_context()
+        # Get trace context from OpenTelemetry
+        trace_id, span_id = self._get_otel_context()

-            # Set trace_id (fallback to ContextVar if no OTEL context)
-            if trace_id:
-                record.trace_id = trace_id
-            else:
-                record.trace_id = get_trace_id()
-
-            record.span_id = span_id or ""
+        # Set trace_id (fallback to ContextVar if no OTEL context)
+        if trace_id:
+            record.trace_id = trace_id
        else:
-            # Keep existing trace_id; only fill span_id if missing
-            if not getattr(record, "span_id", ""):
-                record.span_id = ""
+            record.trace_id = get_trace_id()
+
+        record.span_id = span_id or ""

        # For backward compatibility, also set req_id
        record.req_id = get_request_id()
@@ -62,12 +55,9 @@ class IdentityContextFilter(logging.Filter):

    def filter(self, record: logging.LogRecord) -> bool:
        identity = self._extract_identity()
-        if not getattr(record, "tenant_id", ""):
-            record.tenant_id = identity.get("tenant_id", "")
-        if not getattr(record, "user_id", ""):
-            record.user_id = identity.get("user_id", "")
-        if not getattr(record, "user_type", ""):
-            record.user_type = identity.get("user_type", "")
+        record.tenant_id = identity.get("tenant_id", "")
+        record.user_id = identity.get("user_id", "")
+        record.user_type = identity.get("user_type", "")
        return True

    def _extract_identity(self) -> dict[str, str]:
@@ -347,7 +347,7 @@ class BaseSession(
                        message.message.root.model_dump(by_alias=True, mode="json", exclude_none=True)
                    )

-                    responder = RequestResponder[ReceiveRequestT, SendResultT](
+                    responder = RequestResponder(
                        request_id=message.message.root.id,
                        request_meta=validated_request.root.params.meta if validated_request.root.params else None,
                        request=validated_request,
@@ -88,7 +88,7 @@ PARAMETER_RULE_TEMPLATE: dict[DefaultParameterName, dict] = {
    DefaultParameterName.MAX_TOKENS: {
        "label": {
            "en_US": "Max Tokens",
-            "zh_Hans": "最大 Token 数",
+            "zh_Hans": "最大标记",
        },
        "type": "int",
        "help": {
@@ -1,11 +1,10 @@
 import decimal
 import hashlib
-import logging
+from threading import Lock

-from pydantic import BaseModel, ConfigDict, Field, ValidationError
-from redis import RedisError
+from pydantic import BaseModel, ConfigDict, Field

-from configs import dify_config
+import contexts
 from core.model_runtime.entities.common_entities import I18nObject
 from core.model_runtime.entities.defaults import PARAMETER_RULE_TEMPLATE
 from core.model_runtime.entities.model_entities import (
@@ -25,9 +24,6 @@ from core.model_runtime.errors.invoke import (
    InvokeServerUnavailableError,
 )
 from core.plugin.entities.plugin_daemon import PluginModelProviderEntity
-from extensions.ext_redis import redis_client
-
-logger = logging.getLogger(__name__)


 class AIModel(BaseModel):
@@ -148,60 +144,34 @@ class AIModel(BaseModel):

        plugin_model_manager = PluginModelClient()
        cache_key = f"{self.tenant_id}:{self.plugin_id}:{self.provider_name}:{self.model_type.value}:{model}"
+        # sort credentials
        sorted_credentials = sorted(credentials.items()) if credentials else []
        cache_key += ":".join([hashlib.md5(f"{k}:{v}".encode()).hexdigest() for k, v in sorted_credentials])

-        cached_schema_json = None
        try:
-            cached_schema_json = redis_client.get(cache_key)
-        except (RedisError, RuntimeError) as exc:
-            logger.warning(
-                "Failed to read plugin model schema cache for model %s: %s",
-                model,
-                str(exc),
-                exc_info=True,
+            contexts.plugin_model_schemas.get()
+        except LookupError:
+            contexts.plugin_model_schemas.set({})
+            contexts.plugin_model_schema_lock.set(Lock())
+
+        with contexts.plugin_model_schema_lock.get():
+            if cache_key in contexts.plugin_model_schemas.get():
+                return contexts.plugin_model_schemas.get()[cache_key]
+
+            schema = plugin_model_manager.get_model_schema(
+                tenant_id=self.tenant_id,
+                user_id="unknown",
+                plugin_id=self.plugin_id,
+                provider=self.provider_name,
+                model_type=self.model_type.value,
+                model=model,
+                credentials=credentials or {},
            )
-        if cached_schema_json:
-            try:
-                return AIModelEntity.model_validate_json(cached_schema_json)
-            except ValidationError:
-                logger.warning(
-                    "Failed to validate cached plugin model schema for model %s",
-                    model,
-                    exc_info=True,
-                )
-                try:
-                    redis_client.delete(cache_key)
-                except (RedisError, RuntimeError) as exc:
-                    logger.warning(
-                        "Failed to delete invalid plugin model schema cache for model %s: %s",
-                        model,
-                        str(exc),
-                        exc_info=True,
-                    )

-        schema = plugin_model_manager.get_model_schema(
-            tenant_id=self.tenant_id,
-            user_id="unknown",
-            plugin_id=self.plugin_id,
-            provider=self.provider_name,
-            model_type=self.model_type.value,
-            model=model,
-            credentials=credentials or {},
-        )
+            if schema:
+                contexts.plugin_model_schemas.get()[cache_key] = schema

-        if schema:
-            try:
-                redis_client.setex(cache_key, dify_config.PLUGIN_MODEL_SCHEMA_CACHE_TTL, schema.model_dump_json())
-            except (RedisError, RuntimeError) as exc:
-                logger.warning(
-                    "Failed to write plugin model schema cache for model %s: %s",
-                    model,
-                    str(exc),
-                    exc_info=True,
-                )
-
-        return schema
+            return schema

    def get_customizable_model_schema_from_credentials(self, model: str, credentials: dict) -> AIModelEntity | None:
        """
@@ -92,10 +92,6 @@ def _build_llm_result_from_first_chunk(
    Build a single `LLMResult` from the first returned chunk.

    This is used for `stream=False` because the plugin side may still implement the response via a chunked stream.
-
-    Note:
-        This function always drains the `chunks` iterator after reading the first chunk to ensure any underlying
-        streaming resources are released (e.g., HTTP connections owned by the plugin runtime).
    """
    content = ""
    content_list: list[PromptMessageContentUnionTypes] = []
@@ -103,25 +99,18 @@ def _build_llm_result_from_first_chunk(
    system_fingerprint: str | None = None
    tools_calls: list[AssistantPromptMessage.ToolCall] = []

-    try:
-        first_chunk = next(chunks, None)
-        if first_chunk is not None:
-            if isinstance(first_chunk.delta.message.content, str):
-                content += first_chunk.delta.message.content
-            elif isinstance(first_chunk.delta.message.content, list):
-                content_list.extend(first_chunk.delta.message.content)
+    first_chunk = next(chunks, None)
+    if first_chunk is not None:
+        if isinstance(first_chunk.delta.message.content, str):
+            content += first_chunk.delta.message.content
+        elif isinstance(first_chunk.delta.message.content, list):
+            content_list.extend(first_chunk.delta.message.content)

-            if first_chunk.delta.message.tool_calls:
-                _increase_tool_call(first_chunk.delta.message.tool_calls, tools_calls)
+        if first_chunk.delta.message.tool_calls:
+            _increase_tool_call(first_chunk.delta.message.tool_calls, tools_calls)

-            usage = first_chunk.delta.usage or LLMUsage.empty_usage()
-            system_fingerprint = first_chunk.system_fingerprint
-    finally:
-        try:
-            for _ in chunks:
-                pass
-        except Exception:
-            logger.debug("Failed to drain non-stream plugin chunk iterator.", exc_info=True)
+        usage = first_chunk.delta.usage or LLMUsage.empty_usage()
+        system_fingerprint = first_chunk.system_fingerprint

    return LLMResult(
        model=model,
@@ -294,7 +283,7 @@ class LargeLanguageModel(AIModel):
            # TODO
            raise self._transform_invoke_error(e)

-        if stream and not isinstance(result, LLMResult):
+        if stream and isinstance(result, Generator):
            return self._invoke_result_generator(
                model=model,
                result=result,
@@ -5,11 +5,7 @@ import logging
 from collections.abc import Sequence
 from threading import Lock

-from pydantic import ValidationError
-from redis import RedisError
-
 import contexts
-from configs import dify_config
 from core.model_runtime.entities.model_entities import AIModelEntity, ModelType
 from core.model_runtime.entities.provider_entities import ProviderConfig, ProviderEntity, SimpleProviderEntity
 from core.model_runtime.model_providers.__base.ai_model import AIModel
@@ -22,7 +18,6 @@ from core.model_runtime.model_providers.__base.tts_model import TTSModel
 from core.model_runtime.schema_validators.model_credential_schema_validator import ModelCredentialSchemaValidator
 from core.model_runtime.schema_validators.provider_credential_schema_validator import ProviderCredentialSchemaValidator
 from core.plugin.entities.plugin_daemon import PluginModelProviderEntity
-from extensions.ext_redis import redis_client
 from models.provider_ids import ModelProviderID

 logger = logging.getLogger(__name__)
@@ -180,60 +175,34 @@ class ModelProviderFactory:
        """
        plugin_id, provider_name = self.get_plugin_id_and_provider_name_from_provider(provider)
        cache_key = f"{self.tenant_id}:{plugin_id}:{provider_name}:{model_type.value}:{model}"
+        # sort credentials
        sorted_credentials = sorted(credentials.items()) if credentials else []
        cache_key += ":".join([hashlib.md5(f"{k}:{v}".encode()).hexdigest() for k, v in sorted_credentials])

-        cached_schema_json = None
        try:
-            cached_schema_json = redis_client.get(cache_key)
-        except (RedisError, RuntimeError) as exc:
-            logger.warning(
-                "Failed to read plugin model schema cache for model %s: %s",
-                model,
-                str(exc),
-                exc_info=True,
+            contexts.plugin_model_schemas.get()
+        except LookupError:
+            contexts.plugin_model_schemas.set({})
+            contexts.plugin_model_schema_lock.set(Lock())
+
+        with contexts.plugin_model_schema_lock.get():
+            if cache_key in contexts.plugin_model_schemas.get():
+                return contexts.plugin_model_schemas.get()[cache_key]
+
+            schema = self.plugin_model_manager.get_model_schema(
+                tenant_id=self.tenant_id,
+                user_id="unknown",
+                plugin_id=plugin_id,
+                provider=provider_name,
+                model_type=model_type.value,
+                model=model,
+                credentials=credentials or {},
            )
-        if cached_schema_json:
-            try:
-                return AIModelEntity.model_validate_json(cached_schema_json)
-            except ValidationError:
-                logger.warning(
-                    "Failed to validate cached plugin model schema for model %s",
-                    model,
-                    exc_info=True,
-                )
-                try:
-                    redis_client.delete(cache_key)
-                except (RedisError, RuntimeError) as exc:
-                    logger.warning(
-                        "Failed to delete invalid plugin model schema cache for model %s: %s",
-                        model,
-                        str(exc),
-                        exc_info=True,
-                    )

-        schema = self.plugin_model_manager.get_model_schema(
-            tenant_id=self.tenant_id,
-            user_id="unknown",
-            plugin_id=plugin_id,
-            provider=provider_name,
-            model_type=model_type.value,
-            model=model,
-            credentials=credentials or {},
-        )
+            if schema:
+                contexts.plugin_model_schemas.get()[cache_key] = schema

-        if schema:
-            try:
-                redis_client.setex(cache_key, dify_config.PLUGIN_MODEL_SCHEMA_CACHE_TTL, schema.model_dump_json())
-            except (RedisError, RuntimeError) as exc:
-                logger.warning(
-                    "Failed to write plugin model schema cache for model %s: %s",
-                    model,
-                    str(exc),
-                    exc_info=True,
-                )
-
-        return schema
+            return schema

    def get_models(
        self,
@@ -314,8 +283,6 @@ class ModelProviderFactory:
        elif model_type == ModelType.TTS:
            return TTSModel.model_validate(init_params)

-        raise ValueError(f"Unsupported model type: {model_type}")
-
    def get_provider_icon(self, provider: str, icon_type: str, lang: str) -> tuple[bytes, str]:
        """
        Get provider icon
@@ -5,10 +5,9 @@ from typing import Any
 from core.app.app_config.entities import AppConfig
 from core.moderation.base import ModerationAction, ModerationError
 from core.moderation.factory import ModerationFactory
-from core.ops.ops_trace_manager import TraceQueueManager
+from core.ops.entities.trace_entity import TraceTaskName
+from core.ops.ops_trace_manager import TraceQueueManager, TraceTask
 from core.ops.utils import measure_time
-from core.telemetry import TelemetryContext, TelemetryEvent, TraceTaskName
-from core.telemetry import emit as telemetry_emit

 logger = logging.getLogger(__name__)

@@ -50,18 +49,14 @@ class InputModeration:
            moderation_result = moderation_factory.moderation_for_inputs(inputs, query)

        if trace_manager:
-            telemetry_emit(
-                TelemetryEvent(
-                    name=TraceTaskName.MODERATION_TRACE,
-                    context=TelemetryContext(tenant_id=tenant_id, app_id=app_id),
-                    payload={
-                        "message_id": message_id,
-                        "moderation_result": moderation_result,
-                        "inputs": inputs,
-                        "timer": timer,
-                    },
-                ),
-                trace_manager=trace_manager,
+            trace_manager.add_trace_task(
+                TraceTask(
+                    TraceTaskName.MODERATION_TRACE,
+                    message_id=message_id,
+                    moderation_result=moderation_result,
+                    inputs=inputs,
+                    timer=timer,
+                )
            )

        if not moderation_result.flagged:
@@ -9,8 +9,8 @@ from pydantic import BaseModel, ConfigDict, field_serializer, field_validator
 class BaseTraceInfo(BaseModel):
    message_id: str | None = None
    message_data: Any | None = None
-    inputs: Union[str, dict[str, Any], list[Any]] | None = None
-    outputs: Union[str, dict[str, Any], list[Any]] | None = None
+    inputs: Union[str, dict[str, Any], list] | None = None
+    outputs: Union[str, dict[str, Any], list] | None = None
    start_time: datetime | None = None
    end_time: datetime | None = None
    metadata: dict[str, Any]
@@ -18,7 +18,7 @@ class BaseTraceInfo(BaseModel):

    @field_validator("inputs", "outputs")
    @classmethod
-    def ensure_type(cls, v: str | dict[str, Any] | list[Any] | None) -> str | dict[str, Any] | list[Any] | None:
+    def ensure_type(cls, v):
        if v is None:
            return None
        if isinstance(v, str | dict | list):
@@ -27,48 +27,6 @@ class BaseTraceInfo(BaseModel):

    model_config = ConfigDict(protected_namespaces=())

-    @property
-    def resolved_trace_id(self) -> str | None:
-        """Get trace_id with intelligent fallback.
-
-        Priority:
-        1. External trace_id (from X-Trace-Id header)
-        2. workflow_run_id (if this trace type has it)
-        3. message_id (as final fallback)
-        """
-        if self.trace_id:
-            return self.trace_id
-
-        # Try workflow_run_id (only exists on workflow-related traces)
-        workflow_run_id = getattr(self, "workflow_run_id", None)
-        if workflow_run_id:
-            return workflow_run_id
-
-        # Final fallback to message_id
-        return str(self.message_id) if self.message_id else None
-
-    @property
-    def resolved_parent_context(self) -> tuple[str | None, str | None]:
-        """Resolve cross-workflow parent linking from metadata.
-
-        Extracts typed parent IDs from the untyped ``parent_trace_context``
-        metadata dict (set by tool_node when invoking nested workflows).
-
-        Returns:
-            (trace_correlation_override, parent_span_id_source) where
-            trace_correlation_override is the outer workflow_run_id and
-            parent_span_id_source is the outer node_execution_id.
-        """
-        parent_ctx = self.metadata.get("parent_trace_context")
-        if not isinstance(parent_ctx, dict):
-            return None, None
-        trace_override = parent_ctx.get("parent_workflow_run_id")
-        parent_span = parent_ctx.get("parent_node_execution_id")
-        return (
-            trace_override if isinstance(trace_override, str) else None,
-            parent_span if isinstance(parent_span, str) else None,
-        )
-
    @field_serializer("start_time", "end_time")
    def serialize_datetime(self, dt: datetime | None) -> str | None:
        if dt is None:
@@ -90,14 +48,10 @@ class WorkflowTraceInfo(BaseTraceInfo):
    workflow_run_version: str
    error: str | None = None
    total_tokens: int
-    prompt_tokens: int | None = None
-    completion_tokens: int | None = None
    file_list: list[str]
    query: str
    metadata: dict[str, Any]

-    invoked_by: str | None = None
-

 class MessageTraceInfo(BaseTraceInfo):
    conversation_model: str
@@ -105,7 +59,7 @@ class MessageTraceInfo(BaseTraceInfo):
    answer_tokens: int
    total_tokens: int
    error: str | None = None
-    file_list: Union[str, dict[str, Any], list[Any]] | None = None
+    file_list: Union[str, dict[str, Any], list] | None = None
    message_file_data: Any | None = None
    conversation_mode: str
    gen_ai_server_time_to_first_token: float | None = None
@@ -152,7 +106,7 @@ class ToolTraceInfo(BaseTraceInfo):
    tool_config: dict[str, Any]
    time_cost: Union[int, float]
    tool_parameters: dict[str, Any]
-    file_url: Union[str, None, list[str]] = None
+    file_url: Union[str, None, list] = None


 class GenerateNameTraceInfo(BaseTraceInfo):
@@ -160,79 +114,6 @@ class GenerateNameTraceInfo(BaseTraceInfo):
    tenant_id: str


-class PromptGenerationTraceInfo(BaseTraceInfo):
-    """Trace information for prompt generation operations (rule-generate, code-generate, etc.)."""
-
-    tenant_id: str
-    user_id: str
-    app_id: str | None = None
-
-    operation_type: str
-    instruction: str
-
-    prompt_tokens: int
-    completion_tokens: int
-    total_tokens: int
-
-    model_provider: str
-    model_name: str
-
-    latency: float
-
-    total_price: float | None = None
-    currency: str | None = None
-
-    error: str | None = None
-
-    model_config = ConfigDict(protected_namespaces=())
-
-
-class WorkflowNodeTraceInfo(BaseTraceInfo):
-    workflow_id: str
-    workflow_run_id: str
-    tenant_id: str
-    node_execution_id: str
-    node_id: str
-    node_type: str
-    title: str
-
-    status: str
-    error: str | None = None
-    elapsed_time: float
-
-    index: int
-    predecessor_node_id: str | None = None
-
-    total_tokens: int = 0
-    total_price: float = 0.0
-    currency: str | None = None
-
-    model_provider: str | None = None
-    model_name: str | None = None
-    prompt_tokens: int | None = None
-    completion_tokens: int | None = None
-
-    tool_name: str | None = None
-
-    iteration_id: str | None = None
-    iteration_index: int | None = None
-    loop_id: str | None = None
-    loop_index: int | None = None
-    parallel_id: str | None = None
-
-    node_inputs: Mapping[str, Any] | None = None
-    node_outputs: Mapping[str, Any] | None = None
-    process_data: Mapping[str, Any] | None = None
-
-    invoked_by: str | None = None
-
-    model_config = ConfigDict(protected_namespaces=())
-
-
-class DraftNodeExecutionTrace(WorkflowNodeTraceInfo):
-    pass
-
-
 class TaskData(BaseModel):
    app_id: str
    trace_info_type: str
@@ -247,38 +128,16 @@ trace_info_info_map = {
    "DatasetRetrievalTraceInfo": DatasetRetrievalTraceInfo,
    "ToolTraceInfo": ToolTraceInfo,
    "GenerateNameTraceInfo": GenerateNameTraceInfo,
-    "PromptGenerationTraceInfo": PromptGenerationTraceInfo,
-    "WorkflowNodeTraceInfo": WorkflowNodeTraceInfo,
-    "DraftNodeExecutionTrace": DraftNodeExecutionTrace,
 }


-class OperationType(StrEnum):
-    """Operation type for token metric labels.
-
-    Used as a metric attribute on ``dify.tokens.input`` / ``dify.tokens.output``
-    counters so consumers can break down token usage by operation.
-    """
-
-    WORKFLOW = "workflow"
-    NODE_EXECUTION = "node_execution"
-    MESSAGE = "message"
-    RULE_GENERATE = "rule_generate"
-    CODE_GENERATE = "code_generate"
-    STRUCTURED_OUTPUT = "structured_output"
-    INSTRUCTION_MODIFY = "instruction_modify"
-
-
 class TraceTaskName(StrEnum):
    CONVERSATION_TRACE = "conversation"
    WORKFLOW_TRACE = "workflow"
-    DRAFT_NODE_EXECUTION_TRACE = "draft_node_execution"
    MESSAGE_TRACE = "message"
    MODERATION_TRACE = "moderation"
    SUGGESTED_QUESTION_TRACE = "suggested_question"
    DATASET_RETRIEVAL_TRACE = "dataset_retrieval"
    TOOL_TRACE = "tool"
    GENERATE_NAME_TRACE = "generate_conversation_name"
-    PROMPT_GENERATION_TRACE = "prompt_generation"
    DATASOURCE_TRACE = "datasource"
-    NODE_EXECUTION_TRACE = "node_execution"
@@ -3,7 +3,6 @@ import os
 from datetime import datetime, timedelta

 from langfuse import Langfuse
-from sqlalchemy import select
 from sqlalchemy.orm import sessionmaker

 from core.ops.base_trace_instance import BaseTraceInstance
@@ -31,7 +30,7 @@ from core.ops.utils import filter_none_values
 from core.repositories import DifyCoreRepositoryFactory
 from core.workflow.enums import NodeType
 from extensions.ext_database import db
-from models import EndUser, Message, WorkflowNodeExecutionTriggeredFrom
+from models import EndUser, WorkflowNodeExecutionTriggeredFrom
 from models.enums import MessageStatus

 logger = logging.getLogger(__name__)
@@ -72,50 +71,7 @@ class LangFuseDataTrace(BaseTraceInstance):
        metadata = trace_info.metadata
        metadata["workflow_app_log_id"] = trace_info.workflow_app_log_id

-        # Check for parent_trace_context to detect nested workflow
-        parent_trace_context = trace_info.metadata.get("parent_trace_context")
-
-        if parent_trace_context:
-            # Nested workflow: create span under outer trace
-            outer_trace_id = parent_trace_context.get("trace_id")
-            parent_node_execution_id = parent_trace_context.get("parent_node_execution_id")
-            parent_conversation_id = parent_trace_context.get("parent_conversation_id")
-            parent_workflow_run_id = parent_trace_context.get("parent_workflow_run_id")
-
-            # Resolve outer trace_id: try message_id lookup first, fallback to workflow_run_id
-            if parent_conversation_id:
-                session_factory = sessionmaker(bind=db.engine)
-                with session_factory() as session:
-                    message_data_stmt = select(Message.id).where(
-                        Message.conversation_id == parent_conversation_id,
-                        Message.workflow_run_id == parent_workflow_run_id,
-                    )
-                    resolved_message_id = session.scalar(message_data_stmt)
-                    if resolved_message_id:
-                        outer_trace_id = resolved_message_id
-                    else:
-                        outer_trace_id = parent_workflow_run_id
-            else:
-                outer_trace_id = parent_workflow_run_id
-
-            # Create inner workflow span under outer trace
-            workflow_span_data = LangfuseSpan(
-                id=trace_info.workflow_run_id,
-                name=TraceTaskName.WORKFLOW_TRACE,
-                input=dict(trace_info.workflow_run_inputs),
-                output=dict(trace_info.workflow_run_outputs),
-                trace_id=outer_trace_id,
-                parent_observation_id=parent_node_execution_id,
-                start_time=trace_info.start_time,
-                end_time=trace_info.end_time,
-                metadata=metadata,
-                level=LevelEnum.DEFAULT if trace_info.error == "" else LevelEnum.ERROR,
-                status_message=trace_info.error or "",
-            )
-            self.add_span(langfuse_span_data=workflow_span_data)
-            # Use outer_trace_id for all node spans/generations
-            trace_id = outer_trace_id
-        elif trace_info.message_id:
+        if trace_info.message_id:
            trace_id = trace_info.trace_id or trace_info.message_id
            name = TraceTaskName.MESSAGE_TRACE
            trace_data = LangfuseTrace(
@@ -218,11 +174,6 @@ class LangFuseDataTrace(BaseTraceInstance):
                    }
                )

-            # Determine parent_observation_id for nested workflows
-            node_parent_observation_id = None
-            if parent_trace_context or trace_info.message_id:
-                node_parent_observation_id = trace_info.workflow_run_id
-
            # add generation span
            if process_data and process_data.get("model_mode") == "chat":
                total_token = metadata.get("total_tokens", 0)
@@ -255,7 +206,7 @@ class LangFuseDataTrace(BaseTraceInstance):
                    metadata=metadata,
                    level=(LevelEnum.DEFAULT if status == "succeeded" else LevelEnum.ERROR),
                    status_message=trace_info.error or "",
-                    parent_observation_id=node_parent_observation_id,
+                    parent_observation_id=trace_info.workflow_run_id if trace_info.message_id else None,
                    usage=generation_usage,
                )

@@ -274,7 +225,7 @@ class LangFuseDataTrace(BaseTraceInstance):
                    metadata=metadata,
                    level=(LevelEnum.DEFAULT if status == "succeeded" else LevelEnum.ERROR),
                    status_message=trace_info.error or "",
-                    parent_observation_id=node_parent_observation_id,
+                    parent_observation_id=trace_info.workflow_run_id if trace_info.message_id else None,
                )

                self.add_span(langfuse_span_data=span_data)
@@ -6,7 +6,6 @@ from typing import cast

 from langsmith import Client
 from langsmith.schemas import RunBase
-from sqlalchemy import select
 from sqlalchemy.orm import sessionmaker

 from core.ops.base_trace_instance import BaseTraceInstance
@@ -31,7 +30,7 @@ from core.ops.utils import filter_none_values, generate_dotted_order
 from core.repositories import DifyCoreRepositoryFactory
 from core.workflow.enums import NodeType, WorkflowNodeExecutionMetadataKey
 from extensions.ext_database import db
-from models import EndUser, Message, MessageFile, WorkflowNodeExecutionTriggeredFrom
+from models import EndUser, MessageFile, WorkflowNodeExecutionTriggeredFrom

 logger = logging.getLogger(__name__)

@@ -65,35 +64,7 @@ class LangSmithDataTrace(BaseTraceInstance):
            self.generate_name_trace(trace_info)

    def workflow_trace(self, trace_info: WorkflowTraceInfo):
-        # Check for parent_trace_context for cross-workflow linking
-        parent_trace_context = trace_info.metadata.get("parent_trace_context")
-
-        if parent_trace_context:
-            # Inner workflow: resolve outer trace_id and link to parent node
-            outer_trace_id = parent_trace_context.get("parent_workflow_run_id")
-
-            # Try to resolve message_id from conversation_id if available
-            if parent_trace_context.get("parent_conversation_id"):
-                try:
-                    session_factory = sessionmaker(bind=db.engine)
-                    with session_factory() as session:
-                        message_data_stmt = select(Message.id).where(
-                            Message.conversation_id == parent_trace_context["parent_conversation_id"],
-                            Message.workflow_run_id == parent_trace_context["parent_workflow_run_id"],
-                        )
-                        resolved_message_id = session.scalar(message_data_stmt)
-                        if resolved_message_id:
-                            outer_trace_id = resolved_message_id
-                except Exception as e:
-                    logger.debug("Failed to resolve message_id from conversation_id: %s", str(e))
-
-            trace_id = outer_trace_id
-            parent_run_id = parent_trace_context.get("parent_node_execution_id")
-        else:
-            # Outer workflow: existing behavior
-            trace_id = trace_info.trace_id or trace_info.message_id or trace_info.workflow_run_id
-            parent_run_id = trace_info.message_id or None
-
+        trace_id = trace_info.trace_id or trace_info.message_id or trace_info.workflow_run_id
        if trace_info.start_time is None:
            trace_info.start_time = datetime.now()
        message_dotted_order = (
@@ -107,8 +78,7 @@ class LangSmithDataTrace(BaseTraceInstance):
        metadata = trace_info.metadata
        metadata["workflow_app_log_id"] = trace_info.workflow_app_log_id

-        # Only create message_run for outer workflows (no parent_trace_context)
-        if trace_info.message_id and not parent_trace_context:
+        if trace_info.message_id:
            message_run = LangSmithRunModel(
                id=trace_info.message_id,
                name=TraceTaskName.MESSAGE_TRACE,
@@ -151,9 +121,9 @@ class LangSmithDataTrace(BaseTraceInstance):
            },
            error=trace_info.error,
            tags=["workflow"],
-            parent_run_id=parent_run_id,
+            parent_run_id=trace_info.message_id or None,
            trace_id=trace_id,
-            dotted_order=None if parent_trace_context else workflow_dotted_order,
+            dotted_order=workflow_dotted_order,
            serialized=None,
            events=[],
            session_id=None,
@@ -21,26 +21,19 @@ from core.ops.entities.config_entity import (
 )
 from core.ops.entities.trace_entity import (
    DatasetRetrievalTraceInfo,
-    DraftNodeExecutionTrace,
    GenerateNameTraceInfo,
    MessageTraceInfo,
    ModerationTraceInfo,
-    PromptGenerationTraceInfo,
    SuggestedQuestionTraceInfo,
    TaskData,
    ToolTraceInfo,
    TraceTaskName,
-    WorkflowNodeTraceInfo,
    WorkflowTraceInfo,
 )
 from core.ops.utils import get_message_data
 from extensions.ext_database import db
 from extensions.ext_storage import storage
-from models.account import Tenant
-from models.dataset import Dataset
 from models.model import App, AppModelConfig, Conversation, Message, MessageFile, TraceAppConfig
-from models.provider import Provider, ProviderCredential, ProviderModel, ProviderModelCredential, ProviderType
-from models.tools import ApiToolProvider, BuiltinToolProvider, MCPToolProvider, WorkflowToolProvider
 from models.workflow import WorkflowAppLog
 from tasks.ops_trace_task import process_trace_tasks

@@ -50,139 +43,6 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)


-def _lookup_app_and_workspace_names(app_id: str | None, tenant_id: str | None) -> tuple[str, str]:
-    """Return (app_name, workspace_name) for the given IDs. Falls back to empty strings."""
-    app_name = ""
-    workspace_name = ""
-    if not app_id and not tenant_id:
-        return app_name, workspace_name
-    with Session(db.engine) as session:
-        if app_id:
-            name = session.scalar(select(App.name).where(App.id == app_id))
-            if name:
-                app_name = name
-        if tenant_id:
-            name = session.scalar(select(Tenant.name).where(Tenant.id == tenant_id))
-            if name:
-                workspace_name = name
-    return app_name, workspace_name
-
-
-_PROVIDER_TYPE_TO_MODEL: dict[str, type] = {
-    "builtin": BuiltinToolProvider,
-    "plugin": BuiltinToolProvider,
-    "api": ApiToolProvider,
-    "workflow": WorkflowToolProvider,
-    "mcp": MCPToolProvider,
-}
-
-
-def _lookup_credential_name(credential_id: str | None, provider_type: str | None) -> str:
-    if not credential_id:
-        return ""
-    model_cls = _PROVIDER_TYPE_TO_MODEL.get(provider_type or "")
-    if not model_cls:
-        return ""
-    with Session(db.engine) as session:
-        name = session.scalar(select(model_cls.name).where(model_cls.id == credential_id))
-        return str(name) if name else ""
-
-
-def _lookup_llm_credential_info(
-    tenant_id: str | None, provider: str | None, model: str | None, model_type: str | None = "llm"
-) -> tuple[str | None, str]:
-    """
-    Lookup LLM credential ID and name for the given provider and model.
-    Returns (credential_id, credential_name).
-
-    Handles async timing issues gracefully - if credential is deleted between lookups,
-    returns the ID but empty name rather than failing.
-    """
-    if not tenant_id or not provider:
-        return None, ""
-
-    try:
-        with Session(db.engine) as session:
-            # Try to find provider-level or model-level configuration
-            provider_record = session.scalar(
-                select(Provider).where(
-                    Provider.tenant_id == tenant_id,
-                    Provider.provider_name == provider,
-                    Provider.provider_type == ProviderType.CUSTOM,
-                )
-            )
-
-            if not provider_record:
-                return None, ""
-
-            # Check if there's a model-specific config
-            credential_id = None
-            credential_name = ""
-            is_model_level = False
-
-            if model and provider_record.credential_id:
-                # Try model-level first
-                model_record = session.scalar(
-                    select(ProviderModel).where(
-                        ProviderModel.tenant_id == tenant_id,
-                        ProviderModel.provider_name == provider,
-                        ProviderModel.model_name == model,
-                        ProviderModel.model_type == model_type,
-                    )
-                )
-
-                if model_record and model_record.credential_id:
-                    credential_id = model_record.credential_id
-                    is_model_level = True
-
-            if not credential_id and provider_record.credential_id:
-                # Fall back to provider-level credential
-                credential_id = provider_record.credential_id
-                is_model_level = False
-
-            # Lookup credential_name if we have credential_id
-            if credential_id:
-                try:
-                    if is_model_level:
-                        # Query ProviderModelCredential
-                        cred_name = session.scalar(
-                            select(ProviderModelCredential.credential_name).where(
-                                ProviderModelCredential.id == credential_id
-                            )
-                        )
-                    else:
-                        # Query ProviderCredential
-                        cred_name = session.scalar(
-                            select(ProviderCredential.credential_name).where(ProviderCredential.id == credential_id)
-                        )
-
-                    if cred_name:
-                        credential_name = str(cred_name)
-                except Exception as e:
-                    # Credential might have been deleted between lookups (async timing)
-                    # Return ID but empty name rather than failing
-                    logger.warning(
-                        "Failed to lookup credential name for credential_id=%s (provider=%s, model=%s): %s",
-                        credential_id,
-                        provider,
-                        model,
-                        str(e),
-                    )
-
-            return credential_id, credential_name
-    except Exception as e:
-        # Database query failed or other unexpected error
-        # Return empty rather than propagating error to telemetry emission
-        logger.warning(
-            "Failed to lookup LLM credential info for tenant_id=%s, provider=%s, model=%s: %s",
-            tenant_id,
-            provider,
-            model,
-            str(e),
-        )
-        return None, ""
-
-
 class OpsTraceProviderConfigMap(collections.UserDict[str, dict[str, Any]]):
    def __getitem__(self, provider: str) -> dict[str, Any]:
        match provider:
@@ -457,10 +317,6 @@ class OpsTraceManager:
        if app_id is None:
            return None

-        # Handle storage_id format (tenant-{uuid}) - not a real app_id
-        if isinstance(app_id, str) and app_id.startswith("tenant-"):
-            return None
-
        app: App | None = db.session.query(App).where(App.id == app_id).first()

        if app is None:
@@ -623,56 +479,6 @@ class TraceTask:
                    cls._workflow_run_repo = DifyAPIRepositoryFactory.create_api_workflow_run_repository(session_maker)
        return cls._workflow_run_repo

-    @classmethod
-    def _get_user_id_from_metadata(cls, metadata: dict[str, Any]) -> str:
-        """Extract user ID from metadata, prioritizing end_user over account.
-
-        Returns the actual user ID (end_user or account) who invoked the workflow,
-        regardless of invoke_from context.
-        """
-        # Priority 1: End user (external users via API/WebApp)
-        if user_id := metadata.get("from_end_user_id"):
-            return f"end_user:{user_id}"
-
-        # Priority 2: Account user (internal users via console/debugger)
-        if user_id := metadata.get("from_account_id"):
-            return f"account:{user_id}"
-
-        # Priority 3: User (internal users via console/debugger)
-        if user_id := metadata.get("user_id"):
-            return f"user:{user_id}"
-
-        return "anonymous"
-
-    @classmethod
-    def _calculate_workflow_token_split(cls, workflow_run_id: str, tenant_id: str) -> tuple[int, int]:
-        from core.workflow.enums import WorkflowNodeExecutionMetadataKey
-        from models.workflow import WorkflowNodeExecutionModel
-
-        with Session(db.engine) as session:
-            node_executions = session.scalars(
-                select(WorkflowNodeExecutionModel).where(
-                    WorkflowNodeExecutionModel.tenant_id == tenant_id,
-                    WorkflowNodeExecutionModel.workflow_run_id == workflow_run_id,
-                )
-            ).all()
-
-            total_prompt = 0
-            total_completion = 0
-
-            for node_exec in node_executions:
-                metadata = node_exec.execution_metadata_dict
-
-                prompt = metadata.get(WorkflowNodeExecutionMetadataKey.PROMPT_TOKENS)
-                if prompt is not None:
-                    total_prompt += prompt
-
-                completion = metadata.get(WorkflowNodeExecutionMetadataKey.COMPLETION_TOKENS)
-                if completion is not None:
-                    total_completion += completion
-
-            return (total_prompt, total_completion)
-
    def __init__(
        self,
        trace_type: Any,
@@ -693,8 +499,6 @@ class TraceTask:
        self.app_id = None
        self.trace_id = None
        self.kwargs = kwargs
-        if user_id is not None and "user_id" not in self.kwargs:
-            self.kwargs["user_id"] = user_id
        external_trace_id = kwargs.get("external_trace_id")
        if external_trace_id:
            self.trace_id = external_trace_id
@@ -708,7 +512,7 @@ class TraceTask:
            TraceTaskName.WORKFLOW_TRACE: lambda: self.workflow_trace(
                workflow_run_id=self.workflow_run_id, conversation_id=self.conversation_id, user_id=self.user_id
            ),
-            TraceTaskName.MESSAGE_TRACE: lambda: self.message_trace(message_id=self.message_id, **self.kwargs),
+            TraceTaskName.MESSAGE_TRACE: lambda: self.message_trace(message_id=self.message_id),
            TraceTaskName.MODERATION_TRACE: lambda: self.moderation_trace(
                message_id=self.message_id, timer=self.timer, **self.kwargs
            ),
@@ -724,9 +528,6 @@ class TraceTask:
            TraceTaskName.GENERATE_NAME_TRACE: lambda: self.generate_name_trace(
                conversation_id=self.conversation_id, timer=self.timer, **self.kwargs
            ),
-            TraceTaskName.PROMPT_GENERATION_TRACE: lambda: self.prompt_generation_trace(**self.kwargs),
-            TraceTaskName.NODE_EXECUTION_TRACE: lambda: self.node_execution_trace(**self.kwargs),
-            TraceTaskName.DRAFT_NODE_EXECUTION_TRACE: lambda: self.draft_node_execution_trace(**self.kwargs),
        }

        return preprocess_map.get(self.trace_type, lambda: None)()
@@ -762,10 +563,6 @@ class TraceTask:

        total_tokens = workflow_run.total_tokens

-        prompt_tokens, completion_tokens = self._calculate_workflow_token_split(
-            workflow_run_id=workflow_run_id, tenant_id=tenant_id
-        )
-
        file_list = workflow_run_inputs.get("sys.file") or []
        query = workflow_run_inputs.get("query") or workflow_run_inputs.get("sys.query") or ""

@@ -786,14 +583,7 @@ class TraceTask:
                )
                message_id = session.scalar(message_data_stmt)

-        from core.telemetry.gateway import is_enterprise_telemetry_enabled
-
-        if is_enterprise_telemetry_enabled():
-            app_name, workspace_name = _lookup_app_and_workspace_names(workflow_run.app_id, tenant_id)
-        else:
-            app_name, workspace_name = "", ""
-
-        metadata: dict[str, Any] = {
+        metadata = {
            "workflow_id": workflow_id,
            "conversation_id": conversation_id,
            "workflow_run_id": workflow_run_id,
@@ -806,14 +596,8 @@ class TraceTask:
            "triggered_from": workflow_run.triggered_from,
            "user_id": user_id,
            "app_id": workflow_run.app_id,
-            "app_name": app_name,
-            "workspace_name": workspace_name,
        }

-        parent_trace_context = self.kwargs.get("parent_trace_context")
-        if parent_trace_context:
-            metadata["parent_trace_context"] = parent_trace_context
-
        workflow_trace_info = WorkflowTraceInfo(
            trace_id=self.trace_id,
            workflow_data=workflow_run.to_dict(),
@@ -828,8 +612,6 @@ class TraceTask:
            workflow_run_version=workflow_run_version,
            error=error,
            total_tokens=total_tokens,
-            prompt_tokens=prompt_tokens,
-            completion_tokens=completion_tokens,
            file_list=file_list,
            query=query,
            metadata=metadata,
@@ -837,11 +619,10 @@ class TraceTask:
            message_id=message_id,
            start_time=workflow_run.created_at,
            end_time=workflow_run.finished_at,
-            invoked_by=self._get_user_id_from_metadata(metadata),
        )
        return workflow_trace_info

-    def message_trace(self, message_id: str | None, **kwargs):
+    def message_trace(self, message_id: str | None):
        if not message_id:
            return {}
        message_data = get_message_data(message_id)
@@ -864,19 +645,6 @@ class TraceTask:

        streaming_metrics = self._extract_streaming_metrics(message_data)

-        tenant_id = ""
-        with Session(db.engine) as session:
-            tid = session.scalar(select(App.tenant_id).where(App.id == message_data.app_id))
-            if tid:
-                tenant_id = str(tid)
-
-        from core.telemetry.gateway import is_enterprise_telemetry_enabled
-
-        if is_enterprise_telemetry_enabled():
-            app_name, workspace_name = _lookup_app_and_workspace_names(message_data.app_id, tenant_id)
-        else:
-            app_name, workspace_name = "", ""
-
        metadata = {
            "conversation_id": message_data.conversation_id,
            "ls_provider": message_data.model_provider,
@@ -888,14 +656,7 @@ class TraceTask:
            "workflow_run_id": message_data.workflow_run_id,
            "from_source": message_data.from_source,
            "message_id": message_id,
-            "tenant_id": tenant_id,
-            "app_id": message_data.app_id,
-            "user_id": message_data.from_end_user_id or message_data.from_account_id,
-            "app_name": app_name,
-            "workspace_name": workspace_name,
        }
-        if node_execution_id := kwargs.get("node_execution_id"):
-            metadata["node_execution_id"] = node_execution_id

        message_tokens = message_data.message_tokens

@@ -912,9 +673,7 @@ class TraceTask:
            outputs=message_data.answer,
            file_list=file_list,
            start_time=created_at,
-            end_time=message_data.updated_at
-            if message_data.updated_at and message_data.updated_at > created_at
-            else created_at + timedelta(seconds=message_data.provider_response_latency),
+            end_time=created_at + timedelta(seconds=message_data.provider_response_latency),
            metadata=metadata,
            message_file_data=message_file_data,
            conversation_mode=conversation_mode,
@@ -939,8 +698,6 @@ class TraceTask:
            "preset_response": moderation_result.preset_response,
            "query": moderation_result.query,
        }
-        if node_execution_id := kwargs.get("node_execution_id"):
-            metadata["node_execution_id"] = node_execution_id

        # get workflow_app_log_id
        workflow_app_log_id = None
@@ -982,8 +739,6 @@ class TraceTask:
            "workflow_run_id": message_data.workflow_run_id,
            "from_source": message_data.from_source,
        }
-        if node_execution_id := kwargs.get("node_execution_id"):
-            metadata["node_execution_id"] = node_execution_id

        # get workflow_app_log_id
        workflow_app_log_id = None
@@ -1023,52 +778,6 @@ class TraceTask:
        if not message_data:
            return {}

-        tenant_id = ""
-        with Session(db.engine) as session:
-            tid = session.scalar(select(App.tenant_id).where(App.id == message_data.app_id))
-            if tid:
-                tenant_id = str(tid)
-
-        from core.telemetry.gateway import is_enterprise_telemetry_enabled
-
-        if is_enterprise_telemetry_enabled():
-            app_name, workspace_name = _lookup_app_and_workspace_names(message_data.app_id, tenant_id)
-        else:
-            app_name, workspace_name = "", ""
-
-        doc_list = [doc.model_dump() for doc in documents] if documents else []
-        dataset_ids: set[str] = set()
-        for doc in doc_list:
-            doc_meta = doc.get("metadata") or {}
-            did = doc_meta.get("dataset_id")
-            if did:
-                dataset_ids.add(did)
-
-        embedding_models: dict[str, dict[str, str]] = {}
-        if dataset_ids:
-            with Session(db.engine) as session:
-                rows = session.execute(
-                    select(Dataset.id, Dataset.embedding_model, Dataset.embedding_model_provider).where(
-                        Dataset.id.in_(list(dataset_ids))
-                    )
-                ).all()
-                for row in rows:
-                    embedding_models[str(row[0])] = {
-                        "embedding_model": row[1] or "",
-                        "embedding_model_provider": row[2] or "",
-                    }
-
-        # Extract rerank model info from retrieval_model kwargs
-        rerank_model_provider = ""
-        rerank_model_name = ""
-        if "retrieval_model" in kwargs:
-            retrieval_model = kwargs["retrieval_model"]
-            if isinstance(retrieval_model, dict):
-                reranking_model = retrieval_model.get("reranking_model")
-                if isinstance(reranking_model, dict):
-                    rerank_model_provider = reranking_model.get("reranking_provider_name", "")
-                    rerank_model_name = reranking_model.get("reranking_model_name", "")
-
        metadata = {
            "message_id": message_id,
            "ls_provider": message_data.model_provider,
@@ -1079,23 +788,13 @@ class TraceTask:
            "agent_based": message_data.agent_based,
            "workflow_run_id": message_data.workflow_run_id,
            "from_source": message_data.from_source,
-            "tenant_id": tenant_id,
-            "app_id": message_data.app_id,
-            "user_id": message_data.from_end_user_id or message_data.from_account_id,
-            "app_name": app_name,
-            "workspace_name": workspace_name,
-            "embedding_models": embedding_models,
-            "rerank_model_provider": rerank_model_provider,
-            "rerank_model_name": rerank_model_name,
        }
-        if node_execution_id := kwargs.get("node_execution_id"):
-            metadata["node_execution_id"] = node_execution_id

        dataset_retrieval_trace_info = DatasetRetrievalTraceInfo(
            trace_id=self.trace_id,
            message_id=message_id,
            inputs=message_data.query or message_data.inputs,
-            documents=doc_list,
+            documents=[doc.model_dump() for doc in documents] if documents else [],
            start_time=timer.get("start"),
            end_time=timer.get("end"),
            metadata=metadata,
@@ -1138,10 +837,6 @@ class TraceTask:
            "error": error,
            "tool_parameters": tool_parameters,
        }
-        if message_data.workflow_run_id:
-            metadata["workflow_run_id"] = message_data.workflow_run_id
-        if node_execution_id := kwargs.get("node_execution_id"):
-            metadata["node_execution_id"] = node_execution_id

        file_url = ""
        message_file_data = db.session.query(MessageFile).filter_by(message_id=message_id).first()
@@ -1196,8 +891,6 @@ class TraceTask:
            "conversation_id": conversation_id,
            "tenant_id": tenant_id,
        }
-        if node_execution_id := kwargs.get("node_execution_id"):
-            metadata["node_execution_id"] = node_execution_id

        generate_name_trace_info = GenerateNameTraceInfo(
            trace_id=self.trace_id,
@@ -1212,182 +905,6 @@ class TraceTask:

        return generate_name_trace_info

-    def prompt_generation_trace(self, **kwargs) -> PromptGenerationTraceInfo | dict:
-        tenant_id = kwargs.get("tenant_id", "")
-        user_id = kwargs.get("user_id", "")
-        app_id = kwargs.get("app_id")
-        operation_type = kwargs.get("operation_type", "")
-        instruction = kwargs.get("instruction", "")
-        generated_output = kwargs.get("generated_output", "")
-
-        prompt_tokens = kwargs.get("prompt_tokens", 0)
-        completion_tokens = kwargs.get("completion_tokens", 0)
-        total_tokens = kwargs.get("total_tokens", 0)
-
-        model_provider = kwargs.get("model_provider", "")
-        model_name = kwargs.get("model_name", "")
-
-        latency = kwargs.get("latency", 0.0)
-
-        timer = kwargs.get("timer")
-        start_time = timer.get("start") if timer else None
-        end_time = timer.get("end") if timer else None
-
-        total_price = kwargs.get("total_price")
-        currency = kwargs.get("currency")
-
-        error = kwargs.get("error")
-
-        app_name = None
-        workspace_name = None
-        if app_id:
-            app_name, workspace_name = _lookup_app_and_workspace_names(app_id, tenant_id)
-
-        metadata = {
-            "tenant_id": tenant_id,
-            "user_id": user_id,
-            "app_id": app_id or "",
-            "app_name": app_name,
-            "workspace_name": workspace_name,
-            "operation_type": operation_type,
-            "model_provider": model_provider,
-            "model_name": model_name,
-        }
-        if node_execution_id := kwargs.get("node_execution_id"):
-            metadata["node_execution_id"] = node_execution_id
-
-        return PromptGenerationTraceInfo(
-            trace_id=self.trace_id,
-            inputs=instruction,
-            outputs=generated_output,
-            start_time=start_time,
-            end_time=end_time,
-            metadata=metadata,
-            tenant_id=tenant_id,
-            user_id=user_id,
-            app_id=app_id,
-            operation_type=operation_type,
-            instruction=instruction,
-            prompt_tokens=prompt_tokens,
-            completion_tokens=completion_tokens,
-            total_tokens=total_tokens,
-            model_provider=model_provider,
-            model_name=model_name,
-            latency=latency,
-            total_price=total_price,
-            currency=currency,
-            error=error,
-        )
-
-    def node_execution_trace(self, **kwargs) -> WorkflowNodeTraceInfo | dict:
-        node_data: dict = kwargs.get("node_execution_data", {})
-        if not node_data:
-            return {}
-
-        from core.telemetry.gateway import is_enterprise_telemetry_enabled
-
-        if is_enterprise_telemetry_enabled():
-            app_name, workspace_name = _lookup_app_and_workspace_names(
-                node_data.get("app_id"), node_data.get("tenant_id")
-            )
-        else:
-            app_name, workspace_name = "", ""
-
-        # Try tool credential lookup first
-        credential_id = node_data.get("credential_id")
-        if is_enterprise_telemetry_enabled():
-            credential_name = _lookup_credential_name(credential_id, node_data.get("credential_provider_type"))
-            # If no credential_id found (e.g., LLM nodes), try LLM credential lookup
-            if not credential_id:
-                llm_cred_id, llm_cred_name = _lookup_llm_credential_info(
-                    tenant_id=node_data.get("tenant_id"),
-                    provider=node_data.get("model_provider"),
-                    model=node_data.get("model_name"),
-                    model_type="llm",
-                )
-                if llm_cred_id:
-                    credential_id = llm_cred_id
-                    credential_name = llm_cred_name
-        else:
-            credential_name = ""
-        metadata: dict[str, Any] = {
-            "tenant_id": node_data.get("tenant_id"),
-            "app_id": node_data.get("app_id"),
-            "app_name": app_name,
-            "workspace_name": workspace_name,
-            "user_id": node_data.get("user_id"),
-            "invoke_from": node_data.get("invoke_from"),
-            "credential_id": node_data.get("credential_id"),
-            "credential_name": credential_name,
-            "dataset_ids": node_data.get("dataset_ids"),
-            "dataset_names": node_data.get("dataset_names"),
-            "plugin_name": node_data.get("plugin_name"),
-        }
-
-        parent_trace_context = node_data.get("parent_trace_context")
-        if parent_trace_context:
-            metadata["parent_trace_context"] = parent_trace_context
-
-        message_id: str | None = None
-        conversation_id = node_data.get("conversation_id")
-        workflow_execution_id = node_data.get("workflow_execution_id")
-        if conversation_id and workflow_execution_id and not parent_trace_context:
-            with Session(db.engine) as session:
-                msg_id = session.scalar(
-                    select(Message.id).where(
-                        Message.conversation_id == conversation_id,
-                        Message.workflow_run_id == workflow_execution_id,
-                    )
-                )
-                if msg_id:
-                    message_id = str(msg_id)
-                    metadata["message_id"] = message_id
-            if conversation_id:
-                metadata["conversation_id"] = conversation_id
-
-        return WorkflowNodeTraceInfo(
-            trace_id=self.trace_id,
-            message_id=message_id,
-            start_time=node_data.get("created_at"),
-            end_time=node_data.get("finished_at"),
-            metadata=metadata,
-            workflow_id=node_data.get("workflow_id", ""),
-            workflow_run_id=node_data.get("workflow_execution_id", ""),
-            tenant_id=node_data.get("tenant_id", ""),
-            node_execution_id=node_data.get("node_execution_id", ""),
-            node_id=node_data.get("node_id", ""),
-            node_type=node_data.get("node_type", ""),
-            title=node_data.get("title", ""),
-            status=node_data.get("status", ""),
-            error=node_data.get("error"),
-            elapsed_time=node_data.get("elapsed_time", 0.0),
-            index=node_data.get("index", 0),
-            predecessor_node_id=node_data.get("predecessor_node_id"),
-            total_tokens=node_data.get("total_tokens", 0),
-            total_price=node_data.get("total_price", 0.0),
-            currency=node_data.get("currency"),
-            model_provider=node_data.get("model_provider"),
-            model_name=node_data.get("model_name"),
-            prompt_tokens=node_data.get("prompt_tokens"),
-            completion_tokens=node_data.get("completion_tokens"),
-            tool_name=node_data.get("tool_name"),
-            iteration_id=node_data.get("iteration_id"),
-            iteration_index=node_data.get("iteration_index"),
-            loop_id=node_data.get("loop_id"),
-            loop_index=node_data.get("loop_index"),
-            parallel_id=node_data.get("parallel_id"),
-            node_inputs=node_data.get("node_inputs"),
-            node_outputs=node_data.get("node_outputs"),
-            process_data=node_data.get("process_data"),
-            invoked_by=self._get_user_id_from_metadata(metadata),
-        )
-
-    def draft_node_execution_trace(self, **kwargs) -> DraftNodeExecutionTrace | dict:
-        node_trace = self.node_execution_trace(**kwargs)
-        if not node_trace or not isinstance(node_trace, WorkflowNodeTraceInfo):
-            return node_trace
-        return DraftNodeExecutionTrace(**node_trace.model_dump())
-
    def _extract_streaming_metrics(self, message_data) -> dict:
        if not message_data.message_metadata:
            return {}
@@ -1421,17 +938,13 @@ class TraceQueueManager:
        self.user_id = user_id
        self.trace_instance = OpsTraceManager.get_ops_trace_instance(app_id)
        self.flask_app = current_app._get_current_object()  # type: ignore
-
-        from core.telemetry.gateway import is_enterprise_telemetry_enabled
-
-        self._enterprise_telemetry_enabled = is_enterprise_telemetry_enabled()
        if trace_manager_timer is None:
            self.start_timer()

    def add_trace_task(self, trace_task: TraceTask):
        global trace_manager_timer, trace_manager_queue
        try:
-            if self._enterprise_telemetry_enabled or self.trace_instance:
+            if self.trace_instance:
                trace_task.app_id = self.app_id
                trace_manager_queue.put(trace_task)
        except Exception:
@@ -1467,27 +980,20 @@ class TraceQueueManager:
    def send_to_celery(self, tasks: list[TraceTask]):
        with self.flask_app.app_context():
            for task in tasks:
-                storage_id = task.app_id
-                if storage_id is None:
-                    tenant_id = task.kwargs.get("tenant_id")
-                    if tenant_id:
-                        storage_id = f"tenant-{tenant_id}"
-                    else:
-                        logger.warning("Skipping trace without app_id or tenant_id, trace_type: %s", task.trace_type)
-                        continue
-
+                if task.app_id is None:
+                    continue
                file_id = uuid4().hex
                trace_info = task.execute()

                task_data = TaskData(
-                    app_id=storage_id,
+                    app_id=task.app_id,
                    trace_info_type=type(trace_info).__name__,
                    trace_info=trace_info.model_dump() if trace_info else None,
                )
-                file_path = f"{OPS_FILE_PATH}{storage_id}/{file_id}.json"
+                file_path = f"{OPS_FILE_PATH}{task.app_id}/{file_id}.json"
                storage.save(file_path, task_data.model_dump_json().encode("utf-8"))
                file_info = {
                    "file_id": file_id,
-                    "app_id": storage_id,
+                    "app_id": task.app_id,
                }
                process_trace_tasks.delay(file_info)  # type: ignore
@@ -24,13 +24,7 @@ from core.rag.rerank.rerank_type import RerankMode
 from core.rag.retrieval.retrieval_methods import RetrievalMethod
 from core.tools.signature import sign_upload_file
 from extensions.ext_database import db
-from models.dataset import (
-    ChildChunk,
-    Dataset,
-    DocumentSegment,
-    DocumentSegmentSummary,
-    SegmentAttachmentBinding,
-)
+from models.dataset import ChildChunk, Dataset, DocumentSegment, SegmentAttachmentBinding
 from models.dataset import Document as DatasetDocument
 from models.model import UploadFile
 from services.external_knowledge_service import ExternalDatasetService
@@ -395,15 +389,15 @@ class RetrievalService:
                .all()
            }

+            records = []
+            include_segment_ids = set()
+            segment_child_map = {}
+
            valid_dataset_documents = {}
            image_doc_ids: list[Any] = []
            child_index_node_ids = []
            index_node_ids = []
            doc_to_document_map = {}
-            summary_segment_ids = set()  # Track segments retrieved via summary
-            summary_score_map: dict[str, float] = {}  # Map original_chunk_id to summary score
-
-            # First pass: collect all document IDs and identify summary documents
            for document in documents:
                document_id = document.metadata.get("document_id")
                if document_id not in dataset_documents:
@@ -414,39 +408,16 @@ class RetrievalService:
                    continue
                valid_dataset_documents[document_id] = dataset_document

-                doc_id = document.metadata.get("doc_id") or ""
-                doc_to_document_map[doc_id] = document
-
-                # Check if this is a summary document
-                is_summary = document.metadata.get("is_summary", False)
-                if is_summary:
-                    # For summary documents, find the original chunk via original_chunk_id
-                    original_chunk_id = document.metadata.get("original_chunk_id")
-                    if original_chunk_id:
-                        summary_segment_ids.add(original_chunk_id)
-                        # Save summary's score for later use
-                        summary_score = document.metadata.get("score")
-                        if summary_score is not None:
-                            try:
-                                summary_score_float = float(summary_score)
-                                # If the same segment has multiple summary hits, take the highest score
-                                if original_chunk_id not in summary_score_map:
-                                    summary_score_map[original_chunk_id] = summary_score_float
-                                else:
-                                    summary_score_map[original_chunk_id] = max(
-                                        summary_score_map[original_chunk_id], summary_score_float
-                                    )
-                            except (ValueError, TypeError):
-                                # Skip invalid score values
-                                pass
-                    continue  # Skip adding to other lists for summary documents
-
                if dataset_document.doc_form == IndexStructureType.PARENT_CHILD_INDEX:
+                    doc_id = document.metadata.get("doc_id") or ""
+                    doc_to_document_map[doc_id] = document
                    if document.metadata.get("doc_type") == DocType.IMAGE:
                        image_doc_ids.append(doc_id)
                    else:
                        child_index_node_ids.append(doc_id)
                else:
+                    doc_id = document.metadata.get("doc_id") or ""
+                    doc_to_document_map[doc_id] = document
                    if document.metadata.get("doc_type") == DocType.IMAGE:
                        image_doc_ids.append(doc_id)
                    else:
@@ -462,7 +433,6 @@ class RetrievalService:
            attachment_map: dict[str, list[dict[str, Any]]] = {}
            child_chunk_map: dict[str, list[ChildChunk]] = {}
            doc_segment_map: dict[str, list[str]] = {}
-            segment_summary_map: dict[str, str] = {}  # Map segment_id to summary content

            with session_factory.create_session() as session:
                attachments = cls.get_segment_attachment_infos(image_doc_ids, session)
@@ -477,7 +447,6 @@ class RetrievalService:
                        doc_segment_map[attachment["segment_id"]].append(attachment["attachment_id"])
                    else:
                        doc_segment_map[attachment["segment_id"]] = [attachment["attachment_id"]]
-
                child_chunk_stmt = select(ChildChunk).where(ChildChunk.index_node_id.in_(child_index_node_ids))
                child_index_nodes = session.execute(child_chunk_stmt).scalars().all()

@@ -501,7 +470,6 @@ class RetrievalService:
                    index_node_segments = session.execute(document_segment_stmt).scalars().all()  # type: ignore
                    for index_node_segment in index_node_segments:
                        doc_segment_map[index_node_segment.id] = [index_node_segment.index_node_id]
-
                if segment_ids:
                    document_segment_stmt = select(DocumentSegment).where(
                        DocumentSegment.enabled == True,
@@ -513,40 +481,6 @@ class RetrievalService:
                if index_node_segments:
                    segments.extend(index_node_segments)

-                # Handle summary documents: query segments by original_chunk_id
-                if summary_segment_ids:
-                    summary_segment_ids_list = list(summary_segment_ids)
-                    summary_segment_stmt = select(DocumentSegment).where(
-                        DocumentSegment.enabled == True,
-                        DocumentSegment.status == "completed",
-                        DocumentSegment.id.in_(summary_segment_ids_list),
-                    )
-                    summary_segments = session.execute(summary_segment_stmt).scalars().all()  # type: ignore
-                    segments.extend(summary_segments)
-                    # Add summary segment IDs to segment_ids for summary query
-                    for seg in summary_segments:
-                        if seg.id not in segment_ids:
-                            segment_ids.append(seg.id)
-
-                # Batch query summaries for segments retrieved via summary (only enabled summaries)
-                if summary_segment_ids:
-                    summaries = (
-                        session.query(DocumentSegmentSummary)
-                        .filter(
-                            DocumentSegmentSummary.chunk_id.in_(list(summary_segment_ids)),
-                            DocumentSegmentSummary.status == "completed",
-                            DocumentSegmentSummary.enabled == True,  # Only retrieve enabled summaries
-                        )
-                        .all()
-                    )
-                    for summary in summaries:
-                        if summary.summary_content:
-                            segment_summary_map[summary.chunk_id] = summary.summary_content
-
-            include_segment_ids = set()
-            segment_child_map: dict[str, dict[str, Any]] = {}
-            records: list[dict[str, Any]] = []
-
            for segment in segments:
                child_chunks: list[ChildChunk] = child_chunk_map.get(segment.id, [])
                attachment_infos: list[dict[str, Any]] = attachment_map.get(segment.id, [])
@@ -555,44 +489,30 @@ class RetrievalService:
                if ds_dataset_document and ds_dataset_document.doc_form == IndexStructureType.PARENT_CHILD_INDEX:
                    if segment.id not in include_segment_ids:
                        include_segment_ids.add(segment.id)
-                        # Check if this segment was retrieved via summary
-                        # Use summary score as base score if available, otherwise 0.0
-                        max_score = summary_score_map.get(segment.id, 0.0)
-
                        if child_chunks or attachment_infos:
                            child_chunk_details = []
+                            max_score = 0.0
                            for child_chunk in child_chunks:
-                                child_document: Document | None = doc_to_document_map.get(child_chunk.index_node_id)
-                                if child_document:
-                                    child_score = child_document.metadata.get("score", 0.0)
-                                else:
-                                    child_score = 0.0
+                                document = doc_to_document_map[child_chunk.index_node_id]
                                child_chunk_detail = {
                                    "id": child_chunk.id,
                                    "content": child_chunk.content,
                                    "position": child_chunk.position,
-                                    "score": child_score,
+                                    "score": document.metadata.get("score", 0.0) if document else 0.0,
                                }
                                child_chunk_details.append(child_chunk_detail)
-                                max_score = max(max_score, child_score)
+                                max_score = max(max_score, document.metadata.get("score", 0.0) if document else 0.0)
                            for attachment_info in attachment_infos:
-                                file_document = doc_to_document_map.get(attachment_info["id"])
-                                if file_document:
-                                    max_score = max(max_score, file_document.metadata.get("score", 0.0))
+                                file_document = doc_to_document_map[attachment_info["id"]]
+                                max_score = max(
+                                    max_score, file_document.metadata.get("score", 0.0) if file_document else 0.0
+                                )

                            map_detail = {
                                "max_score": max_score,
                                "child_chunks": child_chunk_details,
                            }
                            segment_child_map[segment.id] = map_detail
-                        else:
-                            # No child chunks or attachments, use summary score if available
-                            summary_score = summary_score_map.get(segment.id)
-                            if summary_score is not None:
-                                segment_child_map[segment.id] = {
-                                    "max_score": summary_score,
-                                    "child_chunks": [],
-                                }
                        record: dict[str, Any] = {
                            "segment": segment,
                        }
@@ -600,23 +520,14 @@ class RetrievalService:
                else:
                    if segment.id not in include_segment_ids:
                        include_segment_ids.add(segment.id)
-
-                        # Check if this segment was retrieved via summary
-                        # Use summary score if available (summary retrieval takes priority)
-                        max_score = summary_score_map.get(segment.id, 0.0)
-
-                        # If not retrieved via summary, use original segment's score
-                        if segment.id not in summary_score_map:
-                            segment_document = doc_to_document_map.get(segment.index_node_id)
-                            if segment_document:
-                                max_score = max(max_score, segment_document.metadata.get("score", 0.0))
-
-                        # Also consider attachment scores
+                        max_score = 0.0
+                        segment_document = doc_to_document_map.get(segment.index_node_id)
+                        if segment_document:
+                            max_score = max(max_score, segment_document.metadata.get("score", 0.0))
                        for attachment_info in attachment_infos:
                            file_doc = doc_to_document_map.get(attachment_info["id"])
                            if file_doc:
                                max_score = max(max_score, file_doc.metadata.get("score", 0.0))
-
                        record = {
                            "segment": segment,
                            "score": max_score,
@@ -665,16 +576,9 @@ class RetrievalService:
                    else None
                )

-                # Extract summary if this segment was retrieved via summary
-                summary_content = segment_summary_map.get(segment.id)
-
                # Create RetrievalSegments object
                retrieval_segment = RetrievalSegments(
-                    segment=segment,
-                    child_chunks=child_chunks_list,
-                    score=score,
-                    files=files,
-                    summary=summary_content,
+                    segment=segment, child_chunks=child_chunks_list, score=score, files=files
                )
                result.append(retrieval_segment)

@@ -391,78 +391,46 @@ class QdrantVector(BaseVector):
        return docs

    def search_by_full_text(self, query: str, **kwargs: Any) -> list[Document]:
-        """Return docs most similar by full-text search.
-
-        Searches each keyword separately and merges results to ensure documents
-        matching ANY keyword are returned (OR logic). Results are capped at top_k.
-
-        Args:
-            query: Search query text. Multi-word queries are split into keywords,
-                   with each keyword searched separately. Limited to 10 keywords.
-            **kwargs: Additional search parameters (top_k, document_ids_filter)
-
+        """Return docs most similar by bm25.
        Returns:
-            List of up to top_k unique documents matching any query keyword.
+            List of documents most similar to the query text and distance for each.
        """
        from qdrant_client.http import models

-        # Build base must conditions (AND logic) for metadata filters
-        base_must_conditions: list = [
-            models.FieldCondition(
-                key="group_id",
-                match=models.MatchValue(value=self._group_id),
-            ),
-        ]
-
+        scroll_filter = models.Filter(
+            must=[
+                models.FieldCondition(
+                    key="group_id",
+                    match=models.MatchValue(value=self._group_id),
+                ),
+                models.FieldCondition(
+                    key="page_content",
+                    match=models.MatchText(text=query),
+                ),
+            ]
+        )
        document_ids_filter = kwargs.get("document_ids_filter")
        if document_ids_filter:
-            base_must_conditions.append(
-                models.FieldCondition(
-                    key="metadata.document_id",
-                    match=models.MatchAny(any=document_ids_filter),
-                )
-            )
-
-        # Split query into keywords, deduplicate and limit to prevent DoS
-        keywords = list(dict.fromkeys(kw.strip() for kw in query.strip().split() if kw.strip()))[:10]
-
-        if not keywords:
-            return []
-
-        top_k = kwargs.get("top_k", 2)
-        seen_ids: set[str | int] = set()
-        documents: list[Document] = []
-
-        # Search each keyword separately and merge results.
-        # This ensures each keyword gets its own search, preventing one keyword's
-        # results from completely overshadowing another's due to scroll ordering.
-        for keyword in keywords:
-            scroll_filter = models.Filter(
-                must=[
-                    *base_must_conditions,
+            if scroll_filter.must:
+                scroll_filter.must.append(
                    models.FieldCondition(
-                        key="page_content",
-                        match=models.MatchText(text=keyword),
-                    ),
-                ]
-            )
-
-            response = self._client.scroll(
-                collection_name=self._collection_name,
-                scroll_filter=scroll_filter,
-                limit=top_k,
-                with_payload=True,
-                with_vectors=True,
-            )
-            results = response[0]
-
-            for result in results:
-                if result and result.id not in seen_ids:
-                    seen_ids.add(result.id)
-                    document = self._document_from_scored_point(result, Field.CONTENT_KEY, Field.METADATA_KEY)
-                    documents.append(document)
-                    if len(documents) >= top_k:
-                        return documents
+                        key="metadata.document_id",
+                        match=models.MatchAny(any=document_ids_filter),
+                    )
+                )
+        response = self._client.scroll(
+            collection_name=self._collection_name,
+            scroll_filter=scroll_filter,
+            limit=kwargs.get("top_k", 2),
+            with_payload=True,
+            with_vectors=True,
+        )
+        results = response[0]
+        documents = []
+        for result in results:
+            if result:
+                document = self._document_from_scored_point(result, Field.CONTENT_KEY, Field.METADATA_KEY)
+                documents.append(document)

        return documents

@@ -20,4 +20,3 @@ class RetrievalSegments(BaseModel):
    child_chunks: list[RetrievalChildChunk] | None = None
    score: float | None = None
    files: list[dict[str, str | int]] | None = None
-    summary: str | None = None  # Summary content if retrieved via summary index
@@ -22,4 +22,3 @@ class RetrievalSourceMetadata(BaseModel):
    doc_metadata: dict[str, Any] | None = None
    title: str | None = None
    files: list[dict[str, Any]] | None = None
-    summary: str | None = None
@@ -1,7 +1,4 @@
-"""Word (.docx) document extractor used for RAG ingestion.
-
-Supports local file paths and remote URLs (downloaded via `core.helper.ssrf_proxy`).
-"""
+"""Abstract interface for document loader implementations."""

 import logging
 import mimetypes
@@ -11,6 +8,7 @@ import tempfile
 import uuid
 from urllib.parse import urlparse

+import httpx
 from docx import Document as DocxDocument
 from docx.oxml.ns import qn
 from docx.text.run import Run
@@ -46,7 +44,7 @@ class WordExtractor(BaseExtractor):

        # If the file is a web path, download it to a temporary file, and use that
        if not os.path.isfile(self.file_path) and self._is_valid_url(self.file_path):
-            response = ssrf_proxy.get(self.file_path)
+            response = httpx.get(self.file_path, timeout=None)

            if response.status_code != 200:
                response.close()
@@ -57,7 +55,6 @@ class WordExtractor(BaseExtractor):
            self.temp_file = tempfile.NamedTemporaryFile()  # noqa SIM115
            try:
                self.temp_file.write(response.content)
-                self.temp_file.flush()
            finally:
                response.close()
            self.file_path = self.temp_file.name
@@ -13,7 +13,6 @@ from urllib.parse import unquote, urlparse
 import httpx

 from configs import dify_config
-from core.entities.knowledge_entities import PreviewDetail
 from core.helper import ssrf_proxy
 from core.rag.extractor.entity.extract_setting import ExtractSetting
 from core.rag.index_processor.constant.doc_type import DocType
@@ -46,27 +45,6 @@ class BaseIndexProcessor(ABC):
    def transform(self, documents: list[Document], current_user: Account | None = None, **kwargs) -> list[Document]:
        raise NotImplementedError

-    @abstractmethod
-    def generate_summary_preview(
-        self,
-        tenant_id: str,
-        preview_texts: list[PreviewDetail],
-        summary_index_setting: dict,
-        doc_language: str | None = None,
-    ) -> list[PreviewDetail]:
-        """
-        For each segment in preview_texts, generate a summary using LLM and attach it to the segment.
-        The summary can be stored in a new attribute, e.g., summary.
-        This method should be implemented by subclasses.
-
-        Args:
-            tenant_id: Tenant ID
-            preview_texts: List of preview details to generate summaries for
-            summary_index_setting: Summary index configuration
-            doc_language: Optional document language to ensure summary is generated in the correct language
-        """
-        raise NotImplementedError
-
    @abstractmethod
    def load(
        self,
@@ -1,27 +1,9 @@
 """Paragraph index processor."""

-import logging
-import re
 import uuid
 from collections.abc import Mapping
-from typing import Any, cast
+from typing import Any

-logger = logging.getLogger(__name__)
-
-from core.entities.knowledge_entities import PreviewDetail
-from core.file import File, FileTransferMethod, FileType, file_manager
-from core.llm_generator.prompts import DEFAULT_GENERATOR_SUMMARY_PROMPT
-from core.model_manager import ModelInstance
-from core.model_runtime.entities.llm_entities import LLMResult, LLMUsage
-from core.model_runtime.entities.message_entities import (
-    ImagePromptMessageContent,
-    PromptMessage,
-    PromptMessageContentUnionTypes,
-    TextPromptMessageContent,
-    UserPromptMessage,
-)
-from core.model_runtime.entities.model_entities import ModelFeature, ModelType
-from core.provider_manager import ProviderManager
 from core.rag.cleaner.clean_processor import CleanProcessor
 from core.rag.datasource.keyword.keyword_factory import Keyword
 from core.rag.datasource.retrieval_service import RetrievalService
@@ -35,17 +17,12 @@ from core.rag.index_processor.index_processor_base import BaseIndexProcessor
 from core.rag.models.document import AttachmentDocument, Document, MultimodalGeneralStructureChunk
 from core.rag.retrieval.retrieval_methods import RetrievalMethod
 from core.tools.utils.text_processing_utils import remove_leading_symbols
-from core.workflow.nodes.llm import llm_utils
-from extensions.ext_database import db
-from factories.file_factory import build_from_mapping
 from libs import helper
-from models import UploadFile
 from models.account import Account
-from models.dataset import Dataset, DatasetProcessRule, DocumentSegment, SegmentAttachmentBinding
+from models.dataset import Dataset, DatasetProcessRule
 from models.dataset import Document as DatasetDocument
 from services.account_service import AccountService
 from services.entities.knowledge_entities.knowledge_entities import Rule
-from services.summary_index_service import SummaryIndexService


 class ParagraphIndexProcessor(BaseIndexProcessor):
@@ -131,29 +108,6 @@ class ParagraphIndexProcessor(BaseIndexProcessor):
                keyword.add_texts(documents)

    def clean(self, dataset: Dataset, node_ids: list[str] | None, with_keywords: bool = True, **kwargs):
-        # Note: Summary indexes are now disabled (not deleted) when segments are disabled.
-        # This method is called for actual deletion scenarios (e.g., when segment is deleted).
-        # For disable operations, disable_summaries_for_segments is called directly in the task.
-        # Only delete summaries if explicitly requested (e.g., when segment is actually deleted)
-        delete_summaries = kwargs.get("delete_summaries", False)
-        if delete_summaries:
-            if node_ids:
-                # Find segments by index_node_id
-                segments = (
-                    db.session.query(DocumentSegment)
-                    .filter(
-                        DocumentSegment.dataset_id == dataset.id,
-                        DocumentSegment.index_node_id.in_(node_ids),
-                    )
-                    .all()
-                )
-                segment_ids = [segment.id for segment in segments]
-                if segment_ids:
-                    SummaryIndexService.delete_summaries_for_segments(dataset, segment_ids)
-            else:
-                # Delete all summaries for the dataset
-                SummaryIndexService.delete_summaries_for_segments(dataset, None)
-
        if dataset.indexing_technique == "high_quality":
            vector = Vector(dataset)
            if node_ids:
@@ -273,347 +227,3 @@ class ParagraphIndexProcessor(BaseIndexProcessor):
            }
        else:
            raise ValueError("Chunks is not a list")
-
-    def generate_summary_preview(
-        self,
-        tenant_id: str,
-        preview_texts: list[PreviewDetail],
-        summary_index_setting: dict,
-        doc_language: str | None = None,
-    ) -> list[PreviewDetail]:
-        """
-        For each segment, concurrently call generate_summary to generate a summary
-        and write it to the summary attribute of PreviewDetail.
-        In preview mode (indexing-estimate), if any summary generation fails, the method will raise an exception.
-        """
-        import concurrent.futures
-
-        from flask import current_app
-
-        # Capture Flask app context for worker threads
-        flask_app = None
-        try:
-            flask_app = current_app._get_current_object()  # type: ignore
-        except RuntimeError:
-            logger.warning("No Flask application context available, summary generation may fail")
-
-        def process(preview: PreviewDetail) -> None:
-            """Generate summary for a single preview item."""
-            if flask_app:
-                # Ensure Flask app context in worker thread
-                with flask_app.app_context():
-                    summary, _ = self.generate_summary(
-                        tenant_id, preview.content, summary_index_setting, document_language=doc_language
-                    )
-                    preview.summary = summary
-            else:
-                # Fallback: try without app context (may fail)
-                summary, _ = self.generate_summary(
-                    tenant_id, preview.content, summary_index_setting, document_language=doc_language
-                )
-                preview.summary = summary
-
-        # Generate summaries concurrently using ThreadPoolExecutor
-        # Set a reasonable timeout to prevent hanging (60 seconds per chunk, max 5 minutes total)
-        timeout_seconds = min(300, 60 * len(preview_texts))
-        errors: list[Exception] = []
-
-        with concurrent.futures.ThreadPoolExecutor(max_workers=min(10, len(preview_texts))) as executor:
-            futures = [executor.submit(process, preview) for preview in preview_texts]
-            # Wait for all tasks to complete with timeout
-            done, not_done = concurrent.futures.wait(futures, timeout=timeout_seconds)
-
-            # Cancel tasks that didn't complete in time
-            if not_done:
-                timeout_error_msg = (
-                    f"Summary generation timeout: {len(not_done)} chunks did not complete within {timeout_seconds}s"
-                )
-                logger.warning("%s. Cancelling remaining tasks...", timeout_error_msg)
-                # In preview mode, timeout is also an error
-                errors.append(TimeoutError(timeout_error_msg))
-                for future in not_done:
-                    future.cancel()
-                # Wait a bit for cancellation to take effect
-                concurrent.futures.wait(not_done, timeout=5)
-
-            # Collect exceptions from completed futures
-            for future in done:
-                try:
-                    future.result()  # This will raise any exception that occurred
-                except Exception as e:
-                    logger.exception("Error in summary generation future")
-                    errors.append(e)
-
-        # In preview mode (indexing-estimate), if there are any errors, fail the request
-        if errors:
-            error_messages = [str(e) for e in errors]
-            error_summary = (
-                f"Failed to generate summaries for {len(errors)} chunk(s). "
-                f"Errors: {'; '.join(error_messages[:3])}"  # Show first 3 errors
-            )
-            if len(errors) > 3:
-                error_summary += f" (and {len(errors) - 3} more)"
-            logger.error("Summary generation failed in preview mode: %s", error_summary)
-            raise ValueError(error_summary)
-
-        return preview_texts
-
-    @staticmethod
-    def generate_summary(
-        tenant_id: str,
-        text: str,
-        summary_index_setting: dict | None = None,
-        segment_id: str | None = None,
-        document_language: str | None = None,
-    ) -> tuple[str, LLMUsage]:
-        """
-        Generate summary for the given text using ModelInstance.invoke_llm and the default or custom summary prompt,
-        and supports vision models by including images from the segment attachments or text content.
-
-        Args:
-            tenant_id: Tenant ID
-            text: Text content to summarize
-            summary_index_setting: Summary index configuration
-            segment_id: Optional segment ID to fetch attachments from SegmentAttachmentBinding table
-            document_language: Optional document language (e.g., "Chinese", "English")
-                to ensure summary is generated in the correct language
-
-        Returns:
-            Tuple of (summary_content, llm_usage) where llm_usage is LLMUsage object
-        """
-        if not summary_index_setting or not summary_index_setting.get("enable"):
-            raise ValueError("summary_index_setting is required and must be enabled to generate summary.")
-
-        model_name = summary_index_setting.get("model_name")
-        model_provider_name = summary_index_setting.get("model_provider_name")
-        summary_prompt = summary_index_setting.get("summary_prompt")
-
-        if not model_name or not model_provider_name:
-            raise ValueError("model_name and model_provider_name are required in summary_index_setting")
-
-        # Import default summary prompt
-        is_default_prompt = False
-        if not summary_prompt:
-            summary_prompt = DEFAULT_GENERATOR_SUMMARY_PROMPT
-            is_default_prompt = True
-
-        # Format prompt with document language only for default prompt
-        # Custom prompts are used as-is to avoid interfering with user-defined templates
-        # If document_language is provided, use it; otherwise, use "the same language as the input content"
-        # This is especially important for image-only chunks where text is empty or minimal
-        if is_default_prompt:
-            language_for_prompt = document_language or "the same language as the input content"
-            try:
-                summary_prompt = summary_prompt.format(language=language_for_prompt)
-            except KeyError:
-                # If default prompt doesn't have {language} placeholder, use it as-is
-                pass
-
-        provider_manager = ProviderManager()
-        provider_model_bundle = provider_manager.get_provider_model_bundle(
-            tenant_id, model_provider_name, ModelType.LLM
-        )
-        model_instance = ModelInstance(provider_model_bundle, model_name)
-
-        # Get model schema to check if vision is supported
-        model_schema = model_instance.model_type_instance.get_model_schema(model_name, model_instance.credentials)
-        supports_vision = model_schema and model_schema.features and ModelFeature.VISION in model_schema.features
-
-        # Extract images if model supports vision
-        image_files = []
-        if supports_vision:
-            # First, try to get images from SegmentAttachmentBinding (preferred method)
-            if segment_id:
-                image_files = ParagraphIndexProcessor._extract_images_from_segment_attachments(tenant_id, segment_id)
-
-            # If no images from attachments, fall back to extracting from text
-            if not image_files:
-                image_files = ParagraphIndexProcessor._extract_images_from_text(tenant_id, text)
-
-        # Build prompt messages
-        prompt_messages = []
-
-        if image_files:
-            # If we have images, create a UserPromptMessage with both text and images
-            prompt_message_contents: list[PromptMessageContentUnionTypes] = []
-
-            # Add images first
-            for file in image_files:
-                try:
-                    file_content = file_manager.to_prompt_message_content(
-                        file, image_detail_config=ImagePromptMessageContent.DETAIL.LOW
-                    )
-                    prompt_message_contents.append(file_content)
-                except Exception as e:
-                    logger.warning("Failed to convert image file to prompt message content: %s", str(e))
-                    continue
-
-            # Add text content
-            if prompt_message_contents:  # Only add text if we successfully added images
-                prompt_message_contents.append(TextPromptMessageContent(data=f"{summary_prompt}\n{text}"))
-                prompt_messages.append(UserPromptMessage(content=prompt_message_contents))
-            else:
-                # If image conversion failed, fall back to text-only
-                prompt = f"{summary_prompt}\n{text}"
-                prompt_messages.append(UserPromptMessage(content=prompt))
-        else:
-            # No images, use simple text prompt
-            prompt = f"{summary_prompt}\n{text}"
-            prompt_messages.append(UserPromptMessage(content=prompt))
-
-        result = model_instance.invoke_llm(
-            prompt_messages=cast(list[PromptMessage], prompt_messages), model_parameters={}, stream=False
-        )
-
-        # Type assertion: when stream=False, invoke_llm returns LLMResult, not Generator
-        if not isinstance(result, LLMResult):
-            raise ValueError("Expected LLMResult when stream=False")
-
-        summary_content = getattr(result.message, "content", "")
-        usage = result.usage
-
-        # Deduct quota for summary generation (same as workflow nodes)
-        try:
-            llm_utils.deduct_llm_quota(tenant_id=tenant_id, model_instance=model_instance, usage=usage)
-        except Exception as e:
-            # Log but don't fail summary generation if quota deduction fails
-            logger.warning("Failed to deduct quota for summary generation: %s", str(e))
-
-        return summary_content, usage
-
-    @staticmethod
-    def _extract_images_from_text(tenant_id: str, text: str) -> list[File]:
-        """
-        Extract images from markdown text and convert them to File objects.
-
-        Args:
-            tenant_id: Tenant ID
-            text: Text content that may contain markdown image links
-
-        Returns:
-            List of File objects representing images found in the text
-        """
-        # Extract markdown images using regex pattern
-        pattern = r"!\[.*?\]\((.*?)\)"
-        images = re.findall(pattern, text)
-
-        if not images:
-            return []
-
-        upload_file_id_list = []
-
-        for image in images:
-            # For data before v0.10.0
-            pattern = r"/files/([a-f0-9\-]+)/image-preview(?:\?.*?)?"
-            match = re.search(pattern, image)
-            if match:
-                upload_file_id = match.group(1)
-                upload_file_id_list.append(upload_file_id)
-                continue
-
-            # For data after v0.10.0
-            pattern = r"/files/([a-f0-9\-]+)/file-preview(?:\?.*?)?"
-            match = re.search(pattern, image)
-            if match:
-                upload_file_id = match.group(1)
-                upload_file_id_list.append(upload_file_id)
-                continue
-
-            # For tools directory - direct file formats (e.g., .png, .jpg, etc.)
-            pattern = r"/files/tools/([a-f0-9\-]+)\.([a-zA-Z0-9]+)(?:\?[^\s\)\"\']*)?"
-            match = re.search(pattern, image)
-            if match:
-                # Tool files are handled differently, skip for now
-                continue
-
-        if not upload_file_id_list:
-            return []
-
-        # Get unique IDs for database query
-        unique_upload_file_ids = list(set(upload_file_id_list))
-        upload_files = (
-            db.session.query(UploadFile)
-            .where(UploadFile.id.in_(unique_upload_file_ids), UploadFile.tenant_id == tenant_id)
-            .all()
-        )
-
-        # Create File objects from UploadFile records
-        file_objects = []
-        for upload_file in upload_files:
-            # Only process image files
-            if not upload_file.mime_type or "image" not in upload_file.mime_type:
-                continue
-
-            mapping = {
-                "upload_file_id": upload_file.id,
-                "transfer_method": FileTransferMethod.LOCAL_FILE.value,
-                "type": FileType.IMAGE.value,
-            }
-
-            try:
-                file_obj = build_from_mapping(
-                    mapping=mapping,
-                    tenant_id=tenant_id,
-                )
-                file_objects.append(file_obj)
-            except Exception as e:
-                logger.warning("Failed to create File object from UploadFile %s: %s", upload_file.id, str(e))
-                continue
-
-        return file_objects
-
-    @staticmethod
-    def _extract_images_from_segment_attachments(tenant_id: str, segment_id: str) -> list[File]:
-        """
-        Extract images from SegmentAttachmentBinding table (preferred method).
-        This matches how DatasetRetrieval gets segment attachments.
-
-        Args:
-            tenant_id: Tenant ID
-            segment_id: Segment ID to fetch attachments for
-
-        Returns:
-            List of File objects representing images found in segment attachments
-        """
-        from sqlalchemy import select
-
-        # Query attachments from SegmentAttachmentBinding table
-        attachments_with_bindings = db.session.execute(
-            select(SegmentAttachmentBinding, UploadFile)
-            .join(UploadFile, UploadFile.id == SegmentAttachmentBinding.attachment_id)
-            .where(
-                SegmentAttachmentBinding.segment_id == segment_id,
-                SegmentAttachmentBinding.tenant_id == tenant_id,
-            )
-        ).all()
-
-        if not attachments_with_bindings:
-            return []
-
-        file_objects = []
-        for _, upload_file in attachments_with_bindings:
-            # Only process image files
-            if not upload_file.mime_type or "image" not in upload_file.mime_type:
-                continue
-
-            try:
-                # Create File object directly (similar to DatasetRetrieval)
-                file_obj = File(
-                    id=upload_file.id,
-                    filename=upload_file.name,
-                    extension="." + upload_file.extension,
-                    mime_type=upload_file.mime_type,
-                    tenant_id=tenant_id,
-                    type=FileType.IMAGE,
-                    transfer_method=FileTransferMethod.LOCAL_FILE,
-                    remote_url=upload_file.source_url,
-                    related_id=upload_file.id,
-                    size=upload_file.size,
-                    storage_key=upload_file.key,
-                )
-                file_objects.append(file_obj)
-            except Exception as e:
-                logger.warning("Failed to create File object from UploadFile %s: %s", upload_file.id, str(e))
-                continue
-
-        return file_objects
@@ -1,14 +1,11 @@
 """Paragraph index processor."""

 import json
-import logging
 import uuid
 from collections.abc import Mapping
 from typing import Any

 from configs import dify_config
-from core.db.session_factory import session_factory
-from core.entities.knowledge_entities import PreviewDetail
 from core.model_manager import ModelInstance
 from core.rag.cleaner.clean_processor import CleanProcessor
 from core.rag.datasource.retrieval_service import RetrievalService
@@ -28,9 +25,6 @@ from models.dataset import ChildChunk, Dataset, DatasetProcessRule, DocumentSegm
 from models.dataset import Document as DatasetDocument
 from services.account_service import AccountService
 from services.entities.knowledge_entities.knowledge_entities import ParentMode, Rule
-from services.summary_index_service import SummaryIndexService
-
-logger = logging.getLogger(__name__)


 class ParentChildIndexProcessor(BaseIndexProcessor):
@@ -141,30 +135,6 @@ class ParentChildIndexProcessor(BaseIndexProcessor):

    def clean(self, dataset: Dataset, node_ids: list[str] | None, with_keywords: bool = True, **kwargs):
        # node_ids is segment's node_ids
-        # Note: Summary indexes are now disabled (not deleted) when segments are disabled.
-        # This method is called for actual deletion scenarios (e.g., when segment is deleted).
-        # For disable operations, disable_summaries_for_segments is called directly in the task.
-        # Only delete summaries if explicitly requested (e.g., when segment is actually deleted)
-        delete_summaries = kwargs.get("delete_summaries", False)
-        if delete_summaries:
-            if node_ids:
-                # Find segments by index_node_id
-                with session_factory.create_session() as session:
-                    segments = (
-                        session.query(DocumentSegment)
-                        .filter(
-                            DocumentSegment.dataset_id == dataset.id,
-                            DocumentSegment.index_node_id.in_(node_ids),
-                        )
-                        .all()
-                    )
-                    segment_ids = [segment.id for segment in segments]
-                    if segment_ids:
-                        SummaryIndexService.delete_summaries_for_segments(dataset, segment_ids)
-            else:
-                # Delete all summaries for the dataset
-                SummaryIndexService.delete_summaries_for_segments(dataset, None)
-
        if dataset.indexing_technique == "high_quality":
            delete_child_chunks = kwargs.get("delete_child_chunks") or False
            precomputed_child_node_ids = kwargs.get("precomputed_child_node_ids")
@@ -356,97 +326,3 @@ class ParentChildIndexProcessor(BaseIndexProcessor):
            "preview": preview,
            "total_segments": len(parent_childs.parent_child_chunks),
        }
-
-    def generate_summary_preview(
-        self,
-        tenant_id: str,
-        preview_texts: list[PreviewDetail],
-        summary_index_setting: dict,
-        doc_language: str | None = None,
-    ) -> list[PreviewDetail]:
-        """
-        For each parent chunk in preview_texts, concurrently call generate_summary to generate a summary
-        and write it to the summary attribute of PreviewDetail.
-        In preview mode (indexing-estimate), if any summary generation fails, the method will raise an exception.
-
-        Note: For parent-child structure, we only generate summaries for parent chunks.
-        """
-        import concurrent.futures
-
-        from flask import current_app
-
-        # Capture Flask app context for worker threads
-        flask_app = None
-        try:
-            flask_app = current_app._get_current_object()  # type: ignore
-        except RuntimeError:
-            logger.warning("No Flask application context available, summary generation may fail")
-
-        def process(preview: PreviewDetail) -> None:
-            """Generate summary for a single preview item (parent chunk)."""
-            from core.rag.index_processor.processor.paragraph_index_processor import ParagraphIndexProcessor
-
-            if flask_app:
-                # Ensure Flask app context in worker thread
-                with flask_app.app_context():
-                    summary, _ = ParagraphIndexProcessor.generate_summary(
-                        tenant_id=tenant_id,
-                        text=preview.content,
-                        summary_index_setting=summary_index_setting,
-                        document_language=doc_language,
-                    )
-                    preview.summary = summary
-            else:
-                # Fallback: try without app context (may fail)
-                summary, _ = ParagraphIndexProcessor.generate_summary(
-                    tenant_id=tenant_id,
-                    text=preview.content,
-                    summary_index_setting=summary_index_setting,
-                    document_language=doc_language,
-                )
-                preview.summary = summary
-
-        # Generate summaries concurrently using ThreadPoolExecutor
-        # Set a reasonable timeout to prevent hanging (60 seconds per chunk, max 5 minutes total)
-        timeout_seconds = min(300, 60 * len(preview_texts))
-        errors: list[Exception] = []
-
-        with concurrent.futures.ThreadPoolExecutor(max_workers=min(10, len(preview_texts))) as executor:
-            futures = [executor.submit(process, preview) for preview in preview_texts]
-            # Wait for all tasks to complete with timeout
-            done, not_done = concurrent.futures.wait(futures, timeout=timeout_seconds)
-
-            # Cancel tasks that didn't complete in time
-            if not_done:
-                timeout_error_msg = (
-                    f"Summary generation timeout: {len(not_done)} chunks did not complete within {timeout_seconds}s"
-                )
-                logger.warning("%s. Cancelling remaining tasks...", timeout_error_msg)
-                # In preview mode, timeout is also an error
-                errors.append(TimeoutError(timeout_error_msg))
-                for future in not_done:
-                    future.cancel()
-                # Wait a bit for cancellation to take effect
-                concurrent.futures.wait(not_done, timeout=5)
-
-            # Collect exceptions from completed futures
-            for future in done:
-                try:
-                    future.result()  # This will raise any exception that occurred
-                except Exception as e:
-                    logger.exception("Error in summary generation future")
-                    errors.append(e)
-
-        # In preview mode (indexing-estimate), if there are any errors, fail the request
-        if errors:
-            error_messages = [str(e) for e in errors]
-            error_summary = (
-                f"Failed to generate summaries for {len(errors)} chunk(s). "
-                f"Errors: {'; '.join(error_messages[:3])}"  # Show first 3 errors
-            )
-            if len(errors) > 3:
-                error_summary += f" (and {len(errors) - 3} more)"
-            logger.error("Summary generation failed in preview mode: %s", error_summary)
-            raise ValueError(error_summary)
-
-        return preview_texts
@@ -11,8 +11,6 @@ import pandas as pd
 from flask import Flask, current_app
 from werkzeug.datastructures import FileStorage

-from core.db.session_factory import session_factory
-from core.entities.knowledge_entities import PreviewDetail
 from core.llm_generator.llm_generator import LLMGenerator
 from core.rag.cleaner.clean_processor import CleanProcessor
 from core.rag.datasource.retrieval_service import RetrievalService
@@ -27,10 +25,9 @@ from core.rag.retrieval.retrieval_methods import RetrievalMethod
 from core.tools.utils.text_processing_utils import remove_leading_symbols
 from libs import helper
 from models.account import Account
-from models.dataset import Dataset, DocumentSegment
+from models.dataset import Dataset
 from models.dataset import Document as DatasetDocument
 from services.entities.knowledge_entities.knowledge_entities import Rule
-from services.summary_index_service import SummaryIndexService

 logger = logging.getLogger(__name__)

@@ -147,31 +144,6 @@ class QAIndexProcessor(BaseIndexProcessor):
                vector.create_multimodal(multimodal_documents)

    def clean(self, dataset: Dataset, node_ids: list[str] | None, with_keywords: bool = True, **kwargs):
-        # Note: Summary indexes are now disabled (not deleted) when segments are disabled.
-        # This method is called for actual deletion scenarios (e.g., when segment is deleted).
-        # For disable operations, disable_summaries_for_segments is called directly in the task.
-        # Note: qa_model doesn't generate summaries, but we clean them for completeness
-        # Only delete summaries if explicitly requested (e.g., when segment is actually deleted)
-        delete_summaries = kwargs.get("delete_summaries", False)
-        if delete_summaries:
-            if node_ids:
-                # Find segments by index_node_id
-                with session_factory.create_session() as session:
-                    segments = (
-                        session.query(DocumentSegment)
-                        .filter(
-                            DocumentSegment.dataset_id == dataset.id,
-                            DocumentSegment.index_node_id.in_(node_ids),
-                        )
-                        .all()
-                    )
-                    segment_ids = [segment.id for segment in segments]
-                    if segment_ids:
-                        SummaryIndexService.delete_summaries_for_segments(dataset, segment_ids)
-            else:
-                # Delete all summaries for the dataset
-                SummaryIndexService.delete_summaries_for_segments(dataset, None)
-
        vector = Vector(dataset)
        if node_ids:
            vector.delete_by_ids(node_ids)
@@ -240,21 +212,6 @@ class QAIndexProcessor(BaseIndexProcessor):
            "total_segments": len(qa_chunks.qa_chunks),
        }

-    def generate_summary_preview(
-        self,
-        tenant_id: str,
-        preview_texts: list[PreviewDetail],
-        summary_index_setting: dict,
-        doc_language: str | None = None,
-    ) -> list[PreviewDetail]:
-        """
-        QA model doesn't generate summaries, so this method returns preview_texts unchanged.
-
-        Note: QA model uses question-answer pairs, which don't require summary generation.
-        """
-        # QA model doesn't generate summaries, return as-is
-        return preview_texts
-
    def _format_qa_document(self, flask_app: Flask, tenant_id: str, document_node, all_qa_documents, document_language):
        format_documents = []
        if document_node.page_content is None or not document_node.page_content.strip():
@@ -27,7 +27,8 @@ from core.model_runtime.entities.llm_entities import LLMResult, LLMUsage
 from core.model_runtime.entities.message_entities import PromptMessage, PromptMessageRole, PromptMessageTool
 from core.model_runtime.entities.model_entities import ModelFeature, ModelType
 from core.model_runtime.model_providers.__base.large_language_model import LargeLanguageModel
-from core.ops.ops_trace_manager import TraceQueueManager
+from core.ops.entities.trace_entity import TraceTaskName
+from core.ops.ops_trace_manager import TraceQueueManager, TraceTask
 from core.ops.utils import measure_time
 from core.prompt.advanced_prompt_transform import AdvancedPromptTransform
 from core.prompt.entities.advanced_prompt_entities import ChatModelMessage, CompletionModelPromptTemplate
@@ -55,8 +56,6 @@ from core.rag.retrieval.template_prompts import (
    METADATA_FILTER_USER_PROMPT_2,
    METADATA_FILTER_USER_PROMPT_3,
 )
-from core.telemetry import TelemetryContext, TelemetryEvent, TraceTaskName
-from core.telemetry import emit as telemetry_emit
 from core.tools.signature import sign_upload_file
 from core.tools.utils.dataset_retriever.dataset_retriever_base_tool import DatasetRetrieverBaseTool
 from extensions.ext_database import db
@@ -237,24 +236,20 @@ class DatasetRetrieval:
            if records:
                for record in records:
                    segment = record.segment
-                    # Build content: if summary exists, add it before the segment content
                    if segment.answer:
-                        segment_content = f"question:{segment.get_sign_content()} answer:{segment.answer}"
+                        document_context_list.append(
+                            DocumentContext(
+                                content=f"question:{segment.get_sign_content()} answer:{segment.answer}",
+                                score=record.score,
+                            )
+                        )
                    else:
-                        segment_content = segment.get_sign_content()
-
-                    # If summary exists, prepend it to the content
-                    if record.summary:
-                        final_content = f"{record.summary}\n{segment_content}"
-                    else:
-                        final_content = segment_content
-
-                    document_context_list.append(
-                        DocumentContext(
-                            content=final_content,
-                            score=record.score,
+                        document_context_list.append(
+                            DocumentContext(
+                                content=segment.get_sign_content(),
+                                score=record.score,
+                            )
                        )
-                    )
                    if vision_enabled:
                        attachments_with_bindings = db.session.execute(
                            select(SegmentAttachmentBinding, UploadFile)
@@ -321,9 +316,6 @@ class DatasetRetrieval:
                                source.content = f"question:{segment.content} \nanswer:{segment.answer}"
                            else:
                                source.content = segment.content
-                            # Add summary if this segment was retrieved via summary
-                            if hasattr(record, "summary") and record.summary:
-                                source.summary = record.summary
                            retrieval_resource_list.append(source)
        if hit_callback and retrieval_resource_list:
            retrieval_resource_list = sorted(retrieval_resource_list, key=lambda x: x.score or 0.0, reverse=True)
@@ -729,21 +721,10 @@ class DatasetRetrieval:
            self.application_generate_entity.trace_manager if self.application_generate_entity else None
        )
        if trace_manager:
-            app_config = self.application_generate_entity.app_config if self.application_generate_entity else None
-            telemetry_emit(
-                TelemetryEvent(
-                    name=TraceTaskName.DATASET_RETRIEVAL_TRACE,
-                    context=TelemetryContext(
-                        tenant_id=app_config.tenant_id if app_config else None,
-                        app_id=app_config.app_id if app_config else None,
-                    ),
-                    payload={
-                        "message_id": message_id,
-                        "documents": documents,
-                        "timer": timer,
-                    },
-                ),
-                trace_manager=trace_manager,
+            trace_manager.add_trace_task(
+                TraceTask(
+                    TraceTaskName.DATASET_RETRIEVAL_TRACE, message_id=message_id, documents=documents, timer=timer
+                )
            )

    def _on_query(
@@ -35,7 +35,6 @@ class SchemaRegistry:
                    registry.load_all_versions()

                    cls._default_instance = registry
-            return cls._default_instance

        return cls._default_instance

@@ -1,43 +0,0 @@
-"""Telemetry facade.
-
-Thin public API for emitting telemetry events.  All routing logic
-lives in ``core.telemetry.gateway`` which is shared by both CE and EE.
-"""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from core.ops.entities.trace_entity import TraceTaskName
-from core.telemetry.events import TelemetryContext, TelemetryEvent
-from core.telemetry.gateway import emit as gateway_emit
-from core.telemetry.gateway import get_trace_task_to_case
-
-if TYPE_CHECKING:
-    from core.ops.ops_trace_manager import TraceQueueManager
-
-
-def emit(event: TelemetryEvent, trace_manager: TraceQueueManager | None = None) -> None:
-    """Emit a telemetry event.
-
-    Translates the ``TelemetryEvent`` (keyed by ``TraceTaskName``) into a
-    ``TelemetryCase`` and delegates to ``core.telemetry.gateway.emit()``.
-    """
-    case = get_trace_task_to_case().get(event.name)
-    if case is None:
-        return
-
-    context: dict[str, object] = {
-        "tenant_id": event.context.tenant_id,
-        "user_id": event.context.user_id,
-        "app_id": event.context.app_id,
-    }
-    gateway_emit(case, context, event.payload, trace_manager)
-
-
-__all__ = [
-    "TelemetryContext",
-    "TelemetryEvent",
-    "TraceTaskName",
-    "emit",
-]
@@ -1,21 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any
-
-if TYPE_CHECKING:
-    from core.ops.entities.trace_entity import TraceTaskName
-
-
-@dataclass(frozen=True)
-class TelemetryContext:
-    tenant_id: str | None = None
-    user_id: str | None = None
-    app_id: str | None = None
-
-
-@dataclass(frozen=True)
-class TelemetryEvent:
-    name: TraceTaskName
-    context: TelemetryContext
-    payload: dict[str, Any]
@@ -1,233 +0,0 @@
-"""Telemetry gateway — single routing layer for all editions.
-
-Maps ``TelemetryCase`` → ``CaseRoute`` and dispatches events to either
-the CE/EE trace pipeline (``TraceQueueManager``) or the enterprise-only
-metric/log Celery queue.
-
-This module lives in ``core/`` so both CE and EE share one routing table
-and one ``emit()`` entry point.  No separate enterprise gateway module is
-needed — enterprise-specific dispatch (Celery task, payload offloading)
-is handled here behind lazy imports that no-op in CE.
-"""
-
-from __future__ import annotations
-
-import json
-import logging
-import uuid
-from typing import TYPE_CHECKING, Any
-
-from core.ops.entities.trace_entity import TraceTaskName
-from extensions.ext_storage import storage
-
-if TYPE_CHECKING:
-    from core.ops.ops_trace_manager import TraceQueueManager
-    from enterprise.telemetry.contracts import TelemetryCase
-
-logger = logging.getLogger(__name__)
-
-PAYLOAD_SIZE_THRESHOLD_BYTES = 1 * 1024 * 1024
-
-# ---------------------------------------------------------------------------
-# Routing table — authoritative mapping for all editions
-# ---------------------------------------------------------------------------
-
-_case_to_trace_task: dict | None = None
-_case_routing: dict | None = None
-
-
-def _get_case_to_trace_task() -> dict:
-    global _case_to_trace_task
-    if _case_to_trace_task is None:
-        from enterprise.telemetry.contracts import TelemetryCase
-
-        _case_to_trace_task = {
-            TelemetryCase.WORKFLOW_RUN: TraceTaskName.WORKFLOW_TRACE,
-            TelemetryCase.MESSAGE_RUN: TraceTaskName.MESSAGE_TRACE,
-            TelemetryCase.NODE_EXECUTION: TraceTaskName.NODE_EXECUTION_TRACE,
-            TelemetryCase.DRAFT_NODE_EXECUTION: TraceTaskName.DRAFT_NODE_EXECUTION_TRACE,
-            TelemetryCase.PROMPT_GENERATION: TraceTaskName.PROMPT_GENERATION_TRACE,
-            TelemetryCase.TOOL_EXECUTION: TraceTaskName.TOOL_TRACE,
-            TelemetryCase.MODERATION_CHECK: TraceTaskName.MODERATION_TRACE,
-            TelemetryCase.SUGGESTED_QUESTION: TraceTaskName.SUGGESTED_QUESTION_TRACE,
-            TelemetryCase.DATASET_RETRIEVAL: TraceTaskName.DATASET_RETRIEVAL_TRACE,
-            TelemetryCase.GENERATE_NAME: TraceTaskName.GENERATE_NAME_TRACE,
-        }
-    return _case_to_trace_task
-
-
-def get_trace_task_to_case() -> dict:
-    """Return TraceTaskName → TelemetryCase (inverse of _get_case_to_trace_task)."""
-    return {v: k for k, v in _get_case_to_trace_task().items()}
-
-
-def _get_case_routing() -> dict:
-    global _case_routing
-    if _case_routing is None:
-        from enterprise.telemetry.contracts import CaseRoute, SignalType, TelemetryCase
-
-        _case_routing = {
-            # TRACE — CE-eligible (flow in both CE and EE)
-            TelemetryCase.WORKFLOW_RUN: CaseRoute(signal_type=SignalType.TRACE, ce_eligible=True),
-            TelemetryCase.MESSAGE_RUN: CaseRoute(signal_type=SignalType.TRACE, ce_eligible=True),
-            TelemetryCase.TOOL_EXECUTION: CaseRoute(signal_type=SignalType.TRACE, ce_eligible=True),
-            TelemetryCase.MODERATION_CHECK: CaseRoute(signal_type=SignalType.TRACE, ce_eligible=True),
-            TelemetryCase.SUGGESTED_QUESTION: CaseRoute(signal_type=SignalType.TRACE, ce_eligible=True),
-            TelemetryCase.DATASET_RETRIEVAL: CaseRoute(signal_type=SignalType.TRACE, ce_eligible=True),
-            TelemetryCase.GENERATE_NAME: CaseRoute(signal_type=SignalType.TRACE, ce_eligible=True),
-            # TRACE — enterprise-only
-            TelemetryCase.NODE_EXECUTION: CaseRoute(signal_type=SignalType.TRACE, ce_eligible=False),
-            TelemetryCase.DRAFT_NODE_EXECUTION: CaseRoute(signal_type=SignalType.TRACE, ce_eligible=False),
-            TelemetryCase.PROMPT_GENERATION: CaseRoute(signal_type=SignalType.TRACE, ce_eligible=False),
-            # METRIC_LOG — enterprise-only (signal-driven, not trace)
-            TelemetryCase.APP_CREATED: CaseRoute(signal_type=SignalType.METRIC_LOG, ce_eligible=False),
-            TelemetryCase.APP_UPDATED: CaseRoute(signal_type=SignalType.METRIC_LOG, ce_eligible=False),
-            TelemetryCase.APP_DELETED: CaseRoute(signal_type=SignalType.METRIC_LOG, ce_eligible=False),
-            TelemetryCase.FEEDBACK_CREATED: CaseRoute(signal_type=SignalType.METRIC_LOG, ce_eligible=False),
-        }
-    return _case_routing
-
-# Public exports for tests and external consumers
-CASE_TO_TRACE_TASK = _get_case_to_trace_task()
-CASE_ROUTING = _get_case_routing()
-
-
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-
-
-def is_enterprise_telemetry_enabled() -> bool:
-    try:
-        from enterprise.telemetry.exporter import is_enterprise_telemetry_enabled
-
-        return is_enterprise_telemetry_enabled()
-    except Exception:
-        return False
-
-
-def _handle_payload_sizing(
-    payload: dict[str, Any],
-    tenant_id: str,
-    event_id: str,
-) -> tuple[dict[str, Any], str | None]:
-    """Inline or offload payload based on size.
-
-    Returns ``(payload_for_envelope, storage_key | None)``.  Payloads
-    exceeding ``PAYLOAD_SIZE_THRESHOLD_BYTES`` are written to object
-    storage and replaced with an empty dict in the envelope.
-    """
-    try:
-        payload_json = json.dumps(payload)
-        payload_size = len(payload_json.encode("utf-8"))
-    except (TypeError, ValueError):
-        logger.warning("Failed to serialize payload for sizing: event_id=%s", event_id)
-        return payload, None
-
-    if payload_size <= PAYLOAD_SIZE_THRESHOLD_BYTES:
-        return payload, None
-
-    storage_key = f"telemetry/{tenant_id}/{event_id}.json"
-    try:
-        storage.save(storage_key, payload_json.encode("utf-8"))
-        logger.debug("Stored large payload to storage: key=%s, size=%d", storage_key, payload_size)
-        return {}, storage_key
-    except Exception:
-        logger.warning("Failed to store large payload, inlining instead: event_id=%s", event_id, exc_info=True)
-        return payload, None
-
-
-# ---------------------------------------------------------------------------
-# Public API
-# ---------------------------------------------------------------------------
-
-
-def emit(
-    case: TelemetryCase,
-    context: dict[str, Any],
-    payload: dict[str, Any],
-    trace_manager: TraceQueueManager | None = None,
-) -> None:
-    """Route a telemetry event to the correct pipeline.
-
-    TRACE events are enqueued into ``TraceQueueManager`` (works in both CE
-    and EE).  Enterprise-only traces are silently dropped when EE is
-    disabled.
-
-    METRIC_LOG events are dispatched to the enterprise Celery queue;
-    silently dropped when enterprise telemetry is unavailable.
-    """
-    route = _get_case_routing().get(case)
-    if route is None:
-        logger.warning("Unknown telemetry case: %s, dropping event", case)
-        return
-
-    if not route.ce_eligible and not is_enterprise_telemetry_enabled():
-        logger.debug("Dropping EE-only event: case=%s (EE disabled)", case)
-        return
-
-    if route.signal_type == "trace":
-        _emit_trace(case, context, payload, trace_manager)
-    else:
-        _emit_metric_log(case, context, payload)
-
-
-def _emit_trace(
-    case: TelemetryCase,
-    context: dict[str, Any],
-    payload: dict[str, Any],
-    trace_manager: TraceQueueManager | None,
-) -> None:
-    from core.ops.ops_trace_manager import TraceQueueManager as LocalTraceQueueManager
-    from core.ops.ops_trace_manager import TraceTask
-
-    trace_task_name = _get_case_to_trace_task().get(case)
-    if trace_task_name is None:
-        logger.warning("No TraceTaskName mapping for case: %s", case)
-        return
-
-    queue_manager = trace_manager or LocalTraceQueueManager(
-        app_id=context.get("app_id"),
-        user_id=context.get("user_id"),
-    )
-    queue_manager.add_trace_task(TraceTask(trace_task_name, **payload))
-    logger.debug("Enqueued trace task: case=%s, app_id=%s", case, context.get("app_id"))
-
-
-def _emit_metric_log(
-    case: TelemetryCase,
-    context: dict[str, Any],
-    payload: dict[str, Any],
-) -> None:
-    """Build envelope and dispatch to enterprise Celery queue.
-
-    No-ops when the enterprise telemetry task is not importable (CE mode).
-    """
-    try:
-        from tasks.enterprise_telemetry_task import process_enterprise_telemetry
-    except ImportError:
-        logger.debug("Enterprise metric/log dispatch unavailable, dropping: case=%s", case)
-        return
-
-    tenant_id = context.get("tenant_id", "")
-    event_id = str(uuid.uuid4())
-
-    payload_for_envelope, payload_ref = _handle_payload_sizing(payload, tenant_id, event_id)
-
-    from enterprise.telemetry.contracts import TelemetryEnvelope
-
-    envelope = TelemetryEnvelope(
-        case=case,
-        tenant_id=tenant_id,
-        event_id=event_id,
-        payload=payload_for_envelope,
-        metadata={"payload_ref": payload_ref} if payload_ref else None,
-    )
-
-    process_enterprise_telemetry.delay(envelope.model_dump_json())
-    logger.debug(
-        "Enqueued metric/log event: case=%s, tenant_id=%s, event_id=%s",
-        case,
-        tenant_id,
-        event_id,
-    )
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Yanli 盐粒	ce1a1c062f	chore(make): default PATH_TO_CHECK to api/	2026-01-29 02:43:32 +08:00
Yanli 盐粒	5af4d7f9a1	chore(api): bootstrap ty type-checking - Add api/ty.toml exclusions for incremental rollout - Wire ty into make type-check (with basedpyright + mypy) - Update style workflow to run make type-check	2026-01-29 02:41:26 +08:00