feat: sync main branch (#31938)

Signed-off-by: majiayu000 <[email protected]>
Signed-off-by: dependabot[bot] <[email protected]>
Signed-off-by: NeatGuyCoding <[email protected]>
Signed-off-by: -LAN- <[email protected]>
Signed-off-by: yihong0618 <[email protected]>
Co-authored-by: QuantumGhost <[email protected]>
Co-authored-by: 盐粒 Yanli <[email protected]>
Co-authored-by: wangxiaolei <[email protected]>
Co-authored-by: Stephen Zhou <[email protected]>
Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>
Co-authored-by: Cursx <[email protected]>
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Co-authored-by: lif <[email protected]>
Co-authored-by: 非法操作 <[email protected]>
Co-authored-by: Asuka Minato <[email protected]>
Co-authored-by: fenglin <[email protected]>
Co-authored-by: qiaofenglin <[email protected]>
Co-authored-by: -LAN- <[email protected]>
Co-authored-by: TomoOkuyama <[email protected]>
Co-authored-by: Tomo Okuyama <[email protected]>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: zyssyz123 <[email protected]>
Co-authored-by: hj24 <[email protected]>
Co-authored-by: Coding On Star <[email protected]>
Co-authored-by: CodingOnStar <[email protected]>
Co-authored-by: yyh <[email protected]>
Co-authored-by: Xiangxuan Qu <[email protected]>
Co-authored-by: fghpdf <[email protected]>
Co-authored-by: coopercoder <[email protected]>
Co-authored-by: zhaiguangpeng <[email protected]>
Co-authored-by: Junyan Qin (Chin) <[email protected]>
Co-authored-by: E.G <[email protected]>
Co-authored-by: GlobalStar117 <[email protected]>
Co-authored-by: Claude Haiku 4.5 <[email protected]>
Co-authored-by: CodingOnStar <[email protected]>
Co-authored-by: crazywoola <[email protected]>
Co-authored-by: heyszt <[email protected]>
Co-authored-by: NeatGuyCoding <[email protected]>
Co-authored-by: Yeuoly <[email protected]>
Co-authored-by: zxhlyh <[email protected]>
Co-authored-by: moonpanda <[email protected]>
Co-authored-by: warlocgao <[email protected]>
Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: claude[bot] <41898282+claude[bot]@users.noreply.github.com>
Co-authored-by: KVOJJJin <[email protected]>
Co-authored-by: eux <[email protected]>
Co-authored-by: bangjiehan <[email protected]>
Co-authored-by: FFXN <[email protected]>
Co-authored-by: Jyong <[email protected]>
Co-authored-by: Nie Ronghua <[email protected]>
Co-authored-by: JQSevenMiao <[email protected]>
Co-authored-by: jiasiqi <[email protected]>
Co-authored-by: Seokrin Taron Sung <[email protected]>
Co-authored-by: CrabSAMA <[email protected]>
Co-authored-by: Copilot <[email protected]>
Co-authored-by: yihong <[email protected]>
Co-authored-by: Joel <[email protected]>
Co-authored-by: Wu Tianwei <[email protected]>
Co-authored-by: yessenia <[email protected]>
Co-authored-by: Jax <[email protected]>
Co-authored-by: niveshdandyan <[email protected]>
Co-authored-by: OSS Contributor <[email protected]>
Co-authored-by: niveshdandyan <[email protected]>
Co-authored-by: Sean Kenneth Doherty <[email protected]>

api/.ruff.toml

@@ -106,10 +106,10 @@ 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"]

api/README.md

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

api/app_factory.py

@@ -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,
     ]

api/commands.py

@@ -30,7 +30,6 @@ from extensions.ext_redis import redis_client
 from extensions.ext_storage import storage
 from extensions.storage.opendal_storage import OpenDALStorage
 from extensions.storage.storage_type import StorageType
-from libs.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")
 

api/configs/app_config.py

@@ -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 [email protected] by email to inquire about licensing matters.**
     EnterpriseFeatureConfig,
-    # Enterprise telemetry configs
-    EnterpriseTelemetryConfig,
 ):
     model_config = SettingsConfigDict(
         # read from dotenv format config file

api/configs/enterprise/__init__.py

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

api/controllers/console/app/app.py

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

api/controllers/console/app/generator.py

@@ -1,8 +1,12 @@
+import logging
 from collections.abc import Sequence
 
 from flask_restx import Resource
 from pydantic import BaseModel, Field
 
+logger = logging.getLogger(__name__)
+
+
 from controllers.console import console_ns
 from controllers.console.app.error import (
     CompletionRequestError,
@@ -19,6 +23,7 @@ from core.helper.code_executor.python3.python3_code_provider import Python3CodeP
 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 core.workflow.generator import WorkflowGenerator
 from extensions.ext_database import db
 from libs.login import current_account_with_tenant, login_required
 from models import App
@@ -35,13 +40,36 @@ class InstructionGeneratePayload(BaseModel):
     instruction: str = Field(..., description="Instruction for generation")
     model_config_data: ModelConfig = 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):
     type: str = Field(..., description="Instruction template type")
 
 
+class PreviousWorkflow(BaseModel):
+    """Previous workflow attempt for regeneration context."""
+
+    nodes: list[dict[str, Any]] = Field(default_factory=list, description="Previously generated nodes")
+    edges: list[dict[str, Any]] = Field(default_factory=list, description="Previously generated edges")
+    warnings: list[str] = Field(default_factory=list, description="Warnings from previous generation")
+
+
+class FlowchartGeneratePayload(BaseModel):
+    instruction: str = Field(..., description="Workflow flowchart generation instruction")
+    model_config_data: dict[str, Any] = Field(..., alias="model_config", description="Model configuration")
+    available_nodes: list[dict[str, Any]] = Field(default_factory=list, description="Available node types")
+    existing_nodes: list[dict[str, Any]] = Field(default_factory=list, description="Existing workflow nodes")
+    existing_edges: list[dict[str, Any]] = Field(default_factory=list, description="Existing workflow edges")
+    available_tools: list[dict[str, Any]] = Field(default_factory=list, description="Available tools")
+    selected_node_ids: list[str] = Field(default_factory=list, description="IDs of selected nodes for context")
+    previous_workflow: PreviousWorkflow | None = Field(default=None, description="Previous workflow for regeneration")
+    regenerate_mode: bool = Field(default=False, description="Whether this is a regeneration request")
+    # Language preference for generated content (node titles, descriptions)
+    language: str | None = Field(default=None, description="Preferred language for generated content")
+    # Available models that user has configured (for LLM/question-classifier nodes)
+    available_models: list[dict[str, Any]] = Field(default_factory=list, description="User's configured models")
+
+
 def reg(cls: type[BaseModel]):
     console_ns.schema_model(cls.__name__, cls.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0))
 
@@ -51,6 +79,7 @@ reg(RuleCodeGeneratePayload)
 reg(RuleStructuredOutputPayload)
 reg(InstructionGeneratePayload)
 reg(InstructionTemplatePayload)
+reg(FlowchartGeneratePayload)
 reg(ModelConfig)
 
 
@@ -67,17 +96,10 @@ 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(
-                tenant_id=current_tenant_id,
-                instruction=args.instruction,
-                model_config=args.model_config_data,
-                no_variable=args.no_variable,
-                user_id=account.id,
-                app_id=args.app_id,
-            )
+            rules = LLMGenerator.generate_rule_config(tenant_id=current_tenant_id, args=args)
         except ProviderTokenNotInitError as ex:
             raise ProviderNotInitializeError(ex.description)
         except QuotaExceededError:
@@ -103,16 +125,12 @@ 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(
                 tenant_id=current_tenant_id,
-                instruction=args.instruction,
-                model_config=args.model_config_data,
-                code_language=args.code_language,
-                user_id=account.id,
-                app_id=args.app_id,
+                args=args,
             )
         except ProviderTokenNotInitError as ex:
             raise ProviderNotInitializeError(ex.description)
@@ -139,15 +157,12 @@ 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,
+                args=args,
             )
         except ProviderTokenNotInitError as ex:
             raise ProviderNotInitializeError(ex.description)
@@ -174,14 +189,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:
@@ -198,33 +213,33 @@ class InstructionGenerateApi(Resource):
                     case "llm":
                         return LLMGenerator.generate_rule_config(
                             current_tenant_id,
-                            instruction=args.instruction,
-                            model_config=args.model_config_data,
-                            no_variable=True,
-                            user_id=account.id,
-                            app_id=app_id,
+                            args=RuleGeneratePayload(
+                                instruction=args.instruction,
+                                model_config=args.model_config_data,
+                                no_variable=True,
+                            ),
                         )
                     case "agent":
                         return LLMGenerator.generate_rule_config(
                             current_tenant_id,
-                            instruction=args.instruction,
-                            model_config=args.model_config_data,
-                            no_variable=True,
-                            user_id=account.id,
-                            app_id=app_id,
+                            args=RuleGeneratePayload(
+                                instruction=args.instruction,
+                                model_config=args.model_config_data,
+                                no_variable=True,
+                            ),
                         )
                     case "code":
                         return LLMGenerator.generate_code(
                             tenant_id=current_tenant_id,
-                            instruction=args.instruction,
-                            model_config=args.model_config_data,
-                            code_language=args.language,
-                            user_id=account.id,
-                            app_id=app_id,
+                            args=RuleCodeGeneratePayload(
+                                instruction=args.instruction,
+                                model_config=args.model_config_data,
+                                code_language=args.language,
+                            ),
                         )
                     case _:
                         return {"error": f"invalid node type: {node_type}"}
-            if args.node_id == "" and args.current != "":
+            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 +247,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 +258,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:
@@ -259,6 +270,52 @@ class InstructionGenerateApi(Resource):
             raise CompletionRequestError(e.description)
 
 
+@console_ns.route("/flowchart-generate")
+class FlowchartGenerateApi(Resource):
+    @console_ns.doc("generate_workflow_flowchart")
+    @console_ns.doc(description="Generate workflow flowchart using LLM with intent classification")
+    @console_ns.expect(console_ns.models[FlowchartGeneratePayload.__name__])
+    @console_ns.response(200, "Flowchart generated successfully")
+    @console_ns.response(400, "Invalid request parameters")
+    @console_ns.response(402, "Provider quota exceeded")
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def post(self):
+        args = FlowchartGeneratePayload.model_validate(console_ns.payload)
+        _, current_tenant_id = current_account_with_tenant()
+
+        try:
+            # Convert PreviousWorkflow to dict if present
+            previous_workflow_dict = args.previous_workflow.model_dump() if args.previous_workflow else None
+
+            result = WorkflowGenerator.generate_workflow_flowchart(
+                tenant_id=current_tenant_id,
+                instruction=args.instruction,
+                model_config=args.model_config_data,
+                available_nodes=args.available_nodes,
+                existing_nodes=args.existing_nodes,
+                existing_edges=args.existing_edges,
+                available_tools=args.available_tools,
+                selected_node_ids=args.selected_node_ids,
+                previous_workflow=previous_workflow_dict,
+                regenerate_mode=args.regenerate_mode,
+                preferred_language=args.language,
+                available_models=args.available_models,
+            )
+
+        except ProviderTokenNotInitError as ex:
+            raise ProviderNotInitializeError(ex.description)
+        except QuotaExceededError:
+            raise ProviderQuotaExceededError()
+        except ModelCurrentlyNotSupportError:
+            raise ProviderModelCurrentlyNotSupportError()
+        except InvokeError as e:
+            raise CompletionRequestError(e.description)
+
+        return result
+
+
 @console_ns.route("/instruction-generate/template")
 class InstructionGenerationTemplateApi(Resource):
     @console_ns.doc("get_instruction_template")

api/controllers/console/app/ops_trace.py

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

api/controllers/console/explore/trial.py

@@ -1,15 +1,16 @@
 import logging
-from typing import Any, cast
+from typing import Any, Literal, cast
 
 from flask import request
-from flask_restx import Resource, fields, marshal, marshal_with, reqparse
+from flask_restx import Resource, fields, marshal, marshal_with
+from pydantic import BaseModel
 from werkzeug.exceptions import Forbidden, InternalServerError, NotFound
 
 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,
@@ -117,7 +118,56 @@ workflow_fields_copy["rag_pipeline_variables"] = fields.List(fields.Nested(pipel
 workflow_model = get_or_create_model("TrialWorkflow", workflow_fields_copy)
 
 
+# Pydantic models for request validation
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
+
+
+class WorkflowRunRequest(BaseModel):
+    inputs: dict
+    files: list | None = None
+
+
+class ChatRequest(BaseModel):
+    inputs: dict
+    query: str
+    files: list | None = None
+    conversation_id: str | None = None
+    parent_message_id: str | None = None
+    retriever_from: str = "explore_app"
+
+
+class TextToSpeechRequest(BaseModel):
+    message_id: str | None = None
+    voice: str | None = None
+    text: str | None = None
+    streaming: bool | None = None
+
+
+class CompletionRequest(BaseModel):
+    inputs: dict
+    query: str = ""
+    files: list | None = None
+    response_mode: Literal["blocking", "streaming"] | None = None
+    retriever_from: str = "explore_app"
+
+
+# Register schemas for Swagger documentation
+console_ns.schema_model(
+    WorkflowRunRequest.__name__, WorkflowRunRequest.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0)
+)
+console_ns.schema_model(
+    ChatRequest.__name__, ChatRequest.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0)
+)
+console_ns.schema_model(
+    TextToSpeechRequest.__name__, TextToSpeechRequest.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0)
+)
+console_ns.schema_model(
+    CompletionRequest.__name__, CompletionRequest.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0)
+)
+
+
 class TrialAppWorkflowRunApi(TrialAppResource):
+    @console_ns.expect(console_ns.models[WorkflowRunRequest.__name__])
     def post(self, trial_app):
         """
         Run workflow
@@ -129,10 +179,8 @@ class TrialAppWorkflowRunApi(TrialAppResource):
         if app_mode != AppMode.WORKFLOW:
             raise NotWorkflowAppError()
 
-        parser = reqparse.RequestParser()
-        parser.add_argument("inputs", type=dict, required=True, nullable=False, location="json")
-        parser.add_argument("files", type=list, required=False, location="json")
-        args = parser.parse_args()
+        request_data = WorkflowRunRequest.model_validate(console_ns.payload)
+        args = request_data.model_dump()
         assert current_user is not None
         try:
             app_id = app_model.id
@@ -183,6 +231,7 @@ class TrialAppWorkflowTaskStopApi(TrialAppResource):
 
 
 class TrialChatApi(TrialAppResource):
+    @console_ns.expect(console_ns.models[ChatRequest.__name__])
     @trial_feature_enable
     def post(self, trial_app):
         app_model = trial_app
@@ -190,14 +239,14 @@ class TrialChatApi(TrialAppResource):
         if app_mode not in {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT}:
             raise NotChatAppError()
 
-        parser = reqparse.RequestParser()
-        parser.add_argument("inputs", type=dict, required=True, location="json")
-        parser.add_argument("query", type=str, required=True, location="json")
-        parser.add_argument("files", type=list, required=False, location="json")
-        parser.add_argument("conversation_id", type=uuid_value, location="json")
-        parser.add_argument("parent_message_id", type=uuid_value, required=False, location="json")
-        parser.add_argument("retriever_from", type=str, required=False, default="explore_app", location="json")
-        args = parser.parse_args()
+        request_data = ChatRequest.model_validate(console_ns.payload)
+        args = request_data.model_dump()
+
+        # Validate UUID values if provided
+        if args.get("conversation_id"):
+            args["conversation_id"] = uuid_value(args["conversation_id"])
+        if args.get("parent_message_id"):
+            args["parent_message_id"] = uuid_value(args["parent_message_id"])
 
         args["auto_generate_name"] = False
 
@@ -320,20 +369,16 @@ class TrialChatAudioApi(TrialAppResource):
 
 
 class TrialChatTextApi(TrialAppResource):
+    @console_ns.expect(console_ns.models[TextToSpeechRequest.__name__])
     @trial_feature_enable
     def post(self, trial_app):
         app_model = trial_app
         try:
-            parser = reqparse.RequestParser()
-            parser.add_argument("message_id", type=str, required=False, location="json")
-            parser.add_argument("voice", type=str, location="json")
-            parser.add_argument("text", type=str, location="json")
-            parser.add_argument("streaming", type=bool, location="json")
-            args = parser.parse_args()
+            request_data = TextToSpeechRequest.model_validate(console_ns.payload)
 
-            message_id = args.get("message_id", None)
-            text = args.get("text", None)
-            voice = args.get("voice", None)
+            message_id = request_data.message_id
+            text = request_data.text
+            voice = request_data.voice
             if not isinstance(current_user, Account):
                 raise ValueError("current_user must be an Account instance")
 
@@ -371,19 +416,15 @@ class TrialChatTextApi(TrialAppResource):
 
 
 class TrialCompletionApi(TrialAppResource):
+    @console_ns.expect(console_ns.models[CompletionRequest.__name__])
     @trial_feature_enable
     def post(self, trial_app):
         app_model = trial_app
         if app_model.mode != "completion":
             raise NotCompletionAppError()
 
-        parser = reqparse.RequestParser()
-        parser.add_argument("inputs", type=dict, required=True, location="json")
-        parser.add_argument("query", type=str, location="json", default="")
-        parser.add_argument("files", type=list, required=False, location="json")
-        parser.add_argument("response_mode", type=str, choices=["blocking", "streaming"], location="json")
-        parser.add_argument("retriever_from", type=str, required=False, default="explore_app", location="json")
-        args = parser.parse_args()
+        request_data = CompletionRequest.model_validate(console_ns.payload)
+        args = request_data.model_dump()
 
         streaming = args["response_mode"] == "streaming"
         args["auto_generate_name"] = False

api/controllers/console/workspace/tool_providers.py

@@ -878,11 +878,7 @@ class ToolBuiltinProviderSetDefaultApi(Resource):
         current_user, current_tenant_id = current_account_with_tenant()
         payload = BuiltinProviderDefaultCredentialPayload.model_validate(console_ns.payload or {})
         return BuiltinToolManageService.set_default_provider(
-            tenant_id=current_tenant_id,
-            user_id=current_user.id,
-            provider=provider,
-            id=payload.id,
-            account=current_user,
+            tenant_id=current_tenant_id, user_id=current_user.id, provider=provider, id=payload.id
         )
 
 

api/core/agent/base_agent_runner.py

@@ -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,

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

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

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

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

api/core/app/task_pipeline/easy_ui_based_generate_task_pipeline.py

@@ -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.

api/core/app/task_pipeline/message_cycle_manager.py

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

api/core/app/workflow/layers/persistence.py

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

api/core/callback_handler/agent_tool_callback_handler.py

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

api/core/helper/ssrf_proxy.py

@@ -171,9 +171,10 @@ def make_request(method: str, url: str, max_retries: int = SSRF_DEFAULT_MAX_RETR
             # httpx may override the Host header when using a proxy
             headers = {k: v for k, v in headers.items() if k.lower() != "host"}
             if user_provided_host is not None:
-                headers["host"] = user_provided_host
-            kwargs["headers"] = headers
-            response = client.request(method=method, url=url, **kwargs)
+                headers["Host"] = user_provided_host
+
+            request = client.build_request(method, url, headers=headers, **kwargs)
+            response = client.send(request, follow_redirects=follow_redirects)
 
             # Check for SSRF protection by Squid proxy
             if response.status_code in (401, 403):

api/core/llm_generator/entities.py

@@ -9,7 +9,6 @@ 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):
@@ -19,4 +18,3 @@ class RuleCodeGeneratePayload(RuleGeneratePayload):
 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")

api/core/llm_generator/llm_generator.py

@@ -1,20 +1,18 @@
 import json
 import logging
-import re
 from collections.abc import Sequence
 from typing import Protocol, cast
 
 import json_repair
 
 from core.app.app_config.entities import ModelConfig
+from core.llm_generator.entities import RuleCodeGeneratePayload, RuleGeneratePayload, RuleStructuredOutputPayload
 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 (
     CONVERSATION_TITLE_PROMPT,
     GENERATOR_QA_PROMPT,
     JAVASCRIPT_CODE_GENERATOR_PROMPT_TEMPLATE,
-    LLM_MODIFY_CODE_SYSTEM,
-    LLM_MODIFY_PROMPT_SYSTEM,
     PYTHON_CODE_GENERATOR_PROMPT_TEMPLATE,
     SUGGESTED_QUESTIONS_MAX_TOKENS,
     SUGGESTED_QUESTIONS_TEMPERATURE,
@@ -26,12 +24,12 @@ 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 core.workflow.generator import WorkflowGenerator
 from extensions.ext_database import db
 from extensions.ext_storage import storage
 from models import App, Message, WorkflowNodeExecutionModel
@@ -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,27 +151,19 @@ 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, args: RuleGeneratePayload):
         output_parser = RuleConfigGeneratorOutputParser()
 
         error = ""
         error_step = ""
         rule_config = {"prompt": "", "variables": [], "opening_statement": "", "error": ""}
-        model_parameters = model_config.completion_params
-        if no_variable:
+        model_parameters = args.model_config_data.completion_params
+        if args.no_variable:
             prompt_template = PromptTemplateParser(WORKFLOW_RULE_CONFIG_PROMPT_GENERATE_TEMPLATE)
 
             prompt_generate = prompt_template.format(
                 inputs={
-                    "TASK_DESCRIPTION": instruction,
+                    "TASK_DESCRIPTION": args.instruction,
                 },
                 remove_template_variables=False,
             )
@@ -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=args.model_config_data.provider,
+                model=args.model_config_data.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", args.model_config_data.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
@@ -240,7 +209,7 @@ class LLMGenerator:
         # format the prompt_generate_prompt
         prompt_generate_prompt = prompt_template.format(
             inputs={
-                "TASK_DESCRIPTION": instruction,
+                "TASK_DESCRIPTION": args.instruction,
             },
             remove_template_variables=False,
         )
@@ -251,125 +220,113 @@ 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=args.model_config_data.provider,
+            model=args.model_config_data.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": args.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", args.model_config_data.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_workflow_flowchart(
+        cls,
+        tenant_id: str,
+        instruction: str,
+        model_config: dict,
+        available_nodes: Sequence[dict[str, object]] | None = None,
+        existing_nodes: Sequence[dict[str, object]] | None = None,
+        available_tools: Sequence[dict[str, object]] | None = None,
+        selected_node_ids: Sequence[str] | None = None,
+        previous_workflow: dict[str, object] | None = None,
+        regenerate_mode: bool = False,
+        preferred_language: str | None = None,
+        available_models: Sequence[dict[str, object]] | None = None,
+    ):
+        return WorkflowGenerator.generate_workflow_flowchart(
+            tenant_id=tenant_id,
+            instruction=instruction,
+            model_config=model_config,
+            available_nodes=available_nodes,
+            existing_nodes=existing_nodes,
+            available_tools=available_tools,
+            selected_node_ids=selected_node_ids,
+            previous_workflow=previous_workflow,
+            regenerate_mode=regenerate_mode,
+            preferred_language=preferred_language,
+            available_models=available_models,
+        )
+
     @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,
+        args: RuleCodeGeneratePayload,
     ):
-        if code_language == "python":
+        if args.code_language == "python":
             prompt_template = PromptTemplateParser(PYTHON_CODE_GENERATOR_PROMPT_TEMPLATE)
         else:
             prompt_template = PromptTemplateParser(JAVASCRIPT_CODE_GENERATOR_PROMPT_TEMPLATE)
 
         prompt = prompt_template.format(
             inputs={
-                "INSTRUCTION": instruction,
-                "CODE_LANGUAGE": code_language,
+                "INSTRUCTION": args.instruction,
+                "CODE_LANGUAGE": args.code_language,
             },
             remove_template_variables=False,
         )
@@ -378,49 +335,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=args.model_config_data.provider,
+            model=args.model_config_data.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 = args.model_config_data.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": args.code_language, "error": ""}
+
+        except InvokeError as e:
+            error = str(e)
+            return {"code": "", "language": args.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", args.model_config_data.name, args.code_language
+            )
+            return {"code": "", "language": args.code_language, "error": f"An unexpected error occurred: {str(e)}"}
 
     @classmethod
     def generate_qa_document(cls, tenant_id: str, query, document_language: str):
@@ -446,81 +382,49 @@ 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, args: RuleStructuredOutputPayload):
         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=args.model_config_data.provider,
+            model=args.model_config_data.name,
         )
 
         prompt_messages = [
             SystemPromptMessage(content=SYSTEM_STRUCTURED_OUTPUT_GENERATE),
-            UserPromptMessage(content=instruction),
+            UserPromptMessage(content=args.instruction),
         ]
-        model_parameters = model_config.completion_params
+        model_parameters = args.model_config_data.completion_params
 
-        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", args.model_config_data.name)
+            return {"output": "", "error": f"An unexpected error occurred: {str(e)}"}
 
     @staticmethod
     def instruction_modify_legacy(
@@ -530,14 +434,12 @@ class LLMGenerator:
         instruction: str,
         model_config: ModelConfig,
         ideal_output: str | None,
-        user_id: str | None = None,
-        app_id: str | None = 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 +448,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(
@@ -579,8 +475,6 @@ class LLMGenerator:
         model_config: ModelConfig,
         ideal_output: str | None,
         workflow_service: WorkflowServiceInterface,
-        user_id: str | None = None,
-        app_id: str | None = None,
     ):
         session = db.session()
 
@@ -611,8 +505,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,8 +538,6 @@ class LLMGenerator:
             instruction=instruction,
             node_type=last_run.node_type,
             ideal_output=ideal_output,
-            user_id=user_id,
-            app_id=app_id,
         )
 
     @staticmethod
@@ -660,8 +550,6 @@ class LLMGenerator:
         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#}}"
@@ -701,120 +589,24 @@ 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.name), exc_info=True)
+            return {"error": f"An unexpected error occurred: {str(e)}"}

api/core/llm_generator/prompts.py

@@ -143,6 +143,50 @@ Based on task description, please create a well-structured prompt template that
 Please generate the full prompt template with at least 300 words and output only the prompt template.
 """  # noqa: E501
 
+WORKFLOW_FLOWCHART_PROMPT_TEMPLATE = """
+You are an expert workflow designer. Generate a Mermaid flowchart based on the user's request.
+
+Constraints:
+- Detect the language of the user's request. Generate all node titles in the same language as the user's input.
+- If the input language cannot be determined, use {{PREFERRED_LANGUAGE}} as the fallback language.
+- Use only node types listed in <available_nodes>.
+- Use only tools listed in <available_tools>. When using a tool node, set type=tool and tool=<tool_key>.
+- Tools may include MCP providers (provider_type=mcp). Tool selection still uses tool_key.
+- Prefer reusing node titles from <existing_nodes> when possible.
+- Output must be valid Mermaid flowchart syntax, no markdown, no extra text.
+- First line must be: flowchart LR
+- Every node must be declared on its own line using:
+  <id>["type=<type>|title=<title>|tool=<tool_key>"]
+  - type is required and must match a type in <available_nodes>.
+  - title is required for non-tool nodes.
+  - tool is required only when type=tool, otherwise omit tool.
+- Declare all node lines before any edges.
+- Edges must use:
+  <id> --> <id>
+  <id> -->|true| <id>
+  <id> -->|false| <id>
+- Keep node ids unique and simple (N1, N2, ...).
+- For complex orchestration:
+  - Break the request into stages (ingest, transform, decision, action, output).
+  - Use IfElse for branching and label edges true/false only.
+  - Fan-in branches by connecting multiple nodes into a shared downstream node.
+  - Avoid cycles unless explicitly requested.
+  - Keep each branch complete with a clear downstream target.
+
+<user_request>
+{{TASK_DESCRIPTION}}
+</user_request>
+<available_nodes>
+{{AVAILABLE_NODES}}
+</available_nodes>
+<existing_nodes>
+{{EXISTING_NODES}}
+</existing_nodes>
+<available_tools>
+{{AVAILABLE_TOOLS}}
+</available_tools>
+"""
+
 RULE_CONFIG_PROMPT_GENERATE_TEMPLATE = """
 Here is a task description for which I would like you to create a high-quality prompt template for:
 <task_description>

api/core/logging/filters.py

@@ -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]:

api/core/moderation/input_moderation.py

@@ -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:

api/core/ops/entities/trace_entity.py

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

api/core/ops/langfuse_trace/langfuse_trace.py

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

api/core/ops/langsmith_trace/langsmith_trace.py

@@ -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,

api/core/ops/ops_trace_manager.py

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

api/core/rag/retrieval/dataset_retrieval.py

@@ -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
@@ -729,21 +728,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(

api/core/telemetry/__init__.py

@@ -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",
-]

api/core/telemetry/events.py

@@ -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]

api/core/telemetry/gateway.py

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

api/core/tools/workflow_as_tool/tool.py

@@ -50,7 +50,6 @@ class WorkflowTool(Tool):
         self.workflow_call_depth = workflow_call_depth
         self.label = label
         self._latest_usage = LLMUsage.empty_usage()
-        self.parent_trace_context: dict[str, str] | None = None
 
         super().__init__(entity=entity, runtime=runtime)
 
@@ -91,15 +90,11 @@ class WorkflowTool(Tool):
 
         self._latest_usage = LLMUsage.empty_usage()
 
-        args: dict[str, Any] = {"inputs": tool_parameters, "files": files}
-        if self.parent_trace_context:
-            args["_parent_trace_context"] = self.parent_trace_context
-
         result = generator.generate(
             app_model=app,
             workflow=workflow,
             user=user,
-            args=args,
+            args={"inputs": tool_parameters, "files": files},
             invoke_from=self.runtime.invoke_from,
             streaming=False,
             call_depth=self.workflow_call_depth + 1,

api/core/workflow/enums.py

@@ -232,8 +232,6 @@ class WorkflowNodeExecutionMetadataKey(StrEnum):
     """
 
     TOTAL_TOKENS = "total_tokens"
-    PROMPT_TOKENS = "prompt_tokens"
-    COMPLETION_TOKENS = "completion_tokens"
     TOTAL_PRICE = "total_price"
     CURRENCY = "currency"
     TOOL_INFO = "tool_info"

api/core/workflow/generator/__init__.py

@@ -0,0 +1 @@
+from .runner import WorkflowGenerator

api/core/workflow/generator/config/__init__.py

@@ -0,0 +1,29 @@
+"""
+Vibe Workflow Generator Configuration Module.
+
+This module centralizes configuration for the Vibe workflow generation feature,
+including node schemas, fallback rules, and response templates.
+"""
+
+from core.workflow.generator.config.node_schemas import (
+    BUILTIN_NODE_SCHEMAS,
+    FALLBACK_RULES,
+    FIELD_NAME_CORRECTIONS,
+    NODE_TYPE_ALIASES,
+    get_builtin_node_schemas,
+    get_corrected_field_name,
+    validate_node_schemas,
+)
+from core.workflow.generator.config.responses import DEFAULT_SUGGESTIONS, OFF_TOPIC_RESPONSES
+
+__all__ = [
+    "BUILTIN_NODE_SCHEMAS",
+    "DEFAULT_SUGGESTIONS",
+    "FALLBACK_RULES",
+    "FIELD_NAME_CORRECTIONS",
+    "NODE_TYPE_ALIASES",
+    "OFF_TOPIC_RESPONSES",
+    "get_builtin_node_schemas",
+    "get_corrected_field_name",
+    "validate_node_schemas",
+]

api/core/workflow/generator/config/node_schemas.py

@@ -0,0 +1,501 @@
+"""
+Unified Node Configuration for Vibe Workflow Generation.
+
+This module centralizes all node-related configuration:
+- Node schemas (parameter definitions)
+- Fallback rules (keyword-based node type inference)
+- Node type aliases (natural language to canonical type mapping)
+- Field name corrections (LLM output normalization)
+- Validation utilities
+
+Note: These definitions are the single source of truth.
+Frontend has a mirrored copy at web/app/components/workflow/hooks/use-workflow-vibe-config.ts
+"""
+
+from typing import Any
+
+# =============================================================================
+# NODE SCHEMAS
+# =============================================================================
+
+# Built-in node schemas with parameter definitions
+# These help the model understand what config each node type requires
+_HARDCODED_SCHEMAS: dict[str, dict[str, Any]] = {
+    "http-request": {
+        "description": "Send HTTP requests to external APIs or fetch web content",
+        "required": ["url", "method"],
+        "parameters": {
+            "url": {
+                "type": "string",
+                "description": "Full URL including protocol (https://...)",
+                "example": "{{#start.url#}} or https://api.example.com/data",
+            },
+            "method": {
+                "type": "enum",
+                "options": ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD"],
+                "description": "HTTP method",
+            },
+            "headers": {
+                "type": "string",
+                "description": "HTTP headers as newline-separated 'Key: Value' pairs",
+                "example": "Content-Type: application/json\nAuthorization: Bearer {{#start.api_key#}}",
+            },
+            "params": {
+                "type": "string",
+                "description": "URL query parameters as newline-separated 'key: value' pairs",
+            },
+            "body": {
+                "type": "object",
+                "description": "Request body with type field required",
+                "example": {"type": "none", "data": []},
+            },
+            "authorization": {
+                "type": "object",
+                "description": "Authorization config",
+                "example": {"type": "no-auth"},
+            },
+            "timeout": {
+                "type": "number",
+                "description": "Request timeout in seconds",
+                "default": 60,
+            },
+        },
+        "outputs": ["body (response content)", "status_code", "headers"],
+    },
+    "code": {
+        "description": "Execute Python or JavaScript code for custom logic",
+        "required": ["code", "language"],
+        "parameters": {
+            "code": {
+                "type": "string",
+                "description": "Code to execute. Must define a main() function that returns a dict.",
+            },
+            "language": {
+                "type": "enum",
+                "options": ["python3", "javascript"],
+            },
+            "variables": {
+                "type": "array",
+                "description": "Input variables passed to the code",
+                "item_schema": {"variable": "string", "value_selector": "array"},
+            },
+            "outputs": {
+                "type": "object",
+                "description": "Output variable definitions",
+            },
+        },
+        "outputs": ["Variables defined in outputs schema"],
+    },
+    "llm": {
+        "description": "Call a large language model for text generation/processing",
+        "required": ["prompt_template"],
+        "parameters": {
+            "model": {
+                "type": "object",
+                "description": "Model configuration (provider, name, mode)",
+            },
+            "prompt_template": {
+                "type": "array",
+                "description": "Messages for the LLM",
+                "item_schema": {
+                    "role": "enum: system, user, assistant",
+                    "text": "string - message content, can include {{#node_id.field#}} references",
+                },
+            },
+            "context": {
+                "type": "object",
+                "description": "Optional context settings",
+            },
+            "memory": {
+                "type": "object",
+                "description": "Optional memory/conversation settings",
+            },
+        },
+        "outputs": ["text (generated response)"],
+    },
+    "if-else": {
+        "description": "Conditional branching based on conditions",
+        "required": ["cases"],
+        "parameters": {
+            "cases": {
+                "type": "array",
+                "description": "List of condition cases. Each case defines when 'true' branch is taken.",
+                "item_schema": {
+                    "case_id": "string - unique case identifier (e.g., 'case_1')",
+                    "logical_operator": "enum: and, or - how multiple conditions combine",
+                    "conditions": {
+                        "type": "array",
+                        "item_schema": {
+                            "variable_selector": "array of strings - path to variable, e.g. ['node_id', 'field']",
+                            "comparison_operator": (
+                                "enum: =, ≠, >, <, ≥, ≤, contains, not contains, is, is not, empty, not empty"
+                            ),
+                            "value": "string or number - value to compare against",
+                        },
+                    },
+                },
+            },
+        },
+        "outputs": ["Branches: true (first case conditions met), false (else/no case matched)"],
+    },
+    "knowledge-retrieval": {
+        "description": "Query knowledge base for relevant content",
+        "required": ["query_variable_selector", "dataset_ids"],
+        "parameters": {
+            "query_variable_selector": {
+                "type": "array",
+                "description": "Path to query variable, e.g. ['start', 'query']",
+            },
+            "dataset_ids": {
+                "type": "array",
+                "description": "List of knowledge base IDs to search",
+            },
+            "retrieval_mode": {
+                "type": "enum",
+                "options": ["single", "multiple"],
+            },
+        },
+        "outputs": ["result (retrieved documents)"],
+    },
+    "template-transform": {
+        "description": "Transform data using Jinja2 templates",
+        "required": ["template", "variables"],
+        "parameters": {
+            "template": {
+                "type": "string",
+                "description": "Jinja2 template string. Use {{ variable_name }} to reference variables.",
+            },
+            "variables": {
+                "type": "array",
+                "description": "Input variables defined for the template",
+                "item_schema": {
+                    "variable": "string - variable name to use in template",
+                    "value_selector": "array - path to source value, e.g. ['start', 'user_input']",
+                },
+            },
+        },
+        "outputs": ["output (transformed string)"],
+    },
+    "variable-aggregator": {
+        "description": "Aggregate variables from multiple branches",
+        "required": ["variables"],
+        "parameters": {
+            "variables": {
+                "type": "array",
+                "description": "List of variable selectors to aggregate",
+                "item_schema": "array of strings - path to source variable, e.g. ['node_id', 'field']",
+            },
+        },
+        "outputs": ["output (aggregated value)"],
+    },
+    "iteration": {
+        "description": "Loop over array items",
+        "required": ["iterator_selector"],
+        "parameters": {
+            "iterator_selector": {
+                "type": "array",
+                "description": "Path to array variable to iterate",
+            },
+        },
+        "outputs": ["item (current iteration item)", "index (current index)"],
+    },
+    "parameter-extractor": {
+        "description": "Extract structured parameters from user input using LLM",
+        "required": ["query", "parameters"],
+        "parameters": {
+            "model": {
+                "type": "object",
+                "description": "Model configuration (provider, name, mode)",
+            },
+            "query": {
+                "type": "array",
+                "description": "Path to input text to extract parameters from, e.g. ['start', 'user_input']",
+            },
+            "parameters": {
+                "type": "array",
+                "description": "Parameters to extract from the input",
+                "item_schema": {
+                    "name": "string - parameter name (required)",
+                    "type": (
+                        "enum: string, number, boolean, array[string], array[number], array[object], array[boolean]"
+                    ),
+                    "description": "string - description of what to extract (required)",
+                    "required": "boolean - whether this parameter is required (MUST be specified)",
+                    "options": "array of strings (optional) - for enum-like selection",
+                },
+            },
+            "instruction": {
+                "type": "string",
+                "description": "Additional instructions for extraction",
+            },
+            "reasoning_mode": {
+                "type": "enum",
+                "options": ["function_call", "prompt"],
+                "description": "How to perform extraction (defaults to function_call)",
+            },
+        },
+        "outputs": ["Extracted parameters as defined in parameters array", "__is_success", "__reason"],
+    },
+    "question-classifier": {
+        "description": "Classify user input into predefined categories using LLM",
+        "required": ["query", "classes"],
+        "parameters": {
+            "model": {
+                "type": "object",
+                "description": "Model configuration (provider, name, mode)",
+            },
+            "query": {
+                "type": "array",
+                "description": "Path to input text to classify, e.g. ['start', 'user_input']",
+            },
+            "classes": {
+                "type": "array",
+                "description": "Classification categories",
+                "item_schema": {
+                    "id": "string - unique class identifier",
+                    "name": "string - class name/label",
+                },
+            },
+            "instruction": {
+                "type": "string",
+                "description": "Additional instructions for classification",
+            },
+        },
+        "outputs": ["class_name (selected class)"],
+    },
+}
+
+
+def _get_dynamic_schemas() -> dict[str, dict[str, Any]]:
+    """
+    Dynamically load schemas from node classes.
+    Uses lazy import to avoid circular dependency.
+    """
+    from core.workflow.nodes.node_mapping import LATEST_VERSION, NODE_TYPE_CLASSES_MAPPING
+
+    schemas = {}
+    for node_type, version_map in NODE_TYPE_CLASSES_MAPPING.items():
+        # Get the latest version class
+        node_cls = version_map.get(LATEST_VERSION)
+        if not node_cls:
+            continue
+
+        # Get schema from the class
+        schema = node_cls.get_default_config_schema()
+        if schema:
+            schemas[node_type.value] = schema
+
+    return schemas
+
+
+# Cache for built-in schemas (populated on first access)
+_builtin_schemas_cache: dict[str, dict[str, Any]] | None = None
+
+
+def get_builtin_node_schemas() -> dict[str, dict[str, Any]]:
+    """
+    Get the complete set of built-in node schemas.
+    Combines hardcoded schemas with dynamically loaded ones.
+    Results are cached after first call.
+    """
+    global _builtin_schemas_cache
+    if _builtin_schemas_cache is None:
+        _builtin_schemas_cache = {**_HARDCODED_SCHEMAS, **_get_dynamic_schemas()}
+    return _builtin_schemas_cache
+
+
+# For backward compatibility - but use get_builtin_node_schemas() for lazy loading
+BUILTIN_NODE_SCHEMAS: dict[str, dict[str, Any]] = _HARDCODED_SCHEMAS.copy()
+
+
+# =============================================================================
+# FALLBACK RULES
+# =============================================================================
+
+# Keyword rules for smart fallback detection
+# Maps node type to keywords that suggest using that node type as a fallback
+FALLBACK_RULES: dict[str, list[str]] = {
+    "http-request": [
+        "http",
+        "url",
+        "web",
+        "scrape",
+        "scraper",
+        "fetch",
+        "api",
+        "request",
+        "download",
+        "upload",
+        "webhook",
+        "endpoint",
+        "rest",
+        "get",
+        "post",
+    ],
+    "code": [
+        "code",
+        "script",
+        "calculate",
+        "compute",
+        "process",
+        "transform",
+        "parse",
+        "convert",
+        "format",
+        "filter",
+        "sort",
+        "math",
+        "logic",
+    ],
+    "llm": [
+        "analyze",
+        "summarize",
+        "summary",
+        "extract",
+        "classify",
+        "translate",
+        "generate",
+        "write",
+        "rewrite",
+        "explain",
+        "answer",
+        "chat",
+    ],
+}
+
+
+# =============================================================================
+# NODE TYPE ALIASES
+# =============================================================================
+
+# Node type aliases for inference from natural language
+# Maps common terms to canonical node type names
+NODE_TYPE_ALIASES: dict[str, str] = {
+    # Start node aliases
+    "start": "start",
+    "begin": "start",
+    "input": "start",
+    # End node aliases
+    "end": "end",
+    "finish": "end",
+    "output": "end",
+    # LLM node aliases
+    "llm": "llm",
+    "ai": "llm",
+    "gpt": "llm",
+    "model": "llm",
+    "chat": "llm",
+    # Code node aliases
+    "code": "code",
+    "script": "code",
+    "python": "code",
+    "javascript": "code",
+    # HTTP request node aliases
+    "http-request": "http-request",
+    "http": "http-request",
+    "request": "http-request",
+    "api": "http-request",
+    "fetch": "http-request",
+    "webhook": "http-request",
+    # Conditional node aliases
+    "if-else": "if-else",
+    "condition": "if-else",
+    "branch": "if-else",
+    "switch": "if-else",
+    # Loop node aliases
+    "iteration": "iteration",
+    "loop": "loop",
+    "foreach": "iteration",
+    # Tool node alias
+    "tool": "tool",
+}
+
+
+# =============================================================================
+# FIELD NAME CORRECTIONS
+# =============================================================================
+
+# Field name corrections for LLM-generated node configs
+# Maps incorrect field names to correct ones for specific node types
+FIELD_NAME_CORRECTIONS: dict[str, dict[str, str]] = {
+    "http-request": {
+        "text": "body",  # LLM might use "text" instead of "body"
+        "content": "body",
+        "response": "body",
+    },
+    "code": {
+        "text": "result",  # LLM might use "text" instead of "result"
+        "output": "result",
+    },
+    "llm": {
+        "response": "text",
+        "answer": "text",
+    },
+}
+
+
+def get_corrected_field_name(node_type: str, field: str) -> str:
+    """
+    Get the corrected field name for a node type.
+
+    Args:
+        node_type: The type of the node (e.g., "http-request", "code")
+        field: The field name to correct
+
+    Returns:
+        The corrected field name, or the original if no correction needed
+    """
+    corrections = FIELD_NAME_CORRECTIONS.get(node_type, {})
+    return corrections.get(field, field)
+
+
+# =============================================================================
+# VALIDATION UTILITIES
+# =============================================================================
+
+# Node types that are internal and don't need schemas for LLM generation
+_INTERNAL_NODE_TYPES: set[str] = {
+    # Internal workflow nodes
+    "answer",  # Internal to chatflow
+    "loop",  # Uses iteration internally
+    "assigner",  # Variable assignment utility
+    "variable-assigner",  # Variable assignment utility
+    "agent",  # Agent node (complex, handled separately)
+    "document-extractor",  # Internal document processing
+    "list-operator",  # Internal list operations
+    # Iteration internal nodes
+    "iteration-start",  # Internal to iteration loop
+    "loop-start",  # Internal to loop
+    "loop-end",  # Internal to loop
+    # Trigger nodes (not user-creatable via LLM)
+    "trigger-plugin",  # Plugin trigger
+    "trigger-schedule",  # Scheduled trigger
+    "trigger-webhook",  # Webhook trigger
+    # Other internal nodes
+    "datasource",  # Data source configuration
+    "human-input",  # Human-in-the-loop node
+    "knowledge-index",  # Knowledge indexing node
+}
+
+
+def validate_node_schemas() -> list[str]:
+    """
+    Validate that all registered node types have corresponding schemas.
+
+    This function checks if BUILTIN_NODE_SCHEMAS covers all node types
+    registered in NODE_TYPE_CLASSES_MAPPING, excluding internal node types.
+
+    Returns:
+        List of warning messages for missing schemas (empty if all valid)
+    """
+    from core.workflow.nodes.node_mapping import NODE_TYPE_CLASSES_MAPPING
+
+    schemas = get_builtin_node_schemas()
+    warnings = []
+    for node_type in NODE_TYPE_CLASSES_MAPPING:
+        type_value = node_type.value
+        if type_value in _INTERNAL_NODE_TYPES:
+            continue
+        if type_value not in schemas:
+            warnings.append(f"Missing schema for node type: {type_value}")
+    return warnings

api/core/workflow/generator/config/responses.py

@@ -0,0 +1,72 @@
+"""
+Response Templates for Vibe Workflow Generation.
+
+This module defines templates for off-topic responses and default suggestions
+to guide users back to workflow-related requests.
+"""
+
+# Off-topic response templates for different categories
+# Each category has messages in multiple languages
+OFF_TOPIC_RESPONSES: dict[str, dict[str, str]] = {
+    "weather": {
+        "en": (
+            "I'm the workflow design assistant - I can't check the weather, "
+            "but I can help you build AI workflows! For example, I could help you "
+            "create a workflow that fetches weather data from an API."
+        ),
+        "zh": "我是工作流设计助手，无法查询天气。但我可以帮你创建一个从API获取天气数据的工作流！",
+    },
+    "math": {
+        "en": (
+            "I focus on workflow design rather than calculations. However, "
+            "if you need calculations in a workflow, I can help you add a Code node "
+            "that handles math operations!"
+        ),
+        "zh": "我专注于工作流设计而非计算。但如果您需要在工作流中进行计算，我可以帮您添加一个处理数学运算的代码节点！",
+    },
+    "joke": {
+        "en": (
+            "While I'd love to share a laugh, I'm specialized in workflow design. "
+            "How about we create something fun instead - like a workflow that generates jokes using AI?"
+        ),
+        "zh": "虽然我很想讲笑话，但我专门从事工作流设计。不如我们创建一个有趣的东西——比如使用AI生成笑话的工作流？",
+    },
+    "translation": {
+        "en": (
+            "I can't translate directly, but I can help you build a translation workflow! "
+            "Would you like to create one using an LLM node?"
+        ),
+        "zh": "我不能直接翻译，但我可以帮你构建一个翻译工作流！要创建一个使用LLM节点的翻译流程吗？",
+    },
+    "general_coding": {
+        "en": (
+            "I'm specialized in Dify workflow design rather than general coding help. "
+            "But if you want to add code logic to your workflow, I can help you configure a Code node!"
+        ),
+        "zh": (
+            "我专注于Dify工作流设计，而非通用编程帮助。但如果您想在工作流中添加代码逻辑，我可以帮您配置一个代码节点！"
+        ),
+    },
+    "default": {
+        "en": (
+            "I'm the Dify workflow design assistant. I help create AI automation workflows, "
+            "but I can't help with general questions. Would you like to create a workflow instead?"
+        ),
+        "zh": "我是Dify工作流设计助手。我帮助创建AI自动化工作流，但无法回答一般性问题。您想创建一个工作流吗？",
+    },
+}
+
+# Default suggestions for off-topic requests
+# These help guide users towards valid workflow requests
+DEFAULT_SUGGESTIONS: dict[str, list[str]] = {
+    "en": [
+        "Create a chatbot workflow",
+        "Build a document summarization pipeline",
+        "Add email notification to workflow",
+    ],
+    "zh": [
+        "创建一个聊天机器人工作流",
+        "构建文档摘要处理流程",
+        "添加邮件通知到工作流",
+    ],
+}

api/core/workflow/generator/prompts/builder_prompts.py

@@ -0,0 +1,733 @@
+# =============================================================================
+# NEW FORMAT: depends_on based prompt (for use with GraphBuilder)
+# =============================================================================
+
+BUILDER_SYSTEM_PROMPT_V2 = """<role>
+You are a Workflow Configuration Engineer.
+Your goal is to generate workflow node configurations with dependency declarations.
+The graph structure (edges, start/end nodes) will be automatically built from your output.
+</role>
+
+<language_rules>
+- Detect the language of the user's request automatically (e.g., English, Chinese, Japanese, etc.).
+- Generate ALL node titles, descriptions, and user-facing text in the SAME language as the user's input.
+- If the input language is ambiguous or cannot be determined (e.g. code-only input),
+  use {preferred_language} as the target language.
+</language_rules>
+
+<inputs>
+<plan>
+{plan_context}
+</plan>
+
+<tool_schemas>
+{tool_schemas}
+</tool_schemas>
+
+<node_specs>
+{builtin_node_specs}
+</node_specs>
+
+<available_models>
+{available_models}
+</available_models>
+
+<workflow_context>
+  <existing_nodes>
+{existing_nodes_context}
+  </existing_nodes>
+  <selected_nodes>
+{selected_nodes_context}
+  </selected_nodes>
+</workflow_context>
+</inputs>
+
+<critical_rules>
+1. **DO NOT generate start or end nodes** - they are automatically added
+2. **DO NOT generate edges** - they are automatically built from depends_on
+3. **Use depends_on array** to declare which nodes must run before this one
+4. **Leave depends_on empty []** for nodes that should start immediately (connect to start)
+</critical_rules>
+
+<rules>
+1. **Configuration**:
+   - You MUST fill ALL required parameters for every node.
+   - Use `{{{{#node_id.field#}}}}` syntax to reference outputs from previous nodes in text fields.
+
+2. **Dependency Declaration**:
+   - Each node has a `depends_on` array listing node IDs that must complete before it runs
+   - Empty depends_on `[]` means the node runs immediately after start
+   - Example: `"depends_on": ["fetch_data"]` means this node waits for fetch_data to complete
+
+3. **Variable References**:
+   - For text fields (like prompts, queries): use string format `{{{{#node_id.field#}}}}`
+   - Dependencies will be auto-inferred from variable references if not explicitly declared
+
+4. **Tools**:
+   - ONLY use the tools listed in `<tool_schemas>`.
+   - If a planned tool is missing from schemas, fallback to `http-request` or `code`.
+
+5. **Model Selection** (CRITICAL):
+   - For LLM, question-classifier, and parameter-extractor nodes, you MUST include a "model" config.
+   - You MUST use ONLY models from the `<available_models>` section above.
+   - Copy the EXACT provider and name values from available_models.
+   - NEVER use openai/gpt-4o, gpt-3.5-turbo, gpt-4, or any other models unless they appear in available_models.
+   - If available_models is empty or shows "No models configured", omit the model config entirely.
+
+6. **if-else Branching**:
+   - Add `true_branch` and `false_branch` in config to specify target node IDs
+   - Example: `"config": {{"cases": [...], "true_branch": "success_node", "false_branch": "fallback_node"}}`
+
+7. **question-classifier Branching**:
+   - Add `target` field to each class in the classes array
+   - Example: `"classes": [{{"id": "tech", "name": "Tech", "target": "tech_handler"}}, ...]`
+
+8. **Node Specifics**:
+   - For `if-else` comparison_operator, use literal symbols: `≥`, `≤`, `=`, `≠` (NOT `>=` or `==`).
+</rules>
+
+<output_format>
+Return ONLY a JSON object with a `nodes` array. Each node has:
+- id: unique identifier
+- type: node type
+- title: display name
+- config: node configuration
+- depends_on: array of node IDs this depends on
+
+```json
+{{{{
+  "nodes": [
+    {{{{
+      "id": "fetch_data",
+      "type": "http-request",
+      "title": "Fetch Data",
+      "config": {{"url": "{{{{#start.url#}}}}", "method": "GET"}},
+      "depends_on": []
+    }}}},
+    {{{{
+      "id": "analyze",
+      "type": "llm",
+      "title": "Analyze",
+      "config": {{"prompt_template": [{{"role": "user", "text": "Analyze: {{{{#fetch_data.body#}}}}"}}]}},
+      "depends_on": ["fetch_data"]
+    }}}}
+  ]
+}}}}
+```
+</output_format>
+
+<examples>
+<example name="simple_linear">
+```json
+{{{{
+  "nodes": [
+    {{{{
+      "id": "llm",
+      "type": "llm",
+      "title": "Generate Response",
+      "config": {{{{
+        "model": {{"provider": "openai", "name": "gpt-4o", "mode": "chat"}},
+        "prompt_template": [{{"role": "user", "text": "Answer: {{{{#start.query#}}}}"}}]
+      }}}},
+      "depends_on": []
+    }}}}
+  ]
+}}}}
+```
+</example>
+
+<example name="parallel_then_merge">
+```json
+{{{{
+  "nodes": [
+    {{{{
+      "id": "api1",
+      "type": "http-request",
+      "title": "Fetch API 1",
+      "config": {{"url": "https://api1.example.com", "method": "GET"}},
+      "depends_on": []
+    }}}},
+    {{{{
+      "id": "api2",
+      "type": "http-request",
+      "title": "Fetch API 2",
+      "config": {{"url": "https://api2.example.com", "method": "GET"}},
+      "depends_on": []
+    }}}},
+    {{{{
+      "id": "merge",
+      "type": "llm",
+      "title": "Merge Results",
+      "config": {{{{
+        "prompt_template": [{{"role": "user", "text": "Combine: {{{{#api1.body#}}}} and {{{{#api2.body#}}}}"}}]
+      }}}},
+      "depends_on": ["api1", "api2"]
+    }}}}
+  ]
+}}}}
+```
+</example>
+
+<example name="if_else_branching">
+```json
+{{{{
+  "nodes": [
+    {{{{
+      "id": "check",
+      "type": "if-else",
+      "title": "Check Condition",
+      "config": {{{{
+        "cases": [{{{{
+          "case_id": "case_1",
+          "logical_operator": "and",
+          "conditions": [{{{{
+            "variable_selector": ["start", "score"],
+            "comparison_operator": "≥",
+            "value": "60"
+          }}}}]
+        }}}}],
+        "true_branch": "pass_handler",
+        "false_branch": "fail_handler"
+      }}}},
+      "depends_on": []
+    }}}},
+    {{{{
+      "id": "pass_handler",
+      "type": "llm",
+      "title": "Pass Response",
+      "config": {{"prompt_template": [{{"role": "user", "text": "Congratulations!"}}]}},
+      "depends_on": []
+    }}}},
+    {{{{
+      "id": "fail_handler",
+      "type": "llm",
+      "title": "Fail Response",
+      "config": {{"prompt_template": [{{"role": "user", "text": "Try again."}}]}},
+      "depends_on": []
+    }}}}
+  ]
+}}}}
+```
+Note: pass_handler and fail_handler have empty depends_on because their connections come from if-else branches.
+</example>
+
+<example name="question_classifier">
+```json
+{{{{
+  "nodes": [
+    {{{{
+      "id": "classifier",
+      "type": "question-classifier",
+      "title": "Classify Intent",
+      "config": {{{{
+        "model": {{"provider": "openai", "name": "gpt-4o", "mode": "chat"}},
+        "query_variable_selector": ["start", "user_input"],
+        "classes": [
+          {{"id": "tech", "name": "Technical", "target": "tech_handler"}},
+          {{"id": "billing", "name": "Billing", "target": "billing_handler"}},
+          {{"id": "other", "name": "Other", "target": "other_handler"}}
+        ]
+      }}}},
+      "depends_on": []
+    }}}},
+    {{{{
+      "id": "tech_handler",
+      "type": "llm",
+      "title": "Tech Support",
+      "config": {{"prompt_template": [{{"role": "user", "text": "Help with tech: {{{{#start.user_input#}}}}"}}]}},
+      "depends_on": []
+    }}}},
+    {{{{
+      "id": "billing_handler",
+      "type": "llm",
+      "title": "Billing Support",
+      "config": {{"prompt_template": [{{"role": "user", "text": "Help with billing: {{{{#start.user_input#}}}}"}}]}},
+      "depends_on": []
+    }}}},
+    {{{{
+      "id": "other_handler",
+      "type": "llm",
+      "title": "General Support",
+      "config": {{"prompt_template": [{{"role": "user", "text": "General help: {{{{#start.user_input#}}}}"}}]}},
+      "depends_on": []
+    }}}}
+  ]
+}}}}
+```
+Note: Handler nodes have empty depends_on because their connections come from classifier branches.
+</example>
+</examples>
+"""
+
+BUILDER_USER_PROMPT_V2 = """<instruction>
+{instruction}
+</instruction>
+
+Generate the workflow nodes configuration. Remember:
+1. Do NOT generate start or end nodes
+2. Do NOT generate edges - use depends_on instead
+3. For if-else: add true_branch/false_branch in config
+4. For question-classifier: add target to each class
+"""
+
+# =============================================================================
+# LEGACY FORMAT: edges-based prompt (backward compatible)
+# =============================================================================
+
+BUILDER_SYSTEM_PROMPT = """<role>
+You are a Workflow Configuration Engineer.
+Your goal is to implement the Architect's plan by generating a precise, runnable Dify Workflow JSON configuration.
+</role>
+
+<language_rules>
+- Detect the language of the user's request automatically (e.g., English, Chinese, Japanese, etc.).
+- Generate ALL node titles, descriptions, and user-facing text in the SAME language as the user's input.
+- If the input language is ambiguous or cannot be determined (e.g. code-only input),
+  use {preferred_language} as the target language.
+</language_rules>
+
+<inputs>
+<plan>
+{plan_context}
+</plan>
+
+<tool_schemas>
+{tool_schemas}
+</tool_schemas>
+
+<node_specs>
+{builtin_node_specs}
+</node_specs>
+
+<available_models>
+{available_models}
+</available_models>
+
+<workflow_context>
+  <existing_nodes>
+{existing_nodes_context}
+  </existing_nodes>
+  <existing_edges>
+{existing_edges_context}
+  </existing_edges>
+  <selected_nodes>
+{selected_nodes_context}
+  </selected_nodes>
+</workflow_context>
+</inputs>
+
+<rules>
+1. **Configuration**:
+   - You MUST fill ALL required parameters for every node.
+   - Use `{{{{#node_id.field#}}}}` syntax to reference outputs from previous nodes in text fields.
+   - For 'start' node, define all necessary user inputs.
+
+2. **Variable References**:
+   - For text fields (like prompts, queries): use string format `{{{{#node_id.field#}}}}`
+   - For 'end' node outputs: use `value_selector` array format `["node_id", "field"]`
+   - Example: to reference 'llm' node's 'text' output in end node, use `["llm", "text"]`
+
+3. **Tools**:
+   - ONLY use the tools listed in `<tool_schemas>`.
+   - If a planned tool is missing from schemas, fallback to `http-request` or `code`.
+
+4. **Model Selection** (CRITICAL):
+   - For LLM, question-classifier, and parameter-extractor nodes, you MUST include a "model" config.
+   - You MUST use ONLY models from the `<available_models>` section above.
+   - Copy the EXACT provider and name values from available_models.
+   - NEVER use openai/gpt-4o, gpt-3.5-turbo, gpt-4, or any other models unless they appear in available_models.
+   - If available_models is empty or shows "No models configured", omit the model config entirely.
+
+5. **Node Specifics**:
+   - For `if-else` comparison_operator, use literal symbols: `≥`, `≤`, `=`, `≠` (NOT `>=` or `==`).
+
+6. **Modification Mode**:
+   - If `<existing_nodes>` contains nodes, you are MODIFYING an existing workflow.
+   - Keep nodes that are NOT mentioned in the user's instruction UNCHANGED.
+   - Only modify/add/remove nodes that the user explicitly requested.
+   - Preserve node IDs for unchanged nodes to maintain connections.
+   - If user says "add X", append new nodes to existing workflow.
+   - If user says "change Y to Z", only modify that specific node.
+   - If user says "remove X", exclude that node from output.
+   
+   **Edge Modification**:
+   - Use `<existing_edges>` to understand current node connections.
+   - If user mentions "fix edge", "connect", "link", or "add connection",
+     review existing_edges and correct missing/wrong connections.
+   - For multi-branch nodes (if-else, question-classifier),
+     ensure EACH branch has proper sourceHandle (e.g., "true"/"false") and target.
+   - Common edge issues to fix:
+     * Missing edge: Two nodes should connect but don't - add the edge
+     * Wrong target: Edge points to wrong node - update the target
+     * Missing sourceHandle: if-else/classifier branches lack sourceHandle - add "true"/"false"
+     * Disconnected nodes: Node has no incoming or outgoing edges - connect it properly
+   - When modifying edges, ensure logical flow makes sense (start → middle → end).
+   - ALWAYS output complete edges array, even if only modifying one edge.
+   
+   **Validation Feedback** (Automatic Retry):
+   - If `<validation_feedback>` is present, you are RETRYING after validation errors.
+   - Focus ONLY on fixing the specific validation issues mentioned.
+   - Keep everything else from the previous attempt UNCHANGED (preserve node IDs, edges, etc).
+   - Common validation issues and fixes:
+     * "Missing required connection" → Add the missing edge
+     * "Invalid node configuration" → Fix the specific node's config section
+     * "Type mismatch in variable reference" → Correct the variable selector path
+     * "Unknown variable" → Update variable reference to existing output
+   - When fixing, make MINIMAL changes to address each specific error.
+
+7. **Output**:
+   - Return ONLY the JSON object with `nodes` and `edges`.
+   - Do NOT generate Mermaid diagrams.
+   - Do NOT generate explanations.
+</rules>
+
+<edge_rules priority="critical">
+**EDGES ARE CRITICAL** - Every node except 'end' MUST have at least one outgoing edge.
+
+1. **Linear Flow**: Simple source -> target connection
+   ```
+   {{"source": "node_a", "target": "node_b"}}
+   ```
+
+2. **question-classifier Branching**: Each class MUST have a separate edge with `sourceHandle` = class `id`
+   - If you define classes: [{{"id": "cls_refund", "name": "Refund"}}, {{"id": "cls_inquiry", "name": "Inquiry"}}]
+   - You MUST create edges:
+     - {{"source": "classifier", "sourceHandle": "cls_refund", "target": "refund_handler"}}
+     - {{"source": "classifier", "sourceHandle": "cls_inquiry", "target": "inquiry_handler"}}
+
+3. **if-else Branching**: MUST have exactly TWO edges with sourceHandle "true" and "false"
+   - {{"source": "condition", "sourceHandle": "true", "target": "true_branch"}}
+   - {{"source": "condition", "sourceHandle": "false", "target": "false_branch"}}
+
+4. **Branch Convergence**: Multiple branches can connect to same downstream node
+   - Both true_branch and false_branch can connect to the same 'end' node
+
+5. **NEVER leave orphan nodes**: Every node must be connected in the graph
+</edge_rules>
+
+<examples>
+<example name="simple_linear">
+```json
+{{
+  "nodes": [
+    {{
+      "id": "start",
+      "type": "start",
+      "title": "Start",
+      "config": {{
+        "variables": [{{"variable": "query", "label": "Query", "type": "text-input"}}]
+      }}
+    }},
+    {{
+      "id": "llm",
+      "type": "llm",
+      "title": "Generate Response",
+      "config": {{
+        "model": {{"provider": "openai", "name": "gpt-4o", "mode": "chat"}},
+        "prompt_template": [{{"role": "user", "text": "Answer: {{{{#start.query#}}}}"}}]
+      }}
+    }},
+    {{
+      "id": "end",
+      "type": "end",
+      "title": "End",
+      "config": {{
+        "outputs": [
+          {{"variable": "result", "value_selector": ["llm", "text"]}}
+        ]
+      }}
+    }}
+  ],
+  "edges": [
+    {{"source": "start", "target": "llm"}},
+    {{"source": "llm", "target": "end"}}
+  ]
+}}
+```
+</example>
+
+<example name="question_classifier_branching" description="Customer service with intent classification">
+```json
+{{
+  "nodes": [
+    {{
+      "id": "start",
+      "type": "start",
+      "title": "Start",
+      "config": {{
+        "variables": [{{"variable": "user_input", "label": "User Message", "type": "text-input", "required": true}}]
+      }}
+    }},
+    {{
+      "id": "classifier",
+      "type": "question-classifier",
+      "title": "Classify Intent",
+      "config": {{
+        "model": {{"provider": "openai", "name": "gpt-4o", "mode": "chat"}},
+        "query_variable_selector": ["start", "user_input"],
+        "classes": [
+          {{"id": "cls_refund", "name": "Refund Request"}},
+          {{"id": "cls_inquiry", "name": "Product Inquiry"}},
+          {{"id": "cls_complaint", "name": "Complaint"}},
+          {{"id": "cls_other", "name": "Other"}}
+        ],
+        "instruction": "Classify the user's intent"
+      }}
+    }},
+    {{
+      "id": "handle_refund",
+      "type": "llm",
+      "title": "Handle Refund",
+      "config": {{
+        "model": {{"provider": "openai", "name": "gpt-4o", "mode": "chat"}},
+        "prompt_template": [{{"role": "user", "text": "Extract order number and respond: {{{{#start.user_input#}}}}"}}]
+      }}
+    }},
+    {{
+      "id": "handle_inquiry",
+      "type": "llm",
+      "title": "Handle Inquiry",
+      "config": {{
+        "model": {{"provider": "openai", "name": "gpt-4o", "mode": "chat"}},
+        "prompt_template": [{{"role": "user", "text": "Answer product question: {{{{#start.user_input#}}}}"}}]
+      }}
+    }},
+    {{
+      "id": "handle_complaint",
+      "type": "llm",
+      "title": "Handle Complaint",
+      "config": {{
+        "model": {{"provider": "openai", "name": "gpt-4o", "mode": "chat"}},
+        "prompt_template": [{{"role": "user", "text": "Respond with empathy: {{{{#start.user_input#}}}}"}}]
+      }}
+    }},
+    {{
+      "id": "handle_other",
+      "type": "llm",
+      "title": "Handle Other",
+      "config": {{
+        "model": {{"provider": "openai", "name": "gpt-4o", "mode": "chat"}},
+        "prompt_template": [{{"role": "user", "text": "Provide general response: {{{{#start.user_input#}}}}"}}]
+      }}
+    }},
+    {{
+      "id": "end",
+      "type": "end",
+      "title": "End",
+      "config": {{
+        "outputs": [{{"variable": "response", "value_selector": ["handle_refund", "text"]}}]
+      }}
+    }}
+  ],
+  "edges": [
+    {{"source": "start", "target": "classifier"}},
+    {{"source": "classifier", "sourceHandle": "cls_refund", "target": "handle_refund"}},
+    {{"source": "classifier", "sourceHandle": "cls_inquiry", "target": "handle_inquiry"}},
+    {{"source": "classifier", "sourceHandle": "cls_complaint", "target": "handle_complaint"}},
+    {{"source": "classifier", "sourceHandle": "cls_other", "target": "handle_other"}},
+    {{"source": "handle_refund", "target": "end"}},
+    {{"source": "handle_inquiry", "target": "end"}},
+    {{"source": "handle_complaint", "target": "end"}},
+    {{"source": "handle_other", "target": "end"}}
+  ]
+}}
+```
+CRITICAL: Notice that each class id (cls_refund, cls_inquiry, etc.) becomes a sourceHandle in the edges!
+</example>
+
+<example name="if_else_branching" description="Conditional logic with if-else">
+```json
+{{
+  "nodes": [
+    {{
+      "id": "start",
+      "type": "start",
+      "title": "Start",
+      "config": {{
+        "variables": [{{"variable": "years", "label": "Years of Experience", "type": "number", "required": true}}]
+      }}
+    }},
+    {{
+      "id": "check_experience",
+      "type": "if-else",
+      "title": "Check Experience",
+      "config": {{
+        "cases": [
+          {{
+            "case_id": "case_1",
+            "logical_operator": "and",
+            "conditions": [
+              {{
+                "variable_selector": ["start", "years"],
+                "comparison_operator": "≥",
+                "value": "3"
+              }}
+            ]
+          }}
+        ]
+      }}
+    }},
+    {{
+      "id": "qualified",
+      "type": "llm",
+      "title": "Qualified Response",
+      "config": {{
+        "model": {{"provider": "openai", "name": "gpt-4o", "mode": "chat"}},
+        "prompt_template": [{{"role": "user", "text": "Generate qualified candidate response"}}]
+      }}
+    }},
+    {{
+      "id": "not_qualified",
+      "type": "llm",
+      "title": "Not Qualified Response",
+      "config": {{
+        "model": {{"provider": "openai", "name": "gpt-4o", "mode": "chat"}},
+        "prompt_template": [{{"role": "user", "text": "Generate rejection response"}}]
+      }}
+    }},
+    {{
+      "id": "end",
+      "type": "end",
+      "title": "End",
+      "config": {{
+        "outputs": [{{"variable": "result", "value_selector": ["qualified", "text"]}}]
+      }}
+    }}
+  ],
+  "edges": [
+    {{"source": "start", "target": "check_experience"}},
+    {{"source": "check_experience", "sourceHandle": "true", "target": "qualified"}},
+    {{"source": "check_experience", "sourceHandle": "false", "target": "not_qualified"}},
+    {{"source": "qualified", "target": "end"}},
+    {{"source": "not_qualified", "target": "end"}}
+  ]
+}}
+```
+CRITICAL: if-else MUST have exactly two edges with sourceHandle "true" and "false"!
+</example>
+
+<example name="parameter_extractor" description="Extract structured data from text">
+```json
+{{
+  "nodes": [
+    {{
+      "id": "start",
+      "type": "start",
+      "title": "Start",
+      "config": {{
+        "variables": [{{"variable": "resume", "label": "Resume Text", "type": "paragraph", "required": true}}]
+      }}
+    }},
+    {{
+      "id": "extract",
+      "type": "parameter-extractor",
+      "title": "Extract Info",
+      "config": {{
+        "model": {{"provider": "openai", "name": "gpt-4o", "mode": "chat"}},
+        "query": ["start", "resume"],
+        "parameters": [
+          {{"name": "name", "type": "string", "description": "Candidate name", "required": true}},
+          {{"name": "years", "type": "number", "description": "Years of experience", "required": true}},
+          {{"name": "skills", "type": "array[string]", "description": "List of skills", "required": true}}
+        ],
+        "instruction": "Extract candidate information from resume"
+      }}
+    }},
+    {{
+      "id": "process",
+      "type": "llm",
+      "title": "Process Data",
+      "config": {{
+        "model": {{"provider": "openai", "name": "gpt-4o", "mode": "chat"}},
+        "prompt_template": [{{"role": "user", "text": "Name: {{{{#extract.name#}}}}, Years: {{{{#extract.years#}}}}"}}]
+      }}
+    }},
+    {{
+      "id": "end",
+      "type": "end",
+      "title": "End",
+      "config": {{
+        "outputs": [{{"variable": "result", "value_selector": ["process", "text"]}}]
+      }}
+    }}
+  ],
+  "edges": [
+    {{"source": "start", "target": "extract"}},
+    {{"source": "extract", "target": "process"}},
+    {{"source": "process", "target": "end"}}
+  ]
+}}
+```
+</example>
+</examples>
+
+<edge_checklist>
+Before finalizing, verify:
+1. [ ] Every node (except 'end') has at least one outgoing edge
+2. [ ] 'start' node has exactly one outgoing edge
+3. [ ] 'question-classifier' has one edge per class, each with sourceHandle = class id
+4. [ ] 'if-else' has exactly two edges: sourceHandle "true" and sourceHandle "false"
+5. [ ] All branches eventually connect to 'end' (directly or through other nodes)
+6. [ ] No orphan nodes exist (every node is reachable from 'start')
+</edge_checklist>
+"""
+
+BUILDER_USER_PROMPT = """<instruction>
+{instruction}
+</instruction>
+
+Generate the full workflow configuration now. Pay special attention to:
+1. Creating edges for ALL branches of question-classifier and if-else nodes
+2. Using correct sourceHandle values for branching nodes
+3. Ensuring every node is connected in the graph
+"""
+
+
+def format_existing_nodes(nodes: list[dict] | None) -> str:
+    """Format existing workflow nodes for context."""
+    if not nodes:
+        return "No existing nodes in workflow (creating from scratch)."
+
+    lines = []
+    for node in nodes:
+        node_id = node.get("id", "unknown")
+        node_type = node.get("type", "unknown")
+        title = node.get("title", "Untitled")
+        lines.append(f"- [{node_id}] {title} ({node_type})")
+    return "\n".join(lines)
+
+
+def format_selected_nodes(
+    selected_ids: list[str] | None,
+    existing_nodes: list[dict] | None,
+) -> str:
+    """Format selected nodes for modification context."""
+    if not selected_ids:
+        return "No nodes selected (generating new workflow)."
+
+    node_map = {n.get("id"): n for n in (existing_nodes or [])}
+    lines = []
+    for node_id in selected_ids:
+        if node_id in node_map:
+            node = node_map[node_id]
+            lines.append(f"- [{node_id}] {node.get('title', 'Untitled')} ({node.get('type', 'unknown')})")
+        else:
+            lines.append(f"- [{node_id}] (not found in current workflow)")
+    return "\n".join(lines)
+
+
+def format_existing_edges(edges: list[dict] | None) -> str:
+    """Format existing workflow edges to show connections."""
+    if not edges:
+        return "No existing edges (creating new workflow)."
+
+    lines = []
+    for edge in edges:
+        source = edge.get("source", "unknown")
+        target = edge.get("target", "unknown")
+        source_handle = edge.get("sourceHandle", "")
+        if source_handle:
+            lines.append(f"- {source} ({source_handle}) -> {target}")
+        else:
+            lines.append(f"- {source} -> {target}")
+    return "\n".join(lines)

api/core/workflow/generator/prompts/planner_prompts.py

@@ -0,0 +1,75 @@
+PLANNER_SYSTEM_PROMPT = """<role>
+You are an expert Workflow Architect.
+Your job is to analyze user requests and plan a high-level automation workflow.
+</role>
+
+<task>
+1. **Classify Intent**:
+   - Is the user asking to create an automation/workflow? -> Intent: "generate"
+   - Is it general chat/weather/jokes? -> Intent: "off_topic"
+
+2. **Plan Steps** (if intent is "generate"):
+   - Break down the user's goal into logical steps.
+   - For each step, identify if a specific capability/tool is needed.
+   - Select the MOST RELEVANT tools from the available_tools list.
+   - DO NOT configure parameters yet. Just identify the tool.
+
+3. **Output Format**:
+   Return a JSON object.
+</task>
+
+<available_tools>
+{tools_summary}
+</available_tools>
+
+<response_format>
+If intent is "generate":
+```json
+{{
+  "intent": "generate",
+  "plan_thought": "Brief explanation of the plan...",
+  "steps": [
+    {{ "step": 1, "description": "Fetch data from URL", "tool": "http-request" }},
+    {{ "step": 2, "description": "Summarize content", "tool": "llm" }},
+    {{ "step": 3, "description": "Search for info", "tool": "google_search" }}
+  ],
+  "required_tool_keys": ["google_search"] 
+}}
+```
+(Note: 'http-request', 'llm', 'code' are built-in, you don't need to list them in required_tool_keys,
+only external tools)
+
+If intent is "off_topic":
+```json
+{{
+  "intent": "off_topic",
+  "message": "I can only help you build workflows. Try asking me to 'Create a workflow that...'",
+  "suggestions": ["Scrape a website", "Summarize a PDF"]
+}}
+```
+</response_format>
+"""
+
+PLANNER_USER_PROMPT = """<user_request>
+{instruction}
+</user_request>
+"""
+
+
+def format_tools_for_planner(tools: list[dict]) -> str:
+    """Format tools list for planner (Lightweight: Name + Description only)."""
+    if not tools:
+        return "No external tools available."
+
+    lines = []
+    for t in tools:
+        key = t.get("tool_key") or t.get("tool_name")
+        provider = t.get("provider_id") or t.get("provider", "")
+        desc = t.get("tool_description") or t.get("description", "")
+        label = t.get("tool_label") or key
+
+        # Format: - [provider/key] Label: Description
+        full_key = f"{provider}/{key}" if provider else key
+        lines.append(f"- [{full_key}] {label}: {desc}")
+
+    return "\n".join(lines)

api/core/workflow/generator/runner.py

@@ -0,0 +1,349 @@
+import json
+import logging
+import re
+from collections.abc import Sequence
+
+import json_repair
+
+from core.model_manager import ModelManager
+from core.model_runtime.entities.message_entities import SystemPromptMessage, UserPromptMessage
+from core.model_runtime.entities.model_entities import ModelType
+from core.workflow.generator.prompts.builder_prompts import (
+    BUILDER_SYSTEM_PROMPT,
+    BUILDER_SYSTEM_PROMPT_V2,
+    BUILDER_USER_PROMPT,
+    BUILDER_USER_PROMPT_V2,
+    format_existing_edges,
+    format_existing_nodes,
+    format_selected_nodes,
+)
+from core.workflow.generator.prompts.planner_prompts import (
+    PLANNER_SYSTEM_PROMPT,
+    PLANNER_USER_PROMPT,
+    format_tools_for_planner,
+)
+from core.workflow.generator.prompts.vibe_prompts import (
+    format_available_models,
+    format_available_nodes,
+    format_available_tools,
+    parse_vibe_response,
+)
+from core.workflow.generator.utils.graph_builder import CyclicDependencyError, GraphBuilder
+from core.workflow.generator.utils.mermaid_generator import generate_mermaid
+from core.workflow.generator.utils.workflow_validator import ValidationHint, WorkflowValidator
+
+logger = logging.getLogger(__name__)
+
+
+class WorkflowGenerator:
+    """
+    Refactored Vibe Workflow Generator (Planner-Builder Architecture).
+    Extracts Vibe logic from the monolithic LLMGenerator.
+    """
+
+    @classmethod
+    def generate_workflow_flowchart(
+        cls,
+        tenant_id: str,
+        instruction: str,
+        model_config: dict,
+        available_nodes: Sequence[dict[str, object]] | None = None,
+        existing_nodes: Sequence[dict[str, object]] | None = None,
+        existing_edges: Sequence[dict[str, object]] | None = None,
+        available_tools: Sequence[dict[str, object]] | None = None,
+        selected_node_ids: Sequence[str] | None = None,
+        previous_workflow: dict[str, object] | None = None,
+        regenerate_mode: bool = False,
+        preferred_language: str | None = None,
+        available_models: Sequence[dict[str, object]] | None = None,
+        use_graph_builder: bool = False,
+    ):
+        """
+        Generates a Dify Workflow Flowchart from natural language instruction.
+
+        Pipeline:
+        1. Planner: Analyze intent & select tools.
+        2. Context Filter: Filter relevant tools (reduce tokens).
+        3. Builder: Generate node configurations.
+        4. Repair: Fix common node/edge issues (NodeRepair, EdgeRepair).
+        5. Validator: Check for errors & generate friendly hints.
+        6. Renderer: Deterministic Mermaid generation.
+        """
+        model_manager = ModelManager()
+        model_instance = model_manager.get_model_instance(
+            tenant_id=tenant_id,
+            model_type=ModelType.LLM,
+            provider=model_config.get("provider", ""),
+            model=model_config.get("name", ""),
+        )
+        model_parameters = model_config.get("completion_params", {})
+        available_tools_list = list(available_tools) if available_tools else []
+
+        # Check if this is modification mode (user is refining existing workflow)
+        has_existing_nodes = existing_nodes and len(list(existing_nodes)) > 0
+
+        # --- STEP 1: PLANNER (Skip in modification mode) ---
+        if has_existing_nodes:
+            # In modification mode, skip Planner:
+            # - User intent is clear: modify the existing workflow
+            # - Tools are already in use (from existing nodes)
+            # - No need for intent classification or tool selection
+            plan_data = {"intent": "generate", "steps": [], "required_tool_keys": []}
+            filtered_tools = available_tools_list  # Use all available tools
+        else:
+            # In creation mode, run Planner to validate intent and select tools
+            planner_tools_context = format_tools_for_planner(available_tools_list)
+            planner_system = PLANNER_SYSTEM_PROMPT.format(tools_summary=planner_tools_context)
+            planner_user = PLANNER_USER_PROMPT.format(instruction=instruction)
+
+            try:
+                response = model_instance.invoke_llm(
+                    prompt_messages=[
+                        SystemPromptMessage(content=planner_system),
+                        UserPromptMessage(content=planner_user),
+                    ],
+                    model_parameters=model_parameters,
+                    stream=False,
+                )
+                plan_content = response.message.content
+                # Reuse parse_vibe_response logic or simple load
+                plan_data = parse_vibe_response(plan_content)
+            except Exception as e:
+                logger.exception("Planner failed")
+                return {"intent": "error", "error": f"Planning failed: {str(e)}"}
+
+            if plan_data.get("intent") == "off_topic":
+                return {
+                    "intent": "off_topic",
+                    "message": plan_data.get("message", "I can only help with workflow creation."),
+                    "suggestions": plan_data.get("suggestions", []),
+                }
+
+            # --- STEP 2: CONTEXT FILTERING ---
+            required_tools = plan_data.get("required_tool_keys", [])
+
+            filtered_tools = []
+            if required_tools:
+                # Simple linear search (optimized version would use a map)
+                for tool in available_tools_list:
+                    t_key = tool.get("tool_key") or tool.get("tool_name")
+                    provider = tool.get("provider_id") or tool.get("provider")
+                    full_key = f"{provider}/{t_key}" if provider else t_key
+
+                    # Check if this tool is in required list (match either full key or short name)
+                    if t_key in required_tools or full_key in required_tools:
+                        filtered_tools.append(tool)
+            else:
+                # If logic only, no tools needed
+                filtered_tools = []
+
+        # --- STEP 3: BUILDER (with retry loop) ---
+        MAX_GLOBAL_RETRIES = 2  # Total attempts: 1 initial + 1 retry
+
+        workflow_data = None
+        mermaid_code = None
+        all_warnings = []
+        all_fixes = []
+        retry_count = 0
+        validation_hints = []
+
+        for attempt in range(MAX_GLOBAL_RETRIES):
+            retry_count = attempt
+            logger.info("Generation attempt %s/%s", attempt + 1, MAX_GLOBAL_RETRIES)
+
+            # Prepare context
+            tool_schemas = format_available_tools(filtered_tools)
+            node_specs = format_available_nodes(list(available_nodes) if available_nodes else [])
+            existing_nodes_context = format_existing_nodes(list(existing_nodes) if existing_nodes else None)
+            existing_edges_context = format_existing_edges(list(existing_edges) if existing_edges else None)
+            selected_nodes_context = format_selected_nodes(
+                list(selected_node_ids) if selected_node_ids else None, list(existing_nodes) if existing_nodes else None
+            )
+
+            # Build retry context
+            retry_context = ""
+
+            # NOTE: Manual regeneration/refinement mode removed
+            # Only handle automatic retry (validation errors)
+
+            # For automatic retry (validation errors)
+            if attempt > 0 and validation_hints:
+                severe_issues = [h for h in validation_hints if h.severity == "error"]
+                if severe_issues:
+                    retry_context = "\n<validation_feedback>\n"
+                    retry_context += "The previous generation had validation errors:\n"
+                    for idx, hint in enumerate(severe_issues[:5], 1):
+                        retry_context += f"{idx}. {hint.message}\n"
+                    retry_context += "\nPlease fix these specific issues while keeping everything else UNCHANGED.\n"
+                    retry_context += "</validation_feedback>\n"
+
+            # Select prompt version based on use_graph_builder flag
+            if use_graph_builder:
+                builder_system = BUILDER_SYSTEM_PROMPT_V2.format(
+                    plan_context=json.dumps(plan_data.get("steps", []), indent=2),
+                    tool_schemas=tool_schemas,
+                    builtin_node_specs=node_specs,
+                    available_models=format_available_models(list(available_models or [])),
+                    preferred_language=preferred_language or "English",
+                    existing_nodes_context=existing_nodes_context,
+                    selected_nodes_context=selected_nodes_context,
+                )
+                builder_user = BUILDER_USER_PROMPT_V2.format(instruction=instruction) + retry_context
+            else:
+                builder_system = BUILDER_SYSTEM_PROMPT.format(
+                    plan_context=json.dumps(plan_data.get("steps", []), indent=2),
+                    tool_schemas=tool_schemas,
+                    builtin_node_specs=node_specs,
+                    available_models=format_available_models(list(available_models or [])),
+                    preferred_language=preferred_language or "English",
+                    existing_nodes_context=existing_nodes_context,
+                    existing_edges_context=existing_edges_context,
+                    selected_nodes_context=selected_nodes_context,
+                )
+                builder_user = BUILDER_USER_PROMPT.format(instruction=instruction) + retry_context
+
+            try:
+                build_res = model_instance.invoke_llm(
+                    prompt_messages=[
+                        SystemPromptMessage(content=builder_system),
+                        UserPromptMessage(content=builder_user),
+                    ],
+                    model_parameters=model_parameters,
+                    stream=False,
+                )
+                # Builder output is raw JSON nodes/edges
+                build_content = build_res.message.content
+                match = re.search(r"```(?:json)?\s*([\s\S]+?)```", build_content)
+                if match:
+                    build_content = match.group(1)
+
+                workflow_data = json_repair.loads(build_content)
+
+                if "nodes" not in workflow_data:
+                    workflow_data["nodes"] = []
+
+                # --- GraphBuilder Mode: Build graph from depends_on ---
+                if use_graph_builder:
+                    try:
+                        # Extract nodes from LLM output (without start/end)
+                        llm_nodes = workflow_data.get("nodes", [])
+
+                        # Build complete graph with start/end and edges
+                        complete_nodes, edges = GraphBuilder.build_graph(llm_nodes)
+
+                        workflow_data["nodes"] = complete_nodes
+                        workflow_data["edges"] = edges
+
+                        logger.info(
+                            "GraphBuilder: built %d nodes, %d edges from %d LLM nodes",
+                            len(complete_nodes),
+                            len(edges),
+                            len(llm_nodes),
+                        )
+
+                    except CyclicDependencyError as e:
+                        logger.warning("GraphBuilder: cyclic dependency detected: %s", e)
+                        # Add to validation hints for retry
+                        validation_hints.append(
+                            ValidationHint(
+                                node_id="",
+                                field="depends_on",
+                                message=f"Cyclic dependency detected: {e}. Please fix the dependency chain.",
+                                severity="error",
+                            )
+                        )
+                        if attempt == MAX_GLOBAL_RETRIES - 1:
+                            return {
+                                "intent": "error",
+                                "error": "Failed to build workflow: cyclic dependency detected.",
+                            }
+                        continue  # Retry with error feedback
+
+                    except Exception as e:
+                        logger.exception("GraphBuilder failed on attempt %d", attempt + 1)
+                        if attempt == MAX_GLOBAL_RETRIES - 1:
+                            return {"intent": "error", "error": f"Graph building failed: {str(e)}"}
+                        continue
+                else:
+                    # Legacy mode: edges from LLM output
+                    if "edges" not in workflow_data:
+                        workflow_data["edges"] = []
+
+            except Exception as e:
+                logger.exception("Builder failed on attempt %d", attempt + 1)
+                if attempt == MAX_GLOBAL_RETRIES - 1:
+                    return {"intent": "error", "error": f"Building failed: {str(e)}"}
+                continue  # Try again
+
+            # NOTE: NodeRepair and EdgeRepair have been removed.
+            # Validation will detect structural issues, and LLM will fix them on retry.
+            # This is more accurate because LLM understands the workflow context.
+
+            # --- STEP 4: RENDERER (Generate Mermaid early for validation) ---
+            mermaid_code = generate_mermaid(workflow_data)
+
+            # --- STEP 5: VALIDATOR ---
+            is_valid, validation_hints = WorkflowValidator.validate(workflow_data, available_tools_list)
+
+            # --- STEP 6: GRAPH VALIDATION (structural checks using graph algorithms) ---
+            if attempt < MAX_GLOBAL_RETRIES - 1:
+                try:
+                    from core.workflow.generator.utils.graph_validator import GraphValidator
+
+                    graph_result = GraphValidator.validate(workflow_data)
+
+                    if not graph_result.success:
+                        # Convert graph errors to validation hints
+                        for graph_error in graph_result.errors:
+                            validation_hints.append(
+                                ValidationHint(
+                                    node_id=graph_error.node_id,
+                                    field="edges",
+                                    message=f"[Graph] {graph_error.message}",
+                                    severity="error",
+                                )
+                            )
+                        # Also add warnings (dead ends) as hints
+                        for graph_warning in graph_result.warnings:
+                            validation_hints.append(
+                                ValidationHint(
+                                    node_id=graph_warning.node_id,
+                                    field="edges",
+                                    message=f"[Graph] {graph_warning.message}",
+                                    severity="warning",
+                                )
+                            )
+                except Exception as e:
+                    logger.warning("Graph validation error: %s", e)
+            # Collect all validation warnings
+            all_warnings = [h.message for h in validation_hints]
+
+            # Check if we should retry
+            severe_issues = [h for h in validation_hints if h.severity == "error"]
+
+            if not severe_issues or attempt == MAX_GLOBAL_RETRIES - 1:
+                break
+
+            # Has severe errors and retries remaining - continue to next attempt
+
+        # Collect all validation warnings
+        all_warnings = [h.message for h in validation_hints]
+
+        # Add stability warning (as requested by user)
+        stability_warning = "The generated workflow may require debugging."
+        if preferred_language and preferred_language.startswith("zh"):
+            stability_warning = "生成的 Workflow 可能需要调试。"
+        all_warnings.append(stability_warning)
+
+        return {
+            "intent": "generate",
+            "flowchart": mermaid_code,
+            "nodes": workflow_data["nodes"],
+            "edges": workflow_data["edges"],
+            "message": plan_data.get("plan_thought", "Generated workflow based on your request."),
+            "warnings": all_warnings,
+            "tool_recommendations": [],  # Legacy field
+            "error": "",
+            "fixed_issues": all_fixes,  # Track what was auto-fixed
+            "retry_count": retry_count,  # Track how many retries were needed
+        }

api/core/workflow/generator/types.py

@@ -0,0 +1,217 @@
+"""
+Type definitions for Vibe Workflow Generator.
+
+This module provides:
+- TypedDict classes for lightweight type hints (no runtime overhead)
+- Pydantic models for runtime validation where needed
+
+Usage:
+    # For type hints only (no runtime validation):
+    from core.workflow.generator.types import WorkflowNodeDict, WorkflowEdgeDict
+
+    # For runtime validation:
+    from core.workflow.generator.types import WorkflowNode, WorkflowEdge
+"""
+
+from typing import Any, TypedDict
+
+from pydantic import BaseModel, Field
+
+# ============================================================
+# TypedDict definitions (lightweight, for type hints only)
+# ============================================================
+
+
+class WorkflowNodeDict(TypedDict, total=False):
+    """
+    Workflow node structure (TypedDict for hints).
+
+    Attributes:
+        id: Unique node identifier
+        type: Node type (e.g., "start", "end", "llm", "if-else", "http-request")
+        title: Human-readable node title
+        config: Node-specific configuration
+        data: Additional node data
+    """
+
+    id: str
+    type: str
+    title: str
+    config: dict[str, Any]
+    data: dict[str, Any]
+
+
+class WorkflowEdgeDict(TypedDict, total=False):
+    """
+    Workflow edge structure (TypedDict for hints).
+
+    Attributes:
+        source: Source node ID
+        target: Target node ID
+        sourceHandle: Branch handle for if-else/question-classifier nodes
+    """
+
+    source: str
+    target: str
+    sourceHandle: str
+
+
+class AvailableModelDict(TypedDict):
+    """
+    Available model structure.
+
+    Attributes:
+        provider: Model provider (e.g., "openai", "anthropic")
+        model: Model name (e.g., "gpt-4", "claude-3")
+    """
+
+    provider: str
+    model: str
+
+
+class ToolParameterDict(TypedDict, total=False):
+    """
+    Tool parameter structure.
+
+    Attributes:
+        name: Parameter name
+        type: Parameter type (e.g., "string", "number", "boolean")
+        required: Whether parameter is required
+        human_description: Human-readable description
+        llm_description: LLM-oriented description
+        options: Available options for enum-type parameters
+    """
+
+    name: str
+    type: str
+    required: bool
+    human_description: str | dict[str, str]
+    llm_description: str
+    options: list[Any]
+
+
+class AvailableToolDict(TypedDict, total=False):
+    """
+    Available tool structure.
+
+    Attributes:
+        provider_id: Tool provider ID
+        provider: Tool provider name (alternative to provider_id)
+        tool_key: Unique tool key
+        tool_name: Tool name (alternative to tool_key)
+        tool_description: Tool description
+        description: Alternative description field
+        is_team_authorization: Whether tool is configured/authorized
+        parameters: List of tool parameters
+    """
+
+    provider_id: str
+    provider: str
+    tool_key: str
+    tool_name: str
+    tool_description: str
+    description: str
+    is_team_authorization: bool
+    parameters: list[ToolParameterDict]
+
+
+class WorkflowDataDict(TypedDict, total=False):
+    """
+    Complete workflow data structure.
+
+    Attributes:
+        nodes: List of workflow nodes
+        edges: List of workflow edges
+        warnings: List of warning messages
+    """
+
+    nodes: list[WorkflowNodeDict]
+    edges: list[WorkflowEdgeDict]
+    warnings: list[str]
+
+
+# ============================================================
+# Pydantic models (for runtime validation)
+# ============================================================
+
+
+class WorkflowNode(BaseModel):
+    """
+    Workflow node with runtime validation.
+
+    Use this model when you need to validate node data at runtime.
+    For lightweight type hints without validation, use WorkflowNodeDict.
+    """
+
+    id: str
+    type: str
+    title: str = ""
+    config: dict[str, Any] = Field(default_factory=dict)
+    data: dict[str, Any] = Field(default_factory=dict)
+
+
+class WorkflowEdge(BaseModel):
+    """
+    Workflow edge with runtime validation.
+
+    Use this model when you need to validate edge data at runtime.
+    For lightweight type hints without validation, use WorkflowEdgeDict.
+    """
+
+    source: str
+    target: str
+    sourceHandle: str | None = None
+
+
+class AvailableModel(BaseModel):
+    """
+    Available model with runtime validation.
+
+    Use this model when you need to validate model data at runtime.
+    For lightweight type hints without validation, use AvailableModelDict.
+    """
+
+    provider: str
+    model: str
+
+
+class ToolParameter(BaseModel):
+    """Tool parameter with runtime validation."""
+
+    name: str = ""
+    type: str = "string"
+    required: bool = False
+    human_description: str | dict[str, str] = ""
+    llm_description: str = ""
+    options: list[Any] = Field(default_factory=list)
+
+
+class AvailableTool(BaseModel):
+    """
+    Available tool with runtime validation.
+
+    Use this model when you need to validate tool data at runtime.
+    For lightweight type hints without validation, use AvailableToolDict.
+    """
+
+    provider_id: str = ""
+    provider: str = ""
+    tool_key: str = ""
+    tool_name: str = ""
+    tool_description: str = ""
+    description: str = ""
+    is_team_authorization: bool = False
+    parameters: list[ToolParameter] = Field(default_factory=list)
+
+
+class WorkflowData(BaseModel):
+    """
+    Complete workflow data with runtime validation.
+
+    Use this model when you need to validate workflow data at runtime.
+    For lightweight type hints without validation, use WorkflowDataDict.
+    """
+
+    nodes: list[WorkflowNode] = Field(default_factory=list)
+    edges: list[WorkflowEdge] = Field(default_factory=list)
+    warnings: list[str] = Field(default_factory=list)

api/core/workflow/generator/utils/edge_repair.py

@@ -0,0 +1,384 @@
+"""
+Edge Repair Utility for Vibe Workflow Generation.
+
+This module provides intelligent edge repair capabilities for generated workflows.
+It can detect and fix common edge issues:
+- Missing edges between sequential nodes
+- Incomplete branches for question-classifier and if-else nodes
+- Orphaned nodes without connections
+
+The repair logic is deterministic and doesn't require LLM calls.
+"""
+
+import logging
+from dataclasses import dataclass, field
+
+from core.workflow.generator.types import WorkflowDataDict, WorkflowEdgeDict, WorkflowNodeDict
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class RepairResult:
+    """Result of edge repair operation."""
+
+    nodes: list[WorkflowNodeDict]
+    edges: list[WorkflowEdgeDict]
+    repairs_made: list[str] = field(default_factory=list)
+    warnings: list[str] = field(default_factory=list)
+
+    @property
+    def was_repaired(self) -> bool:
+        """Check if any repairs were made."""
+        return len(self.repairs_made) > 0
+
+
+class EdgeRepair:
+    """
+    Intelligent edge repair for workflow graphs.
+
+    Repairs are applied in order:
+    1. Infer linear connections from node order (if no edges exist)
+    2. Add missing branch edges for question-classifier
+    3. Add missing branch edges for if-else
+    4. Connect orphaned nodes
+    """
+
+    @classmethod
+    def repair(cls, workflow_data: WorkflowDataDict) -> RepairResult:
+        """
+        Repair edges in the workflow data.
+
+        Args:
+            workflow_data: Dict containing 'nodes' and 'edges'
+
+        Returns:
+            RepairResult with repaired nodes, edges, and repair logs
+        """
+        nodes = list(workflow_data.get("nodes", []))
+        edges = list(workflow_data.get("edges", []))
+        repairs: list[str] = []
+        warnings: list[str] = []
+
+        logger.info("[EDGE REPAIR] Starting repair process for %s nodes, %s edges", len(nodes), len(edges))
+
+        # Build node lookup
+
+        # Build node lookup
+        node_map = {n.get("id"): n for n in nodes if n.get("id")}
+        node_ids = set(node_map.keys())
+
+        # 1. If no edges at all, infer linear chain
+        if not edges and len(nodes) > 1:
+            edges, inferred_repairs = cls._infer_linear_chain(nodes)
+            repairs.extend(inferred_repairs)
+
+        # 2. Build edge index for analysis
+        outgoing_edges: dict[str, list[WorkflowEdgeDict]] = {}
+        incoming_edges: dict[str, list[WorkflowEdgeDict]] = {}
+        for edge in edges:
+            src = edge.get("source")
+            tgt = edge.get("target")
+            if src:
+                outgoing_edges.setdefault(src, []).append(edge)
+            if tgt:
+                incoming_edges.setdefault(tgt, []).append(edge)
+
+        # 3. Repair question-classifier branches
+        for node in nodes:
+            if node.get("type") == "question-classifier":
+                new_edges, branch_repairs, branch_warnings = cls._repair_classifier_branches(
+                    node, edges, outgoing_edges, node_ids
+                )
+                edges.extend(new_edges)
+                repairs.extend(branch_repairs)
+                warnings.extend(branch_warnings)
+                # Update outgoing index
+                for edge in new_edges:
+                    outgoing_edges.setdefault(edge.get("source"), []).append(edge)
+
+        # 4. Repair if-else branches
+        for node in nodes:
+            if node.get("type") == "if-else":
+                new_edges, branch_repairs, branch_warnings = cls._repair_if_else_branches(
+                    node, edges, outgoing_edges, node_ids
+                )
+                edges.extend(new_edges)
+                repairs.extend(branch_repairs)
+                warnings.extend(branch_warnings)
+                # Update outgoing index
+                for edge in new_edges:
+                    outgoing_edges.setdefault(edge.get("source"), []).append(edge)
+
+        # 5. Connect orphaned nodes (nodes with no incoming edge, except start)
+        new_edges, orphan_repairs = cls._connect_orphaned_nodes(nodes, edges, outgoing_edges, incoming_edges)
+        edges.extend(new_edges)
+        repairs.extend(orphan_repairs)
+
+        # 6. Connect nodes with no outgoing edge to 'end' (except end nodes)
+        new_edges, terminal_repairs = cls._connect_terminal_nodes(nodes, edges, outgoing_edges)
+        edges.extend(new_edges)
+        repairs.extend(terminal_repairs)
+
+        if repairs:
+            logger.info("[EDGE REPAIR] Completed with %s repairs:", len(repairs))
+            for i, repair in enumerate(repairs, 1):
+                logger.info("[EDGE REPAIR]   %s. %s", i, repair)
+        else:
+            logger.info("[EDGE REPAIR] Completed - no repairs needed")
+
+        return RepairResult(
+            nodes=nodes,
+            edges=edges,
+            repairs_made=repairs,
+            warnings=warnings,
+        )
+
+    @classmethod
+    def _infer_linear_chain(cls, nodes: list[WorkflowNodeDict]) -> tuple[list[WorkflowEdgeDict], list[str]]:
+        """
+        Infer a linear chain of edges from node order.
+
+        This is used when no edges are provided at all.
+        """
+        edges: list[WorkflowEdgeDict] = []
+        repairs: list[str] = []
+
+        # Filter to get ordered node IDs
+        node_ids = [n.get("id") for n in nodes if n.get("id")]
+
+        if len(node_ids) < 2:
+            return edges, repairs
+
+        # Create edges between consecutive nodes
+        for i in range(len(node_ids) - 1):
+            src = node_ids[i]
+            tgt = node_ids[i + 1]
+            edges.append({"source": src, "target": tgt})
+            repairs.append(f"Inferred edge: {src} -> {tgt}")
+
+        return edges, repairs
+
+    @classmethod
+    def _repair_classifier_branches(
+        cls,
+        node: WorkflowNodeDict,
+        edges: list[WorkflowEdgeDict],
+        outgoing_edges: dict[str, list[WorkflowEdgeDict]],
+        valid_node_ids: set[str],
+    ) -> tuple[list[WorkflowEdgeDict], list[str], list[str]]:
+        """
+        Repair missing branches for question-classifier nodes.
+
+        For each class that doesn't have an edge, create one pointing to 'end'.
+        """
+        new_edges: list[WorkflowEdgeDict] = []
+        repairs: list[str] = []
+        warnings: list[str] = []
+
+        node_id = node.get("id")
+        if not node_id:
+            return new_edges, repairs, warnings
+
+        config = node.get("config", {})
+        classes = config.get("classes", [])
+
+        if not classes:
+            return new_edges, repairs, warnings
+
+        # Get existing sourceHandles for this node
+        existing_handles = set()
+        for edge in outgoing_edges.get(node_id, []):
+            handle = edge.get("sourceHandle")
+            if handle:
+                existing_handles.add(handle)
+
+        # Find 'end' node as default target
+        end_node_id = "end"
+        if "end" not in valid_node_ids:
+            # Try to find an end node
+            for nid in valid_node_ids:
+                if "end" in nid.lower():
+                    end_node_id = nid
+                    break
+
+        # Add missing branches
+        for cls_def in classes:
+            if not isinstance(cls_def, dict):
+                continue
+            cls_id = cls_def.get("id")
+            cls_name = cls_def.get("name", cls_id)
+
+            if cls_id and cls_id not in existing_handles:
+                new_edge = {
+                    "source": node_id,
+                    "sourceHandle": cls_id,
+                    "target": end_node_id,
+                }
+                new_edges.append(new_edge)
+                repairs.append(f"Added missing branch edge for class '{cls_name}' -> {end_node_id}")
+                warnings.append(
+                    f"Auto-connected question-classifier branch '{cls_name}' to '{end_node_id}'. "
+                    "You may want to redirect this to a specific handler node."
+                )
+
+        return new_edges, repairs, warnings
+
+    @classmethod
+    def _repair_if_else_branches(
+        cls,
+        node: WorkflowNodeDict,
+        edges: list[WorkflowEdgeDict],
+        outgoing_edges: dict[str, list[WorkflowEdgeDict]],
+        valid_node_ids: set[str],
+    ) -> tuple[list[WorkflowEdgeDict], list[str], list[str]]:
+        """
+        Repair missing branches for if-else nodes.
+
+        If-else in Dify uses case_id as sourceHandle for each condition,
+        plus 'false' for the else branch.
+        """
+        new_edges: list[WorkflowEdgeDict] = []
+        repairs: list[str] = []
+        warnings: list[str] = []
+
+        node_id = node.get("id")
+        if not node_id:
+            return new_edges, repairs, warnings
+
+        # Get existing sourceHandles
+        existing_handles = set()
+        for edge in outgoing_edges.get(node_id, []):
+            handle = edge.get("sourceHandle")
+            if handle:
+                existing_handles.add(handle)
+
+        # Find 'end' node as default target
+        end_node_id = "end"
+        if "end" not in valid_node_ids:
+            for nid in valid_node_ids:
+                if "end" in nid.lower():
+                    end_node_id = nid
+                    break
+
+        # Get required branches from config
+        config = node.get("config", {})
+        cases = config.get("cases", [])
+
+        # Build required handles: each case_id + 'false' for else
+        required_branches = set()
+        for case in cases:
+            case_id = case.get("case_id")
+            if case_id:
+                required_branches.add(case_id)
+        required_branches.add("false")  # else branch
+
+        # Add missing branches
+        for branch in required_branches:
+            if branch not in existing_handles:
+                new_edge = {
+                    "source": node_id,
+                    "sourceHandle": branch,
+                    "target": end_node_id,
+                }
+                new_edges.append(new_edge)
+                repairs.append(f"Added missing if-else branch '{branch}' -> {end_node_id}")
+                warnings.append(
+                    f"Auto-connected if-else branch '{branch}' to '{end_node_id}'. "
+                    "You may want to redirect this to a specific handler node."
+                )
+
+        return new_edges, repairs, warnings
+
+    @classmethod
+    def _connect_orphaned_nodes(
+        cls,
+        nodes: list[WorkflowNodeDict],
+        edges: list[WorkflowEdgeDict],
+        outgoing_edges: dict[str, list[WorkflowEdgeDict]],
+        incoming_edges: dict[str, list[WorkflowEdgeDict]],
+    ) -> tuple[list[WorkflowEdgeDict], list[str]]:
+        """
+        Connect orphaned nodes to the previous node in sequence.
+
+        An orphaned node has no incoming edges and is not a 'start' node.
+        """
+        new_edges: list[WorkflowEdgeDict] = []
+        repairs: list[str] = []
+
+        node_ids = [n.get("id") for n in nodes if n.get("id")]
+        node_types = {n.get("id"): n.get("type") for n in nodes}
+
+        for i, node_id in enumerate(node_ids):
+            node_type = node_types.get(node_id)
+
+            # Skip start nodes - they don't need incoming edges
+            if node_type == "start":
+                continue
+
+            # Check if node has incoming edges
+            if node_id not in incoming_edges or not incoming_edges[node_id]:
+                # Find previous node to connect from
+                if i > 0:
+                    prev_node_id = node_ids[i - 1]
+                    new_edge = {"source": prev_node_id, "target": node_id}
+                    new_edges.append(new_edge)
+                    repairs.append(f"Connected orphaned node: {prev_node_id} -> {node_id}")
+
+                    # Update incoming_edges for subsequent checks
+                    incoming_edges.setdefault(node_id, []).append(new_edge)
+
+        return new_edges, repairs
+
+    @classmethod
+    def _connect_terminal_nodes(
+        cls,
+        nodes: list[WorkflowNodeDict],
+        edges: list[WorkflowEdgeDict],
+        outgoing_edges: dict[str, list[WorkflowEdgeDict]],
+    ) -> tuple[list[WorkflowEdgeDict], list[str]]:
+        """
+        Connect terminal nodes (no outgoing edges) to 'end'.
+
+        A terminal node has no outgoing edges and is not an 'end' node.
+        This ensures all branches eventually reach 'end'.
+        """
+        new_edges: list[WorkflowEdgeDict] = []
+        repairs: list[str] = []
+
+        # Find end node
+        end_node_id = None
+        node_ids = set()
+        for n in nodes:
+            nid = n.get("id")
+            ntype = n.get("type")
+            if nid:
+                node_ids.add(nid)
+            if ntype == "end":
+                end_node_id = nid
+
+        if not end_node_id:
+            # No end node found, can't connect
+            return new_edges, repairs
+
+        for node in nodes:
+            node_id = node.get("id")
+            node_type = node.get("type")
+
+            # Skip end nodes
+            if node_type == "end":
+                continue
+
+            # Skip nodes that already have outgoing edges
+            if outgoing_edges.get(node_id):
+                continue
+
+            # Connect to end
+            new_edge = {"source": node_id, "target": end_node_id}
+            new_edges.append(new_edge)
+            repairs.append(f"Connected terminal node to end: {node_id} -> {end_node_id}")
+
+            # Update for subsequent checks
+            outgoing_edges.setdefault(node_id, []).append(new_edge)
+
+        return new_edges, repairs

api/core/workflow/generator/utils/graph_builder.py

@@ -0,0 +1,615 @@
+"""
+GraphBuilder: Automatic workflow graph construction from node list.
+
+This module implements the core logic for building complete workflow graphs
+from LLM-generated node lists with dependency declarations.
+
+Key features:
+- Automatic start/end node generation
+- Dependency inference from variable references
+- Topological sorting with cycle detection
+- Special handling for branching nodes (if-else, question-classifier)
+- Silent error recovery where possible
+"""
+
+import json
+import logging
+import re
+import uuid
+from collections import defaultdict
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+# Pattern to match variable references like {{#node_id.field#}}
+VAR_PATTERN = re.compile(r"\{\{#([^.#]+)\.[^#]+#\}\}")
+
+# System variable prefixes to exclude from dependency inference
+SYSTEM_VAR_PREFIXES = {"sys", "start", "env"}
+
+# Node types that have special branching behavior
+BRANCHING_NODE_TYPES = {"if-else", "question-classifier"}
+
+# Container node types (iteration, loop) - these have internal subgraphs
+# but behave as single-input-single-output nodes in the external graph
+CONTAINER_NODE_TYPES = {"iteration", "loop"}
+
+
+class GraphBuildError(Exception):
+    """Raised when graph cannot be built due to unrecoverable errors."""
+
+    pass
+
+
+class CyclicDependencyError(GraphBuildError):
+    """Raised when cyclic dependencies are detected."""
+
+    pass
+
+
+class GraphBuilder:
+    """
+    Builds complete workflow graphs from LLM-generated node lists.
+
+    This class handles the conversion from a simplified node list format
+    (with depends_on declarations) to a full workflow graph with nodes and edges.
+
+    The LLM only needs to generate:
+    - Node configurations with depends_on arrays
+    - Branch targets in config for branching nodes
+
+    The GraphBuilder automatically:
+    - Adds start and end nodes
+    - Generates all edges from dependencies
+    - Infers implicit dependencies from variable references
+    - Handles branching nodes (if-else, question-classifier)
+    - Validates graph structure (no cycles, proper connectivity)
+    """
+
+    @classmethod
+    def build_graph(
+        cls,
+        nodes: list[dict[str, Any]],
+        start_config: dict[str, Any] | None = None,
+        end_config: dict[str, Any] | None = None,
+    ) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
+        """
+        Build a complete workflow graph from a node list.
+
+        Args:
+            nodes: LLM-generated nodes (without start/end)
+            start_config: Optional configuration for start node
+            end_config: Optional configuration for end node
+
+        Returns:
+            Tuple of (complete_nodes, edges) where:
+            - complete_nodes includes start, user nodes, and end
+            - edges contains all connections
+
+        Raises:
+            CyclicDependencyError: If cyclic dependencies are detected
+            GraphBuildError: If graph cannot be built
+        """
+        if not nodes:
+            # Empty node list - create minimal workflow
+            start_node = cls._create_start_node([], start_config)
+            end_node = cls._create_end_node([], end_config)
+            edge = cls._create_edge("start", "end")
+            return [start_node, end_node], [edge]
+
+        # Build node index for quick lookup
+        node_map = {node["id"]: node for node in nodes}
+
+        # Step 1: Extract explicit dependencies from depends_on
+        dependencies = cls._extract_explicit_dependencies(nodes)
+
+        # Step 2: Infer implicit dependencies from variable references
+        dependencies = cls._infer_dependencies_from_variables(nodes, dependencies, node_map)
+
+        # Step 3: Validate and fix dependencies (remove invalid references)
+        dependencies = cls._validate_dependencies(dependencies, node_map)
+
+        # Step 4: Topological sort (detects cycles)
+        sorted_node_ids = cls._topological_sort(nodes, dependencies)
+
+        # Step 5: Generate start node
+        start_node = cls._create_start_node(nodes, start_config)
+
+        # Step 6: Generate edges
+        edges = cls._generate_edges(nodes, sorted_node_ids, dependencies, node_map)
+
+        # Step 7: Find terminal nodes and generate end node
+        terminal_nodes = cls._find_terminal_nodes(nodes, dependencies, node_map)
+        end_node = cls._create_end_node(terminal_nodes, end_config)
+
+        # Step 8: Add edges from terminal nodes to end
+        for terminal_id in terminal_nodes:
+            edges.append(cls._create_edge(terminal_id, "end"))
+
+        # Step 9: Assemble complete node list
+        all_nodes = [start_node, *nodes, end_node]
+
+        return all_nodes, edges
+
+    @classmethod
+    def _extract_explicit_dependencies(
+        cls,
+        nodes: list[dict[str, Any]],
+    ) -> dict[str, list[str]]:
+        """
+        Extract explicit dependencies from depends_on field.
+
+        Args:
+            nodes: List of nodes with optional depends_on field
+
+        Returns:
+            Dictionary mapping node_id -> list of dependency node_ids
+        """
+        dependencies: dict[str, list[str]] = {}
+
+        for node in nodes:
+            node_id = node.get("id", "")
+            depends_on = node.get("depends_on", [])
+
+            # Ensure depends_on is a list
+            if isinstance(depends_on, str):
+                depends_on = [depends_on] if depends_on else []
+            elif not isinstance(depends_on, list):
+                depends_on = []
+
+            dependencies[node_id] = list(depends_on)
+
+        return dependencies
+
+    @classmethod
+    def _infer_dependencies_from_variables(
+        cls,
+        nodes: list[dict[str, Any]],
+        explicit_deps: dict[str, list[str]],
+        node_map: dict[str, dict[str, Any]],
+    ) -> dict[str, list[str]]:
+        """
+        Infer implicit dependencies from variable references in config.
+
+        Scans node configurations for patterns like {{#node_id.field#}}
+        and adds those as dependencies if not already declared.
+
+        Args:
+            nodes: List of nodes
+            explicit_deps: Already extracted explicit dependencies
+            node_map: Map of node_id -> node for validation
+
+        Returns:
+            Updated dependencies dictionary
+        """
+        for node in nodes:
+            node_id = node.get("id", "")
+            config = node.get("config", {})
+
+            # Serialize config to search for variable references
+            try:
+                config_str = json.dumps(config, ensure_ascii=False)
+            except (TypeError, ValueError):
+                continue
+
+            # Find all variable references
+            referenced_nodes = set(VAR_PATTERN.findall(config_str))
+
+            # Filter out system variables
+            referenced_nodes -= SYSTEM_VAR_PREFIXES
+
+            # Ensure node_id exists in dependencies
+            if node_id not in explicit_deps:
+                explicit_deps[node_id] = []
+
+            # Add inferred dependencies
+            for ref in referenced_nodes:
+                # Skip self-references (e.g., loop nodes referencing their own outputs)
+                if ref == node_id:
+                    logger.debug(
+                        "Skipping self-reference: %s -> %s",
+                        node_id,
+                        ref,
+                    )
+                    continue
+
+                if ref in node_map and ref not in explicit_deps[node_id]:
+                    explicit_deps[node_id].append(ref)
+                    logger.debug(
+                        "Inferred dependency: %s -> %s (from variable reference)",
+                        node_id,
+                        ref,
+                    )
+
+        return explicit_deps
+
+    @classmethod
+    def _validate_dependencies(
+        cls,
+        dependencies: dict[str, list[str]],
+        node_map: dict[str, dict[str, Any]],
+    ) -> dict[str, list[str]]:
+        """
+        Validate dependencies and remove invalid references.
+
+        Silent fix: References to non-existent nodes are removed.
+
+        Args:
+            dependencies: Dependencies to validate
+            node_map: Map of valid node IDs
+
+        Returns:
+            Validated dependencies
+        """
+        valid_deps: dict[str, list[str]] = {}
+
+        for node_id, deps in dependencies.items():
+            valid_deps[node_id] = []
+            for dep in deps:
+                if dep in node_map:
+                    valid_deps[node_id].append(dep)
+                else:
+                    logger.warning(
+                        "Removed invalid dependency: %s -> %s (node does not exist)",
+                        node_id,
+                        dep,
+                    )
+
+        return valid_deps
+
+    @classmethod
+    def _topological_sort(
+        cls,
+        nodes: list[dict[str, Any]],
+        dependencies: dict[str, list[str]],
+    ) -> list[str]:
+        """
+        Perform topological sort on nodes based on dependencies.
+
+        Uses Kahn's algorithm for cycle detection.
+
+        Args:
+            nodes: List of nodes
+            dependencies: Dependency graph
+
+        Returns:
+            List of node IDs in topological order
+
+        Raises:
+            CyclicDependencyError: If cyclic dependencies are detected
+        """
+        # Build in-degree map
+        in_degree: dict[str, int] = defaultdict(int)
+        reverse_deps: dict[str, list[str]] = defaultdict(list)
+
+        node_ids = {node["id"] for node in nodes}
+
+        for node_id in node_ids:
+            in_degree[node_id] = 0
+
+        for node_id, deps in dependencies.items():
+            for dep in deps:
+                if dep in node_ids:
+                    in_degree[node_id] += 1
+                    reverse_deps[dep].append(node_id)
+
+        # Start with nodes that have no dependencies
+        queue = [nid for nid in node_ids if in_degree[nid] == 0]
+        sorted_ids: list[str] = []
+
+        while queue:
+            current = queue.pop(0)
+            sorted_ids.append(current)
+
+            for dependent in reverse_deps[current]:
+                in_degree[dependent] -= 1
+                if in_degree[dependent] == 0:
+                    queue.append(dependent)
+
+        # Check for cycles
+        if len(sorted_ids) != len(node_ids):
+            remaining = node_ids - set(sorted_ids)
+            raise CyclicDependencyError(f"Cyclic dependency detected involving nodes: {remaining}")
+
+        return sorted_ids
+
+    @classmethod
+    def _generate_edges(
+        cls,
+        nodes: list[dict[str, Any]],
+        sorted_node_ids: list[str],
+        dependencies: dict[str, list[str]],
+        node_map: dict[str, dict[str, Any]],
+    ) -> list[dict[str, Any]]:
+        """
+        Generate all edges based on dependencies and special node handling.
+
+        Args:
+            nodes: List of nodes
+            sorted_node_ids: Topologically sorted node IDs
+            dependencies: Dependency graph
+            node_map: Map of node_id -> node
+
+        Returns:
+            List of edge dictionaries
+        """
+        edges: list[dict[str, Any]] = []
+        nodes_with_incoming: set[str] = set()
+
+        # Track which nodes have outgoing edges from branching
+        branching_sources: set[str] = set()
+
+        # First pass: Handle branching nodes
+        for node in nodes:
+            node_id = node.get("id", "")
+            node_type = node.get("type", "")
+
+            if node_type == "if-else":
+                branch_edges = cls._handle_if_else_node(node)
+                edges.extend(branch_edges)
+                branching_sources.add(node_id)
+                nodes_with_incoming.update(edge["target"] for edge in branch_edges)
+
+            elif node_type == "question-classifier":
+                branch_edges = cls._handle_question_classifier_node(node)
+                edges.extend(branch_edges)
+                branching_sources.add(node_id)
+                nodes_with_incoming.update(edge["target"] for edge in branch_edges)
+
+        # Second pass: Generate edges from dependencies
+        for node_id in sorted_node_ids:
+            deps = dependencies.get(node_id, [])
+
+            if deps:
+                # Connect from each dependency
+                for dep_id in deps:
+                    dep_node = node_map.get(dep_id, {})
+                    dep_type = dep_node.get("type", "")
+
+                    # Skip if dependency is a branching node (edges handled above)
+                    if dep_type in BRANCHING_NODE_TYPES:
+                        continue
+
+                    edges.append(cls._create_edge(dep_id, node_id))
+                    nodes_with_incoming.add(node_id)
+            else:
+                # No dependencies - connect from start
+                # But skip if this node receives edges from branching nodes
+                if node_id not in nodes_with_incoming:
+                    edges.append(cls._create_edge("start", node_id))
+                    nodes_with_incoming.add(node_id)
+
+        return edges
+
+    @classmethod
+    def _handle_if_else_node(
+        cls,
+        node: dict[str, Any],
+    ) -> list[dict[str, Any]]:
+        """
+        Handle if-else node branching.
+
+        Expects config to contain true_branch and/or false_branch.
+
+        Args:
+            node: If-else node
+
+        Returns:
+            List of branch edges
+        """
+        edges: list[dict[str, Any]] = []
+        node_id = node.get("id", "")
+        config = node.get("config", {})
+
+        true_branch = config.get("true_branch")
+        false_branch = config.get("false_branch")
+
+        if true_branch:
+            edges.append(cls._create_edge(node_id, true_branch, source_handle="true"))
+
+        if false_branch:
+            edges.append(cls._create_edge(node_id, false_branch, source_handle="false"))
+
+        # If no branches specified, log warning
+        if not true_branch and not false_branch:
+            logger.warning(
+                "if-else node %s has no branch targets specified",
+                node_id,
+            )
+
+        return edges
+
+    @classmethod
+    def _handle_question_classifier_node(
+        cls,
+        node: dict[str, Any],
+    ) -> list[dict[str, Any]]:
+        """
+        Handle question-classifier node branching.
+
+        Expects config.classes to contain class definitions with target fields.
+
+        Args:
+            node: Question-classifier node
+
+        Returns:
+            List of branch edges
+        """
+        edges: list[dict[str, Any]] = []
+        node_id = node.get("id", "")
+        config = node.get("config", {})
+        classes = config.get("classes", [])
+
+        if not classes:
+            logger.warning(
+                "question-classifier node %s has no classes defined",
+                node_id,
+            )
+            return edges
+
+        for cls_def in classes:
+            class_id = cls_def.get("id", "")
+            target = cls_def.get("target")
+
+            if target:
+                edges.append(cls._create_edge(node_id, target, source_handle=class_id))
+            else:
+                # Silent fix: Connect to end if no target specified
+                edges.append(cls._create_edge(node_id, "end", source_handle=class_id))
+                logger.debug(
+                    "question-classifier class %s has no target, connecting to end",
+                    class_id,
+                )
+
+        return edges
+
+    @classmethod
+    def _find_terminal_nodes(
+        cls,
+        nodes: list[dict[str, Any]],
+        dependencies: dict[str, list[str]],
+        node_map: dict[str, dict[str, Any]],
+    ) -> list[str]:
+        """
+        Find nodes that should connect to the end node.
+
+        Terminal nodes are those that:
+        - Are not dependencies of any other node
+        - Are not branching nodes (those connect to their branches)
+
+        Args:
+            nodes: List of nodes
+            dependencies: Dependency graph
+            node_map: Map of node_id -> node
+
+        Returns:
+            List of terminal node IDs
+        """
+        # Build set of all nodes that are depended upon
+        depended_upon: set[str] = set()
+        for deps in dependencies.values():
+            depended_upon.update(deps)
+
+        # Also track nodes that are branch targets
+        branch_targets: set[str] = set()
+        branching_nodes: set[str] = set()
+
+        for node in nodes:
+            node_id = node.get("id", "")
+            node_type = node.get("type", "")
+            config = node.get("config", {})
+
+            if node_type == "if-else":
+                branching_nodes.add(node_id)
+                if config.get("true_branch"):
+                    branch_targets.add(config["true_branch"])
+                if config.get("false_branch"):
+                    branch_targets.add(config["false_branch"])
+
+            elif node_type == "question-classifier":
+                branching_nodes.add(node_id)
+                for cls_def in config.get("classes", []):
+                    if cls_def.get("target"):
+                        branch_targets.add(cls_def["target"])
+
+        # Find terminal nodes
+        terminal_nodes: list[str] = []
+        for node in nodes:
+            node_id = node.get("id", "")
+            node_type = node.get("type", "")
+
+            # Skip branching nodes - they don't connect to end directly
+            if node_type in BRANCHING_NODE_TYPES:
+                continue
+
+            # Terminal if not depended upon and not a branch target that leads elsewhere
+            if node_id not in depended_upon:
+                terminal_nodes.append(node_id)
+
+        # If no terminal nodes found (shouldn't happen), use all non-branching nodes
+        if not terminal_nodes:
+            terminal_nodes = [node["id"] for node in nodes if node.get("type") not in BRANCHING_NODE_TYPES]
+            logger.warning("No terminal nodes found, using all non-branching nodes")
+
+        return terminal_nodes
+
+    @classmethod
+    def _create_start_node(
+        cls,
+        nodes: list[dict[str, Any]],
+        config: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """
+        Create a start node.
+
+        Args:
+            nodes: User nodes (for potential config inference)
+            config: Optional start node configuration
+
+        Returns:
+            Start node dictionary
+        """
+        return {
+            "id": "start",
+            "type": "start",
+            "title": "Start",
+            "config": config or {},
+            "data": {},
+        }
+
+    @classmethod
+    def _create_end_node(
+        cls,
+        terminal_nodes: list[str],
+        config: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """
+        Create an end node.
+
+        Args:
+            terminal_nodes: Nodes that will connect to end
+            config: Optional end node configuration
+
+        Returns:
+            End node dictionary
+        """
+        return {
+            "id": "end",
+            "type": "end",
+            "title": "End",
+            "config": config or {},
+            "data": {},
+        }
+
+    @classmethod
+    def _create_edge(
+        cls,
+        source: str,
+        target: str,
+        source_handle: str | None = None,
+    ) -> dict[str, Any]:
+        """
+        Create an edge dictionary.
+
+        Args:
+            source: Source node ID
+            target: Target node ID
+            source_handle: Optional handle for branching (e.g., "true", "false", class_id)
+
+        Returns:
+            Edge dictionary
+        """
+        edge: dict[str, Any] = {
+            "id": f"{source}-{target}-{uuid.uuid4().hex[:8]}",
+            "source": source,
+            "target": target,
+        }
+
+        if source_handle:
+            edge["sourceHandle"] = source_handle
+        else:
+            edge["sourceHandle"] = "source"
+
+        edge["targetHandle"] = "target"
+
+        return edge

api/core/workflow/generator/utils/graph_validator.py

@@ -0,0 +1,280 @@
+"""
+Graph Validator for Workflow Generation
+
+Validates workflow graph structure using graph algorithms:
+- Reachability from start node (BFS)
+- Reachability to end node (reverse BFS)
+- Branch edge validation for if-else and classifier nodes
+"""
+
+import time
+from collections import deque
+from dataclasses import dataclass, field
+
+
+@dataclass
+class GraphError:
+    """Represents a structural error in the workflow graph."""
+
+    node_id: str
+    node_type: str
+    error_type: str  # "unreachable", "dead_end", "cycle", "missing_start", "missing_end"
+    message: str
+
+
+@dataclass
+class GraphValidationResult:
+    """Result of graph validation."""
+
+    success: bool
+    errors: list[GraphError] = field(default_factory=list)
+    warnings: list[GraphError] = field(default_factory=list)
+    execution_time: float = 0.0
+    stats: dict = field(default_factory=dict)
+
+
+class GraphValidator:
+    """
+    Validates workflow graph structure using proper graph algorithms.
+
+    Performs:
+    1. Forward reachability analysis (BFS from start)
+    2. Backward reachability analysis (reverse BFS from end)
+    3. Branch edge validation for if-else and classifier nodes
+    """
+
+    @staticmethod
+    def _build_adjacency(
+        nodes: dict[str, dict], edges: list[dict]
+    ) -> tuple[dict[str, list[str]], dict[str, list[str]]]:
+        """Build forward and reverse adjacency lists from edges."""
+        outgoing: dict[str, list[str]] = {node_id: [] for node_id in nodes}
+        incoming: dict[str, list[str]] = {node_id: [] for node_id in nodes}
+
+        for edge in edges:
+            source = edge.get("source")
+            target = edge.get("target")
+            if source in outgoing and target in incoming:
+                outgoing[source].append(target)
+                incoming[target].append(source)
+
+        return outgoing, incoming
+
+    @staticmethod
+    def _bfs_reachable(start: str, adjacency: dict[str, list[str]]) -> set[str]:
+        """BFS to find all nodes reachable from start node."""
+        if start not in adjacency:
+            return set()
+
+        visited = set()
+        queue = deque([start])
+        visited.add(start)
+
+        while queue:
+            current = queue.popleft()
+            for neighbor in adjacency.get(current, []):
+                if neighbor not in visited:
+                    visited.add(neighbor)
+                    queue.append(neighbor)
+
+        return visited
+
+    @staticmethod
+    def validate(workflow_data: dict) -> GraphValidationResult:
+        """Validate workflow graph structure."""
+        start_time = time.time()
+        errors: list[GraphError] = []
+        warnings: list[GraphError] = []
+
+        nodes_list = workflow_data.get("nodes", [])
+        edges_list = workflow_data.get("edges", [])
+        nodes = {n["id"]: n for n in nodes_list if n.get("id")}
+
+        # Find start and end nodes
+        start_node_id = None
+        end_node_ids = []
+
+        for node_id, node in nodes.items():
+            node_type = node.get("type")
+            if node_type == "start":
+                start_node_id = node_id
+            elif node_type == "end":
+                end_node_ids.append(node_id)
+
+        # Check start node exists
+        if not start_node_id:
+            errors.append(
+                GraphError(
+                    node_id="workflow",
+                    node_type="workflow",
+                    error_type="missing_start",
+                    message="Workflow has no start node",
+                )
+            )
+
+        # Check end node exists
+        if not end_node_ids:
+            errors.append(
+                GraphError(
+                    node_id="workflow",
+                    node_type="workflow",
+                    error_type="missing_end",
+                    message="Workflow has no end node",
+                )
+            )
+
+        # If missing start or end, can't do reachability analysis
+        if not start_node_id or not end_node_ids:
+            execution_time = time.time() - start_time
+            return GraphValidationResult(
+                success=False,
+                errors=errors,
+                warnings=warnings,
+                execution_time=execution_time,
+                stats={"nodes": len(nodes), "edges": len(edges_list)},
+            )
+
+        # Build adjacency lists
+        outgoing, incoming = GraphValidator._build_adjacency(nodes, edges_list)
+
+        # --- FORWARD REACHABILITY: BFS from start ---
+        reachable_from_start = GraphValidator._bfs_reachable(start_node_id, outgoing)
+
+        # Find unreachable nodes
+        unreachable_nodes = set(nodes.keys()) - reachable_from_start
+        for node_id in unreachable_nodes:
+            node = nodes[node_id]
+            errors.append(
+                GraphError(
+                    node_id=node_id,
+                    node_type=node.get("type", "unknown"),
+                    error_type="unreachable",
+                    message=f"Node '{node_id}' is not reachable from start node",
+                )
+            )
+
+        # --- BACKWARD REACHABILITY: Reverse BFS from end nodes ---
+        can_reach_end: set[str] = set()
+        for end_id in end_node_ids:
+            can_reach_end.update(GraphValidator._bfs_reachable(end_id, incoming))
+
+        # Find dead-end nodes (can't reach any end node)
+        dead_end_nodes = set(nodes.keys()) - can_reach_end
+        for node_id in dead_end_nodes:
+            if node_id in unreachable_nodes:
+                continue
+            node = nodes[node_id]
+            warnings.append(
+                GraphError(
+                    node_id=node_id,
+                    node_type=node.get("type", "unknown"),
+                    error_type="dead_end",
+                    message=f"Node '{node_id}' cannot reach any end node (dead end)",
+                )
+            )
+
+        # --- Start node has outgoing edges? ---
+        if not outgoing.get(start_node_id):
+            errors.append(
+                GraphError(
+                    node_id=start_node_id,
+                    node_type="start",
+                    error_type="disconnected",
+                    message="Start node has no outgoing connections",
+                )
+            )
+
+        # --- End nodes have incoming edges? ---
+        for end_id in end_node_ids:
+            if not incoming.get(end_id):
+                errors.append(
+                    GraphError(
+                        node_id=end_id,
+                        node_type="end",
+                        error_type="disconnected",
+                        message="End node has no incoming connections",
+                    )
+                )
+
+        # --- BRANCH EDGE VALIDATION ---
+        edge_handles: dict[str, set[str]] = {}
+        for edge in edges_list:
+            source = edge.get("source")
+            handle = edge.get("sourceHandle", "")
+            if source:
+                if source not in edge_handles:
+                    edge_handles[source] = set()
+                edge_handles[source].add(handle)
+
+        # Check if-else and question-classifier nodes
+        for node_id, node in nodes.items():
+            node_type = node.get("type")
+
+            if node_type == "if-else":
+                handles = edge_handles.get(node_id, set())
+                config = node.get("config", {})
+                cases = config.get("cases", [])
+
+                required_handles = set()
+                for case in cases:
+                    case_id = case.get("case_id")
+                    if case_id:
+                        required_handles.add(case_id)
+                required_handles.add("false")
+
+                missing = required_handles - handles
+                for handle in missing:
+                    errors.append(
+                        GraphError(
+                            node_id=node_id,
+                            node_type=node_type,
+                            error_type="missing_branch",
+                            message=f"If-else node '{node_id}' missing edge for branch '{handle}'",
+                        )
+                    )
+
+            elif node_type == "question-classifier":
+                handles = edge_handles.get(node_id, set())
+                config = node.get("config", {})
+                classes = config.get("classes", [])
+
+                required_handles = set()
+                for cls in classes:
+                    if isinstance(cls, dict):
+                        cls_id = cls.get("id")
+                        if cls_id:
+                            required_handles.add(cls_id)
+
+                missing = required_handles - handles
+                for handle in missing:
+                    cls_name = handle
+                    for cls in classes:
+                        if isinstance(cls, dict) and cls.get("id") == handle:
+                            cls_name = cls.get("name", handle)
+                            break
+                    errors.append(
+                        GraphError(
+                            node_id=node_id,
+                            node_type=node_type,
+                            error_type="missing_branch",
+                            message=f"Classifier '{node_id}' missing edge for class '{cls_name}'",
+                        )
+                    )
+
+        execution_time = time.time() - start_time
+        success = len(errors) == 0
+
+        return GraphValidationResult(
+            success=success,
+            errors=errors,
+            warnings=warnings,
+            execution_time=execution_time,
+            stats={
+                "nodes": len(nodes),
+                "edges": len(edges_list),
+                "reachable_from_start": len(reachable_from_start),
+                "can_reach_end": len(can_reach_end),
+                "unreachable": len(unreachable_nodes),
+                "dead_ends": len(dead_end_nodes - unreachable_nodes),
+            },
+        )

api/core/workflow/generator/utils/mermaid_generator.py

@@ -0,0 +1,113 @@
+import logging
+
+from core.workflow.generator.types import WorkflowDataDict
+
+logger = logging.getLogger(__name__)
+
+
+def generate_mermaid(workflow_data: WorkflowDataDict) -> str:
+    """
+    Generate a Mermaid flowchart from workflow data consisting of nodes and edges.
+
+    Args:
+        workflow_data: Dict containing 'nodes' (list) and 'edges' (list)
+
+    Returns:
+        String containing the Mermaid flowchart syntax
+    """
+    nodes = workflow_data.get("nodes", [])
+    edges = workflow_data.get("edges", [])
+
+    lines = ["flowchart TD"]
+
+    # 1. Define Nodes
+    # Format: node_id["title<br/>type"] or similar
+    # We will use the Vibe Workflow standard format: id["type=TYPE|title=TITLE"]
+    # Or specifically for tool nodes: id["type=tool|title=TITLE|tool=TOOL_KEY"]
+
+    # Map of original IDs to safe Mermaid IDs
+    id_map = {}
+
+    def get_safe_id(original_id: str) -> str:
+        if original_id == "end":
+            return "end_node"
+        if original_id == "subgraph":
+            return "subgraph_node"
+        # Mermaid IDs should be alphanumeric.
+        # If the ID has special chars, we might need to escape or hash, but Vibe usually generates simple IDs.
+        # We'll trust standard IDs but handle the reserved keyword 'end'.
+        return original_id
+
+    for node in nodes:
+        node_id = node.get("id")
+        if not node_id:
+            continue
+
+        safe_id = get_safe_id(node_id)
+        id_map[node_id] = safe_id
+
+        node_type = node.get("type", "unknown")
+        title = node.get("title", "Untitled")
+
+        # Escape quotes in title
+        safe_title = title.replace('"', "'")
+
+        if node_type == "tool":
+            config = node.get("config", {})
+            # Try multiple fields for tool reference
+            tool_ref = (
+                config.get("tool_key")
+                or config.get("tool")
+                or config.get("tool_name")
+                or node.get("tool_name")
+                or "unknown"
+            )
+            node_def = f'{safe_id}["type={node_type}|title={safe_title}|tool={tool_ref}"]'
+        else:
+            node_def = f'{safe_id}["type={node_type}|title={safe_title}"]'
+
+        lines.append(f"  {node_def}")
+
+    # 2. Define Edges
+    # Format: source --> target
+
+    # Track defined nodes to avoid edge errors
+    defined_node_ids = {n.get("id") for n in nodes if n.get("id")}
+
+    for edge in edges:
+        source = edge.get("source")
+        target = edge.get("target")
+
+        # Skip invalid edges
+        if not source or not target:
+            continue
+
+        if source not in defined_node_ids or target not in defined_node_ids:
+            continue
+
+        safe_source = id_map.get(source, source)
+        safe_target = id_map.get(target, target)
+
+        # Handle conditional branches (true/false) if present
+        # In Dify workflow, sourceHandle is often used for this
+        source_handle = edge.get("sourceHandle")
+        label = ""
+
+        if source_handle == "true":
+            label = "|true|"
+        elif source_handle == "false":
+            label = "|false|"
+        elif source_handle and source_handle != "source":
+            # For question-classifier or other multi-path nodes
+            # Clean up handle for display if needed
+            safe_handle = str(source_handle).replace('"', "'")
+            label = f"|{safe_handle}|"
+
+        edge_line = f"  {safe_source} -->{label} {safe_target}"
+        lines.append(edge_line)
+
+    # Start/End nodes are implicitly handled if they are in the 'nodes' list
+    # If not, we might need to add them, but usually the Builder should produce them.
+
+    result = "\n".join(lines)
+    return result

api/core/workflow/generator/utils/node_repair.py

@@ -0,0 +1,304 @@
+"""
+Node Repair Utility for Vibe Workflow Generation.
+
+This module provides intelligent node configuration repair capabilities.
+It can detect and fix common node configuration issues:
+- Invalid comparison operators in if-else nodes (e.g. '>=' -> '≥')
+"""
+
+import copy
+import logging
+import uuid
+from dataclasses import dataclass, field
+
+from core.workflow.generator.types import WorkflowNodeDict
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class NodeRepairResult:
+    """Result of node repair operation."""
+
+    nodes: list[WorkflowNodeDict]
+    repairs_made: list[str] = field(default_factory=list)
+    warnings: list[str] = field(default_factory=list)
+
+    @property
+    def was_repaired(self) -> bool:
+        """Check if any repairs were made."""
+        return len(self.repairs_made) > 0
+
+
+class NodeRepair:
+    """
+    Intelligent node configuration repair.
+    """
+
+    OPERATOR_MAP = {
+        ">=": "≥",
+        "<=": "≤",
+        "!=": "≠",
+        "==": "=",
+    }
+
+    TYPE_MAPPING = {
+        "json": "object",
+        "dict": "object",
+        "dictionary": "object",
+        "float": "number",
+        "int": "number",
+        "integer": "number",
+        "double": "number",
+        "str": "string",
+        "text": "string",
+        "bool": "boolean",
+        "list": "array[object]",
+        "array": "array[object]",
+    }
+
+    _REPAIR_HANDLERS = {
+        "if-else": "_repair_if_else_operators",
+        "variable-aggregator": "_repair_variable_aggregator_variables",
+        "code": "_repair_code_node_config",
+    }
+
+    @classmethod
+    def repair(
+        cls,
+        nodes: list[WorkflowNodeDict],
+        llm_callback=None,
+    ) -> NodeRepairResult:
+        """
+        Repair node configurations.
+
+        Args:
+            nodes: List of node dictionaries
+            llm_callback: Optional callback(node, issue_desc) -> fixed_config_part
+
+        Returns:
+            NodeRepairResult with repaired nodes and logs
+        """
+        # Deep copy to avoid mutating original
+        nodes = copy.deepcopy(nodes)
+        repairs: list[str] = []
+        warnings: list[str] = []
+
+        logger.info("[NODE REPAIR] Starting repair process for %s nodes", len(nodes))
+
+        for node in nodes:
+            node_type = node.get("type")
+
+            # 1. Rule-based repairs
+            handler_name = cls._REPAIR_HANDLERS.get(node_type)
+            if handler_name:
+                handler = getattr(cls, handler_name)
+                # Check if handler accepts llm_callback (inspect signature or just pass generic kwargs?)
+                # Simplest for now: handlers signature: (node, repairs, llm_callback=None)
+                try:
+                    handler(node, repairs, llm_callback=llm_callback)
+                except TypeError:
+                    # Fallback for handlers that don't accept llm_callback yet
+                    handler(node, repairs)
+
+            # Add other node type repairs here as needed
+
+        if repairs:
+            logger.info("[NODE REPAIR] Completed with %s repairs:", len(repairs))
+            for i, repair in enumerate(repairs, 1):
+                logger.info("[NODE REPAIR]   %s. %s", i, repair)
+        else:
+            logger.info("[NODE REPAIR] Completed - no repairs needed")
+
+        return NodeRepairResult(
+            nodes=nodes,
+            repairs_made=repairs,
+            warnings=warnings,
+        )
+
+    @classmethod
+    def _repair_if_else_operators(cls, node: WorkflowNodeDict, repairs: list[str], **kwargs):
+        """
+        Normalize comparison operators in if-else nodes.
+        And ensure 'id' field exists for cases and conditions (frontend requirement).
+        """
+        node_id = node.get("id", "unknown")
+        config = node.get("config", {})
+        cases = config.get("cases", [])
+
+        for case in cases:
+            # Ensure case_id
+            if "case_id" not in case:
+                case["case_id"] = str(uuid.uuid4())
+                repairs.append(f"Generated missing case_id for case in node '{node_id}'")
+
+            conditions = case.get("conditions", [])
+            for condition in conditions:
+                # Ensure condition id
+                if "id" not in condition:
+                    condition["id"] = str(uuid.uuid4())
+                    # Not logging this repair to avoid clutter, as it's a structural fix
+
+                # Ensure value type (LLM might return int/float, but we need str/bool/list)
+                val = condition.get("value")
+                if isinstance(val, (int, float)) and not isinstance(val, bool):
+                    condition["value"] = str(val)
+                    repairs.append(f"Coerced numeric value to string in node '{node_id}'")
+
+                op = condition.get("comparison_operator")
+                if op in cls.OPERATOR_MAP:
+                    new_op = cls.OPERATOR_MAP[op]
+                    condition["comparison_operator"] = new_op
+                    repairs.append(f"Normalized operator '{op}' to '{new_op}' in node '{node_id}'")
+
+    @classmethod
+    def _repair_variable_aggregator_variables(cls, node: WorkflowNodeDict, repairs: list[str]):
+        """
+        Repair variable-aggregator variables format.
+        Converts dict format to list[list[str]] format.
+        Expected: [["node_id", "field"], ["node_id2", "field2"]]
+        May receive: [{"name": "...", "value_selector": ["node_id", "field"]}, ...]
+        """
+        node_id = node.get("id", "unknown")
+        config = node.get("config", {})
+        variables = config.get("variables", [])
+
+        if not variables:
+            return
+
+        repaired = False
+        repaired_variables = []
+
+        for var in variables:
+            if isinstance(var, dict):
+                # Convert dict format to array format
+                value_selector = var.get("value_selector") or var.get("selector") or var.get("path")
+                if isinstance(value_selector, list) and len(value_selector) > 0:
+                    repaired_variables.append(value_selector)
+                    repaired = True
+                else:
+                    # Try to extract from name field - LLM may generate {"name": "node_id.field"}
+                    name = var.get("name")
+                    if isinstance(name, str) and "." in name:
+                        # Try to parse "node_id.field" format
+                        parts = name.split(".", 1)
+                        if len(parts) == 2:
+                            repaired_variables.append([parts[0], parts[1]])
+                            repaired = True
+                        else:
+                            logger.warning(
+                                "Variable aggregator node '%s' has invalid variable format: %s",
+                                node_id,
+                                var,
+                            )
+                            repaired_variables.append([])  # Empty array as fallback
+                    else:
+                        # If no valid selector or name, skip this variable
+                        logger.warning(
+                            "Variable aggregator node '%s' has invalid variable format: %s",
+                            node_id,
+                            var,
+                        )
+                        # Don't add empty array - skip invalid variables
+            elif isinstance(var, list):
+                # Already in correct format
+                repaired_variables.append(var)
+            else:
+                # Unknown format, skip
+                logger.warning("Variable aggregator node '%s' has unknown variable format: %s", node_id, var)
+                # Don't add empty array - skip invalid variables
+
+        if repaired:
+            config["variables"] = repaired_variables
+            repairs.append(f"Repaired variable-aggregator variables format in node '{node_id}'")
+
+    @classmethod
+    def _repair_code_node_config(cls, node: WorkflowNodeDict, repairs: list[str], llm_callback=None):
+        """
+        Repair code node configuration (outputs and variables).
+        1. Outputs: Converts list format to dict format AND normalizes types.
+        2. Variables: Ensures value_selector exists.
+        """
+        node_id = node.get("id", "unknown")
+        config = node.get("config", {})
+
+        if "variables" not in config:
+            config["variables"] = []
+
+        # --- Repair Variables ---
+        variables = config.get("variables")
+        if isinstance(variables, list):
+            for var in variables:
+                if isinstance(var, dict):
+                    # Ensure value_selector exists (frontend crashes if missing)
+                    if "value_selector" not in var:
+                        var["value_selector"] = []
+                        # Not logging trivial repairs
+
+        # --- Repair Outputs ---
+        outputs = config.get("outputs")
+
+        if not outputs:
+            return
+
+        # Helper to normalize type
+        def normalize_type(t: str) -> str:
+            t_lower = str(t).lower()
+            return cls.TYPE_MAPPING.get(t_lower, t)
+
+        # 1. Handle Dict format (Standard) - Check for invalid types
+        if isinstance(outputs, dict):
+            changed = False
+            for var_name, var_config in outputs.items():
+                if isinstance(var_config, dict):
+                    original_type = var_config.get("type")
+                    if original_type:
+                        new_type = normalize_type(original_type)
+                        if new_type != original_type:
+                            var_config["type"] = new_type
+                            changed = True
+                            repairs.append(
+                                f"Normalized type '{original_type}' to '{new_type}' "
+                                f"for var '{var_name}' in node '{node_id}'"
+                            )
+            return
+
+        # 2. Handle List format (Repair needed)
+        if isinstance(outputs, list):
+            new_outputs = {}
+            for item in outputs:
+                if isinstance(item, dict):
+                    var_name = item.get("variable") or item.get("name")
+                    var_type = item.get("type")
+                    if var_name and var_type:
+                        norm_type = normalize_type(var_type)
+                        new_outputs[var_name] = {"type": norm_type}
+                        if norm_type != var_type:
+                            repairs.append(
+                                f"Normalized type '{var_type}' to '{norm_type}' "
+                                f"during list conversion in node '{node_id}'"
+                            )
+
+            if new_outputs:
+                config["outputs"] = new_outputs
+                repairs.append(f"Repaired code node outputs format in node '{node_id}'")
+            else:
+                # Fallback: Try LLM if available
+                if llm_callback:
+                    try:
+                        # Attempt to fix using LLM
+                        fixed_outputs = llm_callback(
+                            node,
+                            "outputs must be a dictionary like {'var_name': {'type': 'string'}}, "
+                            "but got a list or valid conversion failed.",
+                        )
+                        if isinstance(fixed_outputs, dict) and fixed_outputs:
+                            config["outputs"] = fixed_outputs
+                            repairs.append(f"Repaired code node outputs format using LLM in node '{node_id}'")
+                            return
+                    except Exception as e:
+                        logger.warning("LLM fallback repair failed for node '%s': %s", node_id, e)
+
+                # If conversion/LLM failed, set to empty dict
+                config["outputs"] = {}
+                repairs.append(f"Reset invalid code node outputs to empty dict in node '{node_id}'")

api/core/workflow/generator/utils/workflow_validator.py

@@ -0,0 +1,101 @@
+from dataclasses import dataclass
+
+from core.workflow.generator.types import AvailableModelDict, AvailableToolDict, WorkflowDataDict
+from core.workflow.generator.validation.context import ValidationContext
+from core.workflow.generator.validation.engine import ValidationEngine
+from core.workflow.generator.validation.rules import Severity
+
+
+@dataclass
+class ValidationHint:
+    """Legacy compatibility class for validation hints."""
+
+    node_id: str
+    field: str
+    message: str
+    severity: str  # 'error', 'warning'
+    suggestion: str = None
+    node_type: str = None  # Added for test compatibility
+
+    # Alias for potential old code using 'type' instead of 'severity'
+    @property
+    def type(self) -> str:
+        return self.severity
+
+    @property
+    def element_id(self) -> str:
+        return self.node_id
+
+
+FriendlyHint = ValidationHint  # Alias for backward compatibility
+
+
+class WorkflowValidator:
+    """
+    Validates the generated workflow configuration (nodes and edges).
+    Wraps the new ValidationEngine for backward compatibility.
+    """
+
+    @classmethod
+    def validate(
+        cls,
+        workflow_data: WorkflowDataDict,
+        available_tools: list[AvailableToolDict],
+        available_models: list[AvailableModelDict] | None = None,
+    ) -> tuple[bool, list[ValidationHint]]:
+        """
+        Validate workflow data and return validity status and hints.
+
+        Args:
+            workflow_data: Dict containing 'nodes' and 'edges'
+            available_tools: List of available tool configurations
+            available_models: List of available models (added for Vibe compat)
+
+        Returns:
+            Tuple(max_severity_is_not_error, list_of_hints)
+        """
+        nodes = workflow_data.get("nodes", [])
+        edges = workflow_data.get("edges", [])
+
+        # Create context
+        context = ValidationContext(
+            nodes=nodes,
+            edges=edges,
+            available_models=available_models or [],
+            available_tools=available_tools or [],
+        )
+
+        # Run validation engine
+        engine = ValidationEngine()
+        result = engine.validate(context)
+
+        # Convert engine errors to legacy hints
+        hints: list[ValidationHint] = []
+
+        error_count = 0
+        warning_count = 0
+
+        for error in result.all_errors:
+            # Map severity
+            severity = "error" if error.severity == Severity.ERROR else "warning"
+
+            if severity == "error":
+                error_count += 1
+            else:
+                warning_count += 1
+
+            # Map field from message or details if possible (heuristic)
+            field_name = error.details.get("field", "unknown")
+
+            hints.append(
+                ValidationHint(
+                    node_id=error.node_id,
+                    field=field_name,
+                    message=error.message,
+                    severity=severity,
+                    suggestion=error.fix_hint,
+                    node_type=error.node_type,
+                )
+            )
+
+        return result.is_valid, hints

api/core/workflow/generator/validation/__init__.py

@@ -0,0 +1,42 @@
+"""
+Validation Rule Engine for Vibe Workflow Generation.
+
+This module provides a declarative, schema-based validation system for
+generated workflow nodes. It classifies errors into fixable (LLM can auto-fix)
+and user-required (needs manual intervention) categories.
+
+Usage:
+    from core.workflow.generator.validation import ValidationEngine, ValidationContext
+
+    context = ValidationContext(
+        available_models=[...],
+        available_tools=[...],
+        nodes=[...],
+        edges=[...],
+    )
+    engine = ValidationEngine()
+    result = engine.validate(context)
+
+    # Access classified errors
+    fixable_errors = result.fixable_errors
+    user_required_errors = result.user_required_errors
+"""
+
+from core.workflow.generator.validation.context import ValidationContext
+from core.workflow.generator.validation.engine import ValidationEngine, ValidationResult
+from core.workflow.generator.validation.rules import (
+    RuleCategory,
+    Severity,
+    ValidationError,
+    ValidationRule,
+)
+
+__all__ = [
+    "RuleCategory",
+    "Severity",
+    "ValidationContext",
+    "ValidationEngine",
+    "ValidationError",
+    "ValidationResult",
+    "ValidationRule",
+]

api/core/workflow/generator/validation/context.py

@@ -0,0 +1,115 @@
+"""
+Validation Context for the Rule Engine.
+
+The ValidationContext holds all the data needed for validation:
+- Generated nodes and edges
+- Available models, tools, and datasets
+- Node output schemas for variable reference validation
+"""
+
+from dataclasses import dataclass, field
+
+from core.workflow.generator.types import (
+    AvailableModelDict,
+    AvailableToolDict,
+    WorkflowEdgeDict,
+    WorkflowNodeDict,
+)
+
+
+@dataclass
+class ValidationContext:
+    """
+    Context object containing all data needed for validation.
+
+    This is passed to each validation rule, providing access to:
+    - The nodes being validated
+    - Edge connections between nodes
+    - Available external resources (models, tools)
+    """
+
+    # Generated workflow data
+    nodes: list[WorkflowNodeDict] = field(default_factory=list)
+    edges: list[WorkflowEdgeDict] = field(default_factory=list)
+
+    # Available external resources
+    available_models: list[AvailableModelDict] = field(default_factory=list)
+    available_tools: list[AvailableToolDict] = field(default_factory=list)
+
+    # Cached lookups (populated lazily)
+    _node_map: dict[str, WorkflowNodeDict] | None = field(default=None, repr=False)
+    _model_set: set[tuple[str, str]] | None = field(default=None, repr=False)
+    _tool_set: set[str] | None = field(default=None, repr=False)
+    _configured_tool_set: set[str] | None = field(default=None, repr=False)
+
+    @property
+    def node_map(self) -> dict[str, WorkflowNodeDict]:
+        """Get a map of node_id -> node for quick lookup."""
+        if self._node_map is None:
+            self._node_map = {node.get("id", ""): node for node in self.nodes}
+        return self._node_map
+
+    @property
+    def model_set(self) -> set[tuple[str, str]]:
+        """Get a set of (provider, model_name) tuples for quick lookup."""
+        if self._model_set is None:
+            self._model_set = {(m.get("provider", ""), m.get("model", "")) for m in self.available_models}
+        return self._model_set
+
+    @property
+    def tool_set(self) -> set[str]:
+        """Get a set of all tool keys (both configured and unconfigured)."""
+        if self._tool_set is None:
+            self._tool_set = set()
+            for tool in self.available_tools:
+                provider = tool.get("provider_id") or tool.get("provider", "")
+                tool_key = tool.get("tool_key") or tool.get("tool_name", "")
+                if provider and tool_key:
+                    self._tool_set.add(f"{provider}/{tool_key}")
+                if tool_key:
+                    self._tool_set.add(tool_key)
+        return self._tool_set
+
+    @property
+    def configured_tool_set(self) -> set[str]:
+        """Get a set of configured (authorized) tool keys."""
+        if self._configured_tool_set is None:
+            self._configured_tool_set = set()
+            for tool in self.available_tools:
+                if not tool.get("is_team_authorization", False):
+                    continue
+                provider = tool.get("provider_id") or tool.get("provider", "")
+                tool_key = tool.get("tool_key") or tool.get("tool_name", "")
+                if provider and tool_key:
+                    self._configured_tool_set.add(f"{provider}/{tool_key}")
+                if tool_key:
+                    self._configured_tool_set.add(tool_key)
+        return self._configured_tool_set
+
+    def has_model(self, provider: str, model_name: str) -> bool:
+        """Check if a model is available."""
+        return (provider, model_name) in self.model_set
+
+    def has_tool(self, tool_key: str) -> bool:
+        """Check if a tool exists (configured or not)."""
+        return tool_key in self.tool_set
+
+    def is_tool_configured(self, tool_key: str) -> bool:
+        """Check if a tool is configured and ready to use."""
+        return tool_key in self.configured_tool_set
+
+    def get_node(self, node_id: str) -> WorkflowNodeDict | None:
+        """Get a node by its ID."""
+        return self.node_map.get(node_id)
+
+    def get_node_ids(self) -> set[str]:
+        """Get all node IDs in the workflow."""
+        return set(self.node_map.keys())
+
+    def get_upstream_nodes(self, node_id: str) -> list[str]:
+        """Get IDs of nodes that connect to this node (upstream)."""
+        return [edge.get("source", "") for edge in self.edges if edge.get("target") == node_id]
+
+    def get_downstream_nodes(self, node_id: str) -> list[str]:
+        """Get IDs of nodes that this node connects to (downstream)."""
+        return [edge.get("target", "") for edge in self.edges if edge.get("source") == node_id]

api/core/workflow/generator/validation/engine.py

@@ -0,0 +1,260 @@
+"""
+Validation Engine - Core validation logic.
+
+The ValidationEngine orchestrates rule execution and aggregates results.
+It provides a clean interface for validating workflow nodes.
+"""
+
+import logging
+from dataclasses import dataclass, field
+from typing import Any
+
+from core.workflow.generator.types import (
+    AvailableModelDict,
+    AvailableToolDict,
+    WorkflowEdgeDict,
+    WorkflowNodeDict,
+)
+from core.workflow.generator.validation.context import ValidationContext
+from core.workflow.generator.validation.rules import (
+    RuleCategory,
+    Severity,
+    ValidationError,
+    get_registry,
+)
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ValidationResult:
+    """
+    Result of validation containing all errors classified by fixability.
+
+    Attributes:
+        all_errors: All validation errors found
+        fixable_errors: Errors that LLM can automatically fix
+        user_required_errors: Errors that require user intervention
+        warnings: Non-blocking warnings
+        stats: Validation statistics
+    """
+
+    all_errors: list[ValidationError] = field(default_factory=list)
+    fixable_errors: list[ValidationError] = field(default_factory=list)
+    user_required_errors: list[ValidationError] = field(default_factory=list)
+    warnings: list[ValidationError] = field(default_factory=list)
+    stats: dict[str, int] = field(default_factory=dict)
+
+    @property
+    def has_errors(self) -> bool:
+        """Check if there are any errors (excluding warnings)."""
+        return len(self.fixable_errors) > 0 or len(self.user_required_errors) > 0
+
+    @property
+    def has_fixable_errors(self) -> bool:
+        """Check if there are fixable errors."""
+        return len(self.fixable_errors) > 0
+
+    @property
+    def is_valid(self) -> bool:
+        """Check if validation passed (no errors, warnings are OK)."""
+        return not self.has_errors
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary for API response."""
+        return {
+            "fixable": [e.to_dict() for e in self.fixable_errors],
+            "user_required": [e.to_dict() for e in self.user_required_errors],
+            "warnings": [e.to_dict() for e in self.warnings],
+            "all_warnings": [e.message for e in self.all_errors],
+            "stats": self.stats,
+        }
+
+    def get_error_messages(self) -> list[str]:
+        """Get all error messages as strings."""
+        return [e.message for e in self.all_errors]
+
+    def get_fixable_by_node(self) -> dict[str, list[ValidationError]]:
+        """Group fixable errors by node ID."""
+        result: dict[str, list[ValidationError]] = {}
+        for error in self.fixable_errors:
+            if error.node_id not in result:
+                result[error.node_id] = []
+            result[error.node_id].append(error)
+        return result
+
+
+class ValidationEngine:
+    """
+    The main validation engine.
+
+    Usage:
+        engine = ValidationEngine()
+        context = ValidationContext(nodes=[...], available_models=[...])
+        result = engine.validate(context)
+    """
+
+    def __init__(self):
+        self._registry = get_registry()
+
+    def validate(self, context: ValidationContext) -> ValidationResult:
+        """
+        Validate all nodes in the context.
+
+        Args:
+            context: ValidationContext with nodes, edges, and available resources
+
+        Returns:
+            ValidationResult with classified errors
+        """
+        result = ValidationResult()
+        stats = {
+            "total_nodes": len(context.nodes),
+            "total_rules_checked": 0,
+            "total_errors": 0,
+            "fixable_count": 0,
+            "user_required_count": 0,
+            "warning_count": 0,
+        }
+
+        # Validate each node
+        for node in context.nodes:
+            node_type = node.get("type", "unknown")
+            node_id = node.get("id", "unknown")
+
+            # Get applicable rules for this node type
+            rules = self._registry.get_rules_for_node(node_type)
+
+            for rule in rules:
+                stats["total_rules_checked"] += 1
+
+                try:
+                    errors = rule.check(node, context)
+                    for error in errors:
+                        result.all_errors.append(error)
+                        stats["total_errors"] += 1
+
+                        # Classify by severity and fixability
+                        if error.severity == Severity.WARNING:
+                            result.warnings.append(error)
+                            stats["warning_count"] += 1
+                        elif error.is_fixable:
+                            result.fixable_errors.append(error)
+                            stats["fixable_count"] += 1
+                        else:
+                            result.user_required_errors.append(error)
+                            stats["user_required_count"] += 1
+
+                except Exception:
+                    logger.exception(
+                        "Rule '%s' failed for node '%s'",
+                        rule.id,
+                        node_id,
+                    )
+                    # Don't let a rule failure break the entire validation
+                    continue
+
+        # Validate edges separately
+        edge_errors = self._validate_edges(context)
+        for error in edge_errors:
+            result.all_errors.append(error)
+            stats["total_errors"] += 1
+            if error.is_fixable:
+                result.fixable_errors.append(error)
+                stats["fixable_count"] += 1
+            else:
+                result.user_required_errors.append(error)
+                stats["user_required_count"] += 1
+
+        result.stats = stats
+
+        return result
+
+    def _validate_edges(self, context: ValidationContext) -> list[ValidationError]:
+        """Validate edge connections."""
+        errors: list[ValidationError] = []
+        valid_node_ids = context.get_node_ids()
+
+        for edge in context.edges:
+            source = edge.get("source", "")
+            target = edge.get("target", "")
+
+            if source and source not in valid_node_ids:
+                errors.append(
+                    ValidationError(
+                        rule_id="edge.source.invalid",
+                        node_id=source,
+                        node_type="edge",
+                        category=RuleCategory.SEMANTIC,
+                        severity=Severity.ERROR,
+                        is_fixable=True,
+                        message=f"Edge source '{source}' does not exist",
+                        fix_hint="Update edge to reference existing node",
+                    )
+                )
+
+            if target and target not in valid_node_ids:
+                errors.append(
+                    ValidationError(
+                        rule_id="edge.target.invalid",
+                        node_id=target,
+                        node_type="edge",
+                        category=RuleCategory.SEMANTIC,
+                        severity=Severity.ERROR,
+                        is_fixable=True,
+                        message=f"Edge target '{target}' does not exist",
+                        fix_hint="Update edge to reference existing node",
+                    )
+                )
+
+        return errors
+
+    def validate_single_node(
+        self,
+        node: WorkflowNodeDict,
+        context: ValidationContext,
+    ) -> list[ValidationError]:
+        """
+        Validate a single node.
+
+        Useful for incremental validation when a node is added/modified.
+        """
+        node_type = node.get("type", "unknown")
+        rules = self._registry.get_rules_for_node(node_type)
+
+        errors: list[ValidationError] = []
+        for rule in rules:
+            try:
+                errors.extend(rule.check(node, context))
+            except Exception:
+                logger.exception("Rule '%s' failed", rule.id)
+
+        return errors
+
+
+def validate_nodes(
+    nodes: list[WorkflowNodeDict],
+    edges: list[WorkflowEdgeDict] | None = None,
+    available_models: list[AvailableModelDict] | None = None,
+    available_tools: list[AvailableToolDict] | None = None,
+) -> ValidationResult:
+    """
+    Convenience function to validate nodes without creating engine/context manually.
+
+    Args:
+        nodes: List of workflow nodes to validate
+        edges: Optional list of edges
+        available_models: Optional list of available models
+        available_tools: Optional list of available tools
+
+    Returns:
+        ValidationResult with classified errors
+    """
+    context = ValidationContext(
+        nodes=nodes,
+        edges=edges or [],
+        available_models=available_models or [],
+        available_tools=available_tools or [],
+    )
+    engine = ValidationEngine()
+    return engine.validate(context)

api/core/workflow/generator/validation/rules.py

@@ -0,0 +1,947 @@
+"""
+Validation Rules Definition and Registry.
+
+This module defines:
+- ValidationRule: The rule structure
+- RuleCategory: Categories of validation rules
+- Severity: Error severity levels
+- ValidationError: Error output structure
+- All built-in validation rules
+"""
+
+import re
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import TYPE_CHECKING, Any
+
+from core.workflow.generator.types import WorkflowNodeDict
+
+if TYPE_CHECKING:
+    from core.workflow.generator.validation.context import ValidationContext
+
+
+class RuleCategory(Enum):
+    """Categories of validation rules."""
+
+    STRUCTURE = "structure"  # Field existence, types, formats
+    SEMANTIC = "semantic"  # Variable references, edge connections
+    REFERENCE = "reference"  # External resources (models, tools, datasets)
+
+
+class Severity(Enum):
+    """Severity levels for validation errors."""
+
+    ERROR = "error"  # Must be fixed
+    WARNING = "warning"  # Should be fixed but not blocking
+
+
+@dataclass
+class ValidationError:
+    """
+    Represents a validation error found during rule execution.
+
+    Attributes:
+        rule_id: The ID of the rule that generated this error
+        node_id: The ID of the node with the error
+        node_type: The type of the node
+        category: The rule category
+        severity: Error severity
+        is_fixable: Whether LLM can auto-fix this error
+        message: Human-readable error message
+        fix_hint: Hint for LLM to fix the error
+        details: Additional error details
+    """
+
+    rule_id: str
+    node_id: str
+    node_type: str
+    category: RuleCategory
+    severity: Severity
+    is_fixable: bool
+    message: str
+    fix_hint: str = ""
+    details: dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary for API response."""
+        return {
+            "rule_id": self.rule_id,
+            "node_id": self.node_id,
+            "node_type": self.node_type,
+            "category": self.category.value,
+            "severity": self.severity.value,
+            "is_fixable": self.is_fixable,
+            "message": self.message,
+            "fix_hint": self.fix_hint,
+            "details": self.details,
+        }
+
+
+# Type alias for rule check functions
+RuleCheckFn = Callable[
+    [WorkflowNodeDict, "ValidationContext"],
+    list[ValidationError],
+]
+
+
+@dataclass
+class ValidationRule:
+    """
+    A validation rule definition.
+
+    Attributes:
+        id: Unique rule identifier (e.g., "llm.model.required")
+        node_types: List of node types this rule applies to, or ["*"] for all
+        category: The rule category
+        severity: Default severity for errors from this rule
+        is_fixable: Whether errors from this rule can be auto-fixed by LLM
+        check: The validation function
+        description: Human-readable description of what this rule checks
+        fix_hint: Default hint for fixing errors from this rule
+    """
+
+    id: str
+    node_types: list[str]
+    category: RuleCategory
+    severity: Severity
+    is_fixable: bool
+    check: RuleCheckFn
+    description: str = ""
+    fix_hint: str = ""
+
+    def applies_to(self, node_type: str) -> bool:
+        """Check if this rule applies to a given node type."""
+        return "*" in self.node_types or node_type in self.node_types
+
+
+# =============================================================================
+# Rule Registry
+# =============================================================================
+
+
+class RuleRegistry:
+    """
+    Registry for validation rules.
+
+    Rules are registered here and can be retrieved by category or node type.
+    """
+
+    def __init__(self):
+        self._rules: list[ValidationRule] = []
+
+    def register(self, rule: ValidationRule) -> None:
+        """Register a validation rule."""
+        self._rules.append(rule)
+
+    def get_rules_for_node(self, node_type: str) -> list[ValidationRule]:
+        """Get all rules that apply to a given node type."""
+        return [r for r in self._rules if r.applies_to(node_type)]
+
+    def get_rules_by_category(self, category: RuleCategory) -> list[ValidationRule]:
+        """Get all rules in a given category."""
+        return [r for r in self._rules if r.category == category]
+
+    def get_all_rules(self) -> list[ValidationRule]:
+        """Get all registered rules."""
+        return list(self._rules)
+
+
+# Global rule registry instance
+_registry = RuleRegistry()
+
+
+def register_rule(rule: ValidationRule) -> ValidationRule:
+    """Decorator/function to register a rule with the global registry."""
+    _registry.register(rule)
+    return rule
+
+
+def get_registry() -> RuleRegistry:
+    """Get the global rule registry."""
+    return _registry
+
+
+# =============================================================================
+# Helper Functions for Rule Implementations
+# =============================================================================
+
+# Explicit placeholder value defined in prompt contract
+# See: api/core/workflow/generator/prompts/vibe_prompts.py
+PLACEHOLDER_VALUE = "__PLACEHOLDER__"
+
+# Variable reference pattern: {{#node_id.field#}}
+VARIABLE_REF_PATTERN = re.compile(r"\{\{#([^.#]+)\.([^#]+)#\}\}")
+
+
+def is_placeholder(value: Any) -> bool:
+    """Check if a value appears to be a placeholder."""
+    if not isinstance(value, str):
+        return False
+    return value == PLACEHOLDER_VALUE or PLACEHOLDER_VALUE in value
+
+
+def extract_variable_refs(text: str) -> list[tuple[str, str]]:
+    """
+    Extract variable references from text.
+
+    Returns list of (node_id, field_name) tuples.
+    """
+    return VARIABLE_REF_PATTERN.findall(text)
+
+
+def check_required_field(
+    config: dict[str, Any],
+    field_name: str,
+    node_id: str,
+    node_type: str,
+    rule_id: str,
+    fix_hint: str = "",
+) -> ValidationError | None:
+    """Helper to check if a required field exists and is non-empty."""
+    value = config.get(field_name)
+    if value is None or value == "" or (isinstance(value, list) and len(value) == 0):
+        return ValidationError(
+            rule_id=rule_id,
+            node_id=node_id,
+            node_type=node_type,
+            category=RuleCategory.STRUCTURE,
+            severity=Severity.ERROR,
+            is_fixable=True,
+            message=f"Node '{node_id}': missing required field '{field_name}'",
+            fix_hint=fix_hint or f"Add '{field_name}' to the node config",
+        )
+    return None
+
+
+# =============================================================================
+# Structure Rules - Field existence, types, formats
+# =============================================================================
+
+
+def _check_llm_prompt_template(node: WorkflowNodeDict, ctx: "ValidationContext") -> list[ValidationError]:
+    """Check that LLM node has prompt_template."""
+    errors: list[ValidationError] = []
+    node_id = node.get("id", "unknown")
+    config = node.get("config", {})
+
+    err = check_required_field(
+        config,
+        "prompt_template",
+        node_id,
+        "llm",
+        "llm.prompt_template.required",
+        "Add prompt_template with system and user messages",
+    )
+    if err:
+        errors.append(err)
+
+    return errors
+
+
+def _check_http_request_url(node: WorkflowNodeDict, ctx: "ValidationContext") -> list[ValidationError]:
+    """Check that http-request node has url and method."""
+    errors: list[ValidationError] = []
+    node_id = node.get("id", "unknown")
+    config = node.get("config", {})
+
+    # Check url
+    url = config.get("url", "")
+    if not url:
+        errors.append(
+            ValidationError(
+                rule_id="http.url.required",
+                node_id=node_id,
+                node_type="http-request",
+                category=RuleCategory.STRUCTURE,
+                severity=Severity.ERROR,
+                is_fixable=True,
+                message=f"Node '{node_id}': http-request missing required 'url'",
+                fix_hint="Add url - use {{#start.url#}} or a concrete URL",
+            )
+        )
+    elif is_placeholder(url):
+        errors.append(
+            ValidationError(
+                rule_id="http.url.placeholder",
+                node_id=node_id,
+                node_type="http-request",
+                category=RuleCategory.STRUCTURE,
+                severity=Severity.ERROR,
+                is_fixable=True,
+                message=f"Node '{node_id}': url contains placeholder value",
+                fix_hint="Replace placeholder with actual URL or variable reference",
+            )
+        )
+
+    # Check method
+    method = config.get("method", "")
+    if not method:
+        errors.append(
+            ValidationError(
+                rule_id="http.method.required",
+                node_id=node_id,
+                node_type="http-request",
+                category=RuleCategory.STRUCTURE,
+                severity=Severity.ERROR,
+                is_fixable=True,
+                message=f"Node '{node_id}': http-request missing 'method'",
+                fix_hint="Add method: GET, POST, PUT, DELETE, or PATCH",
+            )
+        )
+
+    return errors
+
+
+def _check_code_node(node: WorkflowNodeDict, ctx: "ValidationContext") -> list[ValidationError]:
+    """Check that code node has code and language."""
+    errors: list[ValidationError] = []
+    node_id = node.get("id", "unknown")
+    config = node.get("config", {})
+
+    err = check_required_field(
+        config,
+        "code",
+        node_id,
+        "code",
+        "code.code.required",
+        "Add code with a main() function that returns a dict",
+    )
+    if err:
+        errors.append(err)
+
+    err = check_required_field(
+        config,
+        "language",
+        node_id,
+        "code",
+        "code.language.required",
+        "Add language: python3 or javascript",
+    )
+    if err:
+        errors.append(err)
+
+    return errors
+
+
+def _check_question_classifier(node: WorkflowNodeDict, ctx: "ValidationContext") -> list[ValidationError]:
+    """Check that question-classifier has classes."""
+    errors: list[ValidationError] = []
+    node_id = node.get("id", "unknown")
+    config = node.get("config", {})
+
+    err = check_required_field(
+        config,
+        "classes",
+        node_id,
+        "question-classifier",
+        "classifier.classes.required",
+        "Add classes array with id and name for each classification",
+    )
+    if err:
+        errors.append(err)
+
+    return errors
+
+
+def _check_parameter_extractor(node: WorkflowNodeDict, ctx: "ValidationContext") -> list[ValidationError]:
+    """Check that parameter-extractor has parameters and instruction."""
+    errors: list[ValidationError] = []
+    node_id = node.get("id", "unknown")
+    config = node.get("config", {})
+
+    err = check_required_field(
+        config,
+        "parameters",
+        node_id,
+        "parameter-extractor",
+        "extractor.parameters.required",
+        "Add parameters array with name, type, description fields",
+    )
+    if err:
+        errors.append(err)
+    else:
+        # Check individual parameters for required fields
+        parameters = config.get("parameters", [])
+        if isinstance(parameters, list):
+            for i, param in enumerate(parameters):
+                if isinstance(param, dict):
+                    # Check for 'required' field (boolean)
+                    if "required" not in param:
+                        errors.append(
+                            ValidationError(
+                                rule_id="extractor.param.required_field.missing",
+                                node_id=node_id,
+                                node_type="parameter-extractor",
+                                category=RuleCategory.STRUCTURE,
+                                severity=Severity.ERROR,
+                                is_fixable=True,
+                                message=f"Node '{node_id}': parameter[{i}] missing 'required' field",
+                                fix_hint=f"Add 'required': True to parameter '{param.get('name', 'unknown')}'",
+                                details={"param_index": i, "param_name": param.get("name")},
+                            )
+                        )
+
+    # instruction is recommended but not strictly required
+    if not config.get("instruction"):
+        errors.append(
+            ValidationError(
+                rule_id="extractor.instruction.recommended",
+                node_id=node_id,
+                node_type="parameter-extractor",
+                category=RuleCategory.STRUCTURE,
+                severity=Severity.WARNING,
+                is_fixable=True,
+                message=f"Node '{node_id}': parameter-extractor should have 'instruction'",
+                fix_hint="Add instruction describing what to extract",
+            )
+        )
+
+    return errors
+
+
+def _check_knowledge_retrieval(node: WorkflowNodeDict, ctx: "ValidationContext") -> list[ValidationError]:
+    """Check that knowledge-retrieval has dataset_ids."""
+    errors: list[ValidationError] = []
+    node_id = node.get("id", "unknown")
+    config = node.get("config", {})
+
+    dataset_ids = config.get("dataset_ids", [])
+    if not dataset_ids:
+        errors.append(
+            ValidationError(
+                rule_id="knowledge.dataset.required",
+                node_id=node_id,
+                node_type="knowledge-retrieval",
+                category=RuleCategory.STRUCTURE,
+                severity=Severity.ERROR,
+                is_fixable=False,  # User must select knowledge base
+                message=f"Node '{node_id}': knowledge-retrieval missing 'dataset_ids'",
+                fix_hint="User must select knowledge bases in the UI",
+            )
+        )
+    else:
+        # Check for placeholder values
+        for ds_id in dataset_ids:
+            if is_placeholder(ds_id):
+                errors.append(
+                    ValidationError(
+                        rule_id="knowledge.dataset.placeholder",
+                        node_id=node_id,
+                        node_type="knowledge-retrieval",
+                        category=RuleCategory.STRUCTURE,
+                        severity=Severity.ERROR,
+                        is_fixable=False,
+                        message=f"Node '{node_id}': dataset_ids contains placeholder",
+                        fix_hint="User must replace placeholder with actual knowledge base ID",
+                        details={"placeholder_value": ds_id},
+                    )
+                )
+                break
+
+    return errors
+
+
+def _check_end_node(node: WorkflowNodeDict, ctx: "ValidationContext") -> list[ValidationError]:
+    """Check that end node has outputs defined."""
+    errors: list[ValidationError] = []
+    node_id = node.get("id", "unknown")
+    config = node.get("config", {})
+
+    outputs = config.get("outputs", [])
+    if not outputs:
+        errors.append(
+            ValidationError(
+                rule_id="end.outputs.recommended",
+                node_id=node_id,
+                node_type="end",
+                category=RuleCategory.STRUCTURE,
+                severity=Severity.WARNING,
+                is_fixable=True,
+                message="End node should define output variables",
+                fix_hint="Add outputs array with variable and value_selector",
+            )
+        )
+
+    return errors
+
+
+# =============================================================================
+# Semantic Rules - Variable references, edge connections
+# =============================================================================
+
+
+def _check_variable_references(node: WorkflowNodeDict, ctx: "ValidationContext") -> list[ValidationError]:
+    """Check that variable references point to valid nodes."""
+    errors: list[ValidationError] = []
+    node_id = node.get("id", "unknown")
+    node_type = node.get("type", "unknown")
+    config = node.get("config", {})
+
+    # Get all valid node IDs (including 'start' which is always valid)
+    valid_node_ids = ctx.get_node_ids()
+    valid_node_ids.add("start")
+    valid_node_ids.add("sys")  # System variables
+
+    def check_text_for_refs(text: str, field_path: str) -> None:
+        if not isinstance(text, str):
+            return
+        refs = extract_variable_refs(text)
+        for ref_node_id, ref_field in refs:
+            if ref_node_id not in valid_node_ids:
+                errors.append(
+                    ValidationError(
+                        rule_id="variable.ref.invalid_node",
+                        node_id=node_id,
+                        node_type=node_type,
+                        category=RuleCategory.SEMANTIC,
+                        severity=Severity.ERROR,
+                        is_fixable=True,
+                        message=f"Node '{node_id}': references non-existent node '{ref_node_id}'",
+                        fix_hint=f"Change {{{{#{ref_node_id}.{ref_field}#}}}} to reference a valid node",
+                        details={"field_path": field_path, "invalid_ref": ref_node_id},
+                    )
+                )
+
+    # Check prompt_template for LLM nodes
+    prompt_template = config.get("prompt_template", [])
+    if isinstance(prompt_template, list):
+        for i, msg in enumerate(prompt_template):
+            if isinstance(msg, dict):
+                text = msg.get("text", "")
+                check_text_for_refs(text, f"prompt_template[{i}].text")
+
+    # Check instruction field
+    instruction = config.get("instruction", "")
+    check_text_for_refs(instruction, "instruction")
+
+    # Check url for http-request
+    url = config.get("url", "")
+    check_text_for_refs(url, "url")
+
+    return errors
+
+
+# NOTE: _check_node_has_outgoing_edge removed - handled by GraphValidator
+
+
+# NOTE: _check_node_has_incoming_edge removed - handled by GraphValidator
+
+
+# NOTE: _check_question_classifier_branches removed - handled by EdgeRepair
+
+
+# NOTE: _check_if_else_branches removed - handled by EdgeRepair
+
+
+def _check_if_else_operators(node: WorkflowNodeDict, ctx: "ValidationContext") -> list[ValidationError]:
+    """Check that if-else comparison operators are valid."""
+    errors: list[ValidationError] = []
+    node_id = node.get("id", "unknown")
+    node_type = node.get("type", "unknown")
+
+    if node_type != "if-else":
+        return errors
+
+    valid_operators = {
+        "contains",
+        "not contains",
+        "start with",
+        "end with",
+        "is",
+        "is not",
+        "empty",
+        "not empty",
+        "in",
+        "not in",
+        "all of",
+        "=",
+        "≠",
+        ">",
+        "<",
+        "≥",
+        "≤",
+        "null",
+        "not null",
+        "exists",
+        "not exists",
+    }
+
+    config = node.get("config", {})
+    cases = config.get("cases", [])
+
+    for case in cases:
+        conditions = case.get("conditions", [])
+        for condition in conditions:
+            op = condition.get("comparison_operator")
+            if op and op not in valid_operators:
+                errors.append(
+                    ValidationError(
+                        rule_id="ifelse.operator.invalid",
+                        node_id=node_id,
+                        node_type=node_type,
+                        category=RuleCategory.SEMANTIC,
+                        severity=Severity.ERROR,
+                        is_fixable=True,
+                        message=f"Invalid operator '{op}' in if-else node",
+                        fix_hint=f"Use one of: {', '.join(sorted(valid_operators))}",
+                        details={"invalid_operator": op, "field": "config.cases.conditions.comparison_operator"},
+                    )
+                )
+
+    return errors
+
+
+def _check_edge_targets_exist(node: WorkflowNodeDict, ctx: "ValidationContext") -> list[ValidationError]:
+    """Check that edge targets reference existing nodes."""
+    errors: list[ValidationError] = []
+    node_id = node.get("id", "unknown")
+    node_type = node.get("type", "unknown")
+
+    valid_node_ids = ctx.get_node_ids()
+
+    # Check all outgoing edges from this node
+    for edge in ctx.edges:
+        if edge.get("source") == node_id:
+            target = edge.get("target")
+            if target and target not in valid_node_ids:
+                errors.append(
+                    ValidationError(
+                        rule_id="edge.target.invalid",
+                        node_id=node_id,
+                        node_type=node_type,
+                        category=RuleCategory.SEMANTIC,
+                        severity=Severity.ERROR,
+                        is_fixable=True,
+                        message=f"Edge from '{node_id}' targets non-existent node '{target}'",
+                        fix_hint=f"Change edge target from '{target}' to an existing node",
+                        details={"invalid_target": target, "field": "edges"},
+                    )
+                )
+
+    return errors
+
+
+# =============================================================================
+# Reference Rules - External resources (models, tools, datasets)
+# =============================================================================
+
+# Node types that require model configuration
+MODEL_REQUIRED_NODE_TYPES = {"llm", "question-classifier", "parameter-extractor"}
+
+
+def _check_model_config(node: WorkflowNodeDict, ctx: "ValidationContext") -> list[ValidationError]:
+    """Check that model configuration is valid."""
+    errors: list[ValidationError] = []
+    node_id = node.get("id", "unknown")
+    node_type = node.get("type", "unknown")
+    config = node.get("config", {})
+
+    if node_type not in MODEL_REQUIRED_NODE_TYPES:
+        return errors
+
+    model = config.get("model")
+
+    # Check if model config exists
+    if not model:
+        if ctx.available_models:
+            errors.append(
+                ValidationError(
+                    rule_id="model.required",
+                    node_id=node_id,
+                    node_type=node_type,
+                    category=RuleCategory.REFERENCE,
+                    severity=Severity.ERROR,
+                    is_fixable=True,
+                    message=f"Node '{node_id}' ({node_type}): missing required 'model' configuration",
+                    fix_hint="Add model config using one of the available models",
+                )
+            )
+        else:
+            errors.append(
+                ValidationError(
+                    rule_id="model.no_available",
+                    node_id=node_id,
+                    node_type=node_type,
+                    category=RuleCategory.REFERENCE,
+                    severity=Severity.ERROR,
+                    is_fixable=False,
+                    message=f"Node '{node_id}' ({node_type}): needs model but no models available",
+                    fix_hint="User must configure a model provider first",
+                )
+            )
+        return errors
+
+    # Check if model config is valid
+    if isinstance(model, dict):
+        provider = model.get("provider", "")
+        name = model.get("name", "")
+
+        # Check for placeholder values
+        if is_placeholder(provider) or is_placeholder(name):
+            if ctx.available_models:
+                errors.append(
+                    ValidationError(
+                        rule_id="model.placeholder",
+                        node_id=node_id,
+                        node_type=node_type,
+                        category=RuleCategory.REFERENCE,
+                        severity=Severity.ERROR,
+                        is_fixable=True,
+                        message=f"Node '{node_id}': model config contains placeholder",
+                        fix_hint="Replace placeholder with actual model from available_models",
+                    )
+                )
+            return errors
+
+        # Check if model exists in available_models
+        if ctx.available_models and provider and name:
+            if not ctx.has_model(provider, name):
+                errors.append(
+                    ValidationError(
+                        rule_id="model.not_found",
+                        node_id=node_id,
+                        node_type=node_type,
+                        category=RuleCategory.REFERENCE,
+                        severity=Severity.ERROR,
+                        is_fixable=True,
+                        message=f"Node '{node_id}': model '{provider}/{name}' not in available models",
+                        fix_hint="Replace with a model from available_models",
+                        details={"provider": provider, "model": name},
+                    )
+                )
+
+    return errors
+
+
+def _check_tool_reference(node: WorkflowNodeDict, ctx: "ValidationContext") -> list[ValidationError]:
+    """Check that tool references are valid and configured."""
+    errors: list[ValidationError] = []
+    node_id = node.get("id", "unknown")
+    node_type = node.get("type", "unknown")
+
+    if node_type != "tool":
+        return errors
+
+    config = node.get("config", {})
+    tool_ref = (
+        config.get("tool_key")
+        or config.get("tool_name")
+        or config.get("provider_id", "") + "/" + config.get("tool_name", "")
+    )
+
+    if not tool_ref:
+        errors.append(
+            ValidationError(
+                rule_id="tool.key.required",
+                node_id=node_id,
+                node_type=node_type,
+                category=RuleCategory.REFERENCE,
+                severity=Severity.ERROR,
+                is_fixable=True,
+                message=f"Node '{node_id}': tool node missing tool_key",
+                fix_hint="Add tool_key from available_tools",
+            )
+        )
+        return errors
+
+    # Check if tool exists
+    if not ctx.has_tool(tool_ref):
+        errors.append(
+            ValidationError(
+                rule_id="tool.not_found",
+                node_id=node_id,
+                node_type=node_type,
+                category=RuleCategory.REFERENCE,
+                severity=Severity.ERROR,
+                is_fixable=True,  # Can be replaced with http-request fallback
+                message=f"Node '{node_id}': tool '{tool_ref}' not found",
+                fix_hint="Use http-request or code node as fallback",
+                details={"tool_ref": tool_ref},
+            )
+        )
+    elif not ctx.is_tool_configured(tool_ref):
+        errors.append(
+            ValidationError(
+                rule_id="tool.not_configured",
+                node_id=node_id,
+                node_type=node_type,
+                category=RuleCategory.REFERENCE,
+                severity=Severity.WARNING,
+                is_fixable=False,  # User needs to configure
+                message=f"Node '{node_id}': tool '{tool_ref}' requires configuration",
+                fix_hint="Configure the tool in Tools settings",
+                details={"tool_ref": tool_ref},
+            )
+        )
+
+    return errors
+
+
+# =============================================================================
+# Register All Rules
+# =============================================================================
+
+# Structure Rules
+register_rule(
+    ValidationRule(
+        id="llm.prompt_template.required",
+        node_types=["llm"],
+        category=RuleCategory.STRUCTURE,
+        severity=Severity.ERROR,
+        is_fixable=True,
+        check=_check_llm_prompt_template,
+        description="LLM node must have prompt_template",
+        fix_hint="Add prompt_template with system and user messages",
+    )
+)
+
+register_rule(
+    ValidationRule(
+        id="http.config.required",
+        node_types=["http-request"],
+        category=RuleCategory.STRUCTURE,
+        severity=Severity.ERROR,
+        is_fixable=True,
+        check=_check_http_request_url,
+        description="HTTP request node must have url and method",
+        fix_hint="Add url and method to config",
+    )
+)
+
+register_rule(
+    ValidationRule(
+        id="code.config.required",
+        node_types=["code"],
+        category=RuleCategory.STRUCTURE,
+        severity=Severity.ERROR,
+        is_fixable=True,
+        check=_check_code_node,
+        description="Code node must have code and language",
+        fix_hint="Add code with main() function and language",
+    )
+)
+
+register_rule(
+    ValidationRule(
+        id="classifier.classes.required",
+        node_types=["question-classifier"],
+        category=RuleCategory.STRUCTURE,
+        severity=Severity.ERROR,
+        is_fixable=True,
+        check=_check_question_classifier,
+        description="Question classifier must have classes",
+        fix_hint="Add classes array with classification options",
+    )
+)
+
+register_rule(
+    ValidationRule(
+        id="extractor.config.required",
+        node_types=["parameter-extractor"],
+        category=RuleCategory.STRUCTURE,
+        severity=Severity.ERROR,
+        is_fixable=True,
+        check=_check_parameter_extractor,
+        description="Parameter extractor must have parameters",
+        fix_hint="Add parameters array",
+    )
+)
+
+register_rule(
+    ValidationRule(
+        id="knowledge.config.required",
+        node_types=["knowledge-retrieval"],
+        category=RuleCategory.STRUCTURE,
+        severity=Severity.ERROR,
+        is_fixable=False,
+        check=_check_knowledge_retrieval,
+        description="Knowledge retrieval must have dataset_ids",
+        fix_hint="User must select knowledge base",
+    )
+)
+
+register_rule(
+    ValidationRule(
+        id="end.outputs.check",
+        node_types=["end"],
+        category=RuleCategory.STRUCTURE,
+        severity=Severity.WARNING,
+        is_fixable=True,
+        check=_check_end_node,
+        description="End node should have outputs",
+        fix_hint="Add outputs array",
+    )
+)
+
+# Semantic Rules
+register_rule(
+    ValidationRule(
+        id="variable.references.valid",
+        node_types=["*"],
+        category=RuleCategory.SEMANTIC,
+        severity=Severity.ERROR,
+        is_fixable=True,
+        check=_check_variable_references,
+        description="Variable references must point to valid nodes",
+        fix_hint="Fix variable reference to use valid node ID",
+    )
+)
+
+# Edge Validation Rules
+# NOTE: Edge connectivity and branch completeness are now handled by:
+# - GraphValidator (BFS-based reachability analysis)
+# - EdgeRepair (automatic branch edge repair)
+
+register_rule(
+    ValidationRule(
+        id="edge.targets.valid",
+        node_types=["*"],
+        category=RuleCategory.SEMANTIC,
+        severity=Severity.ERROR,
+        is_fixable=True,
+        check=_check_edge_targets_exist,
+        description="Edge targets must reference existing nodes",
+        fix_hint="Change edge target to an existing node ID",
+    )
+)
+
+# Reference Rules
+register_rule(
+    ValidationRule(
+        id="model.config.valid",
+        node_types=["llm", "question-classifier", "parameter-extractor"],
+        category=RuleCategory.REFERENCE,
+        severity=Severity.ERROR,
+        is_fixable=True,
+        check=_check_model_config,
+        description="Model configuration must be valid",
+        fix_hint="Add valid model from available_models",
+    )
+)
+
+register_rule(
+    ValidationRule(
+        id="tool.reference.valid",
+        node_types=["tool"],
+        category=RuleCategory.REFERENCE,
+        severity=Severity.ERROR,
+        is_fixable=True,
+        check=_check_tool_reference,
+        description="Tool reference must be valid and configured",
+        fix_hint="Use valid tool or fallback node",
+    )
+)
+
+register_rule(
+    ValidationRule(
+        id="ifelse.operator.valid",
+        node_types=["if-else"],
+        category=RuleCategory.SEMANTIC,
+        severity=Severity.ERROR,
+        is_fixable=True,
+        check=_check_if_else_operators,
+        description="If-else operators must be valid",
+        fix_hint="Use standard operators like ≥, ≤, =, ≠",
+    )
+)

api/core/workflow/nodes/base/node.py

@@ -199,6 +199,14 @@ class Node(Generic[NodeDataT]):
 
         return None
 
+    @classmethod
+    def get_default_config_schema(cls) -> dict[str, Any] | None:
+        """
+        Get the default configuration schema for the node.
+        Used for LLM generation.
+        """
+        return None
+
     # Global registry populated via __init_subclass__
     _registry: ClassVar[dict[NodeType, dict[str, type[Node]]]] = {}
 

api/core/workflow/nodes/end/end_node.py

@@ -1,3 +1,5 @@
+from typing import Any
+
 from core.workflow.enums import NodeExecutionType, NodeType, WorkflowNodeExecutionStatus
 from core.workflow.node_events import NodeRunResult
 from core.workflow.nodes.base.node import Node
@@ -9,6 +11,24 @@ class EndNode(Node[EndNodeData]):
     node_type = NodeType.END
     execution_type = NodeExecutionType.RESPONSE
 
+    @classmethod
+    def get_default_config_schema(cls) -> dict[str, Any] | None:
+        return {
+            "description": "Workflow exit point - defines output variables",
+            "required": ["outputs"],
+            "parameters": {
+                "outputs": {
+                    "type": "array",
+                    "description": "Output variables to return",
+                    "item_schema": {
+                        "variable": "string - output variable name",
+                        "type": "enum: string, number, object, array",
+                        "value_selector": "array - path to source value, e.g. ['node_id', 'field']",
+                    },
+                },
+            },
+        }
+
     @classmethod
     def version(cls) -> str:
         return "1"

api/core/workflow/nodes/llm/node.py

@@ -322,8 +322,6 @@ class LLMNode(Node[LLMNodeData]):
                     outputs=outputs,
                     metadata={
                         WorkflowNodeExecutionMetadataKey.TOTAL_TOKENS: usage.total_tokens,
-                        WorkflowNodeExecutionMetadataKey.PROMPT_TOKENS: usage.prompt_tokens,
-                        WorkflowNodeExecutionMetadataKey.COMPLETION_TOKENS: usage.completion_tokens,
                         WorkflowNodeExecutionMetadataKey.TOTAL_PRICE: usage.total_price,
                         WorkflowNodeExecutionMetadataKey.CURRENCY: usage.currency,
                     },

api/core/workflow/nodes/start/start_node.py

@@ -14,6 +14,27 @@ class StartNode(Node[StartNodeData]):
     node_type = NodeType.START
     execution_type = NodeExecutionType.ROOT
 
+    @classmethod
+    def get_default_config_schema(cls) -> dict[str, Any] | None:
+        return {
+            "description": "Workflow entry point - defines input variables",
+            "required": [],
+            "parameters": {
+                "variables": {
+                    "type": "array",
+                    "description": "Input variables for the workflow",
+                    "item_schema": {
+                        "variable": "string - variable name",
+                        "label": "string - display label",
+                        "type": "enum: text-input, paragraph, number, select, file, file-list",
+                        "required": "boolean",
+                        "max_length": "number (optional)",
+                    },
+                },
+            },
+            "outputs": ["All defined variables are available as {{#start.variable_name#}}"],
+        }
+
     @classmethod
     def version(cls) -> str:
         return "1"

api/core/workflow/nodes/tool/tool_node.py

@@ -50,6 +50,19 @@ class ToolNode(Node[ToolNodeData]):
     def version(cls) -> str:
         return "1"
 
+    @classmethod
+    def get_default_config_schema(cls) -> dict[str, Any] | None:
+        return {
+            "description": "Execute an external tool",
+            "required": ["provider_id", "tool_id", "tool_parameters"],
+            "parameters": {
+                "provider_id": {"type": "string"},
+                "provider_type": {"type": "string"},
+                "tool_id": {"type": "string"},
+                "tool_parameters": {"type": "object"},
+            },
+        }
+
     def _run(self) -> Generator[NodeEventBase, None, None]:
         """
         Run the tool node
@@ -60,9 +73,7 @@ class ToolNode(Node[ToolNodeData]):
         tool_info = {
             "provider_type": self.node_data.provider_type.value,
             "provider_id": self.node_data.provider_id,
-            "tool_name": self.node_data.tool_name,
             "plugin_unique_identifier": self.node_data.plugin_unique_identifier,
-            "credential_id": self.node_data.credential_id,
         }
 
         # get tool runtime
@@ -107,20 +118,6 @@ class ToolNode(Node[ToolNodeData]):
         # get conversation id
         conversation_id = self.graph_runtime_state.variable_pool.get(["sys", SystemVariableKey.CONVERSATION_ID])
 
-        from core.tools.workflow_as_tool.tool import WorkflowTool
-
-        if isinstance(tool_runtime, WorkflowTool):
-            workflow_run_id_var = self.graph_runtime_state.variable_pool.get(
-                ["sys", SystemVariableKey.WORKFLOW_EXECUTION_ID]
-            )
-            tool_runtime.parent_trace_context = {
-                "trace_id": str(workflow_run_id_var.text) if workflow_run_id_var else "",
-                "parent_node_execution_id": self.execution_id,
-                "parent_workflow_run_id": str(workflow_run_id_var.text) if workflow_run_id_var else "",
-                "parent_app_id": self.app_id,
-                "parent_conversation_id": conversation_id.text if conversation_id else None,
-            }
-
         try:
             message_stream = ToolEngine.generic_invoke(
                 tool=tool_runtime,
@@ -447,8 +444,6 @@ class ToolNode(Node[ToolNodeData]):
         }
         if isinstance(usage.total_tokens, int) and usage.total_tokens > 0:
             metadata[WorkflowNodeExecutionMetadataKey.TOTAL_TOKENS] = usage.total_tokens
-            metadata[WorkflowNodeExecutionMetadataKey.PROMPT_TOKENS] = usage.prompt_tokens
-            metadata[WorkflowNodeExecutionMetadataKey.COMPLETION_TOKENS] = usage.completion_tokens
             metadata[WorkflowNodeExecutionMetadataKey.TOTAL_PRICE] = usage.total_price
             metadata[WorkflowNodeExecutionMetadataKey.CURRENCY] = usage.currency
 

api/enterprise/telemetry/DATA_DICTIONARY.md

@@ -1,522 +0,0 @@
-# Dify Enterprise Telemetry Data Dictionary
-
-Quick reference for all telemetry signals emitted by Dify Enterprise. For configuration and architecture details, see [README.md](./README.md).
-
-## Resource Attributes
-
-Attached to every signal (Span, Metric, Log).
-
-| Attribute | Type | Example |
-|-----------|------|---------|
-| `service.name` | string | `dify` |
-| `host.name` | string | `dify-api-7f8b` |
-
-## Traces (Spans)
-
-### `dify.workflow.run`
-
-| Attribute | Type | Description |
-|-----------|------|-------------|
-| `dify.trace_id` | string | Business trace ID (Workflow Run ID) |
-| `dify.tenant_id` | string | Tenant identifier |
-| `dify.app_id` | string | Application identifier |
-| `dify.workflow.id` | string | Workflow definition ID |
-| `dify.workflow.run_id` | string | Unique ID for this run |
-| `dify.workflow.status` | string | `succeeded`, `failed`, `stopped`, etc. |
-| `dify.workflow.error` | string | Error message if failed |
-| `dify.workflow.elapsed_time` | float | Total execution time (seconds) |
-| `dify.invoke_from` | string | `api`, `webapp`, `debug` |
-| `dify.conversation.id` | string | Conversation ID (optional) |
-| `dify.message.id` | string | Message ID (optional) |
-| `dify.invoked_by` | string | User ID who triggered the run |
-| `gen_ai.usage.total_tokens` | int | Total tokens across all nodes (optional) |
-| `gen_ai.user.id` | string | End-user identifier (optional) |
-| `dify.parent.trace_id` | string | Parent workflow trace ID (optional) |
-| `dify.parent.workflow.run_id` | string | Parent workflow run ID (optional) |
-| `dify.parent.node.execution_id` | string | Parent node execution ID (optional) |
-| `dify.parent.app.id` | string | Parent app ID (optional) |
-
-### `dify.node.execution`
-
-| Attribute | Type | Description |
-|-----------|------|-------------|
-| `dify.trace_id` | string | Business trace ID |
-| `dify.tenant_id` | string | Tenant identifier |
-| `dify.app_id` | string | Application identifier |
-| `dify.workflow.id` | string | Workflow definition ID |
-| `dify.workflow.run_id` | string | Workflow Run ID |
-| `dify.message.id` | string | Message ID (optional) |
-| `dify.conversation.id` | string | Conversation ID (optional) |
-| `dify.node.execution_id` | string | Unique node execution ID |
-| `dify.node.id` | string | Node ID in workflow graph |
-| `dify.node.type` | string | Node type (see appendix) |
-| `dify.node.title` | string | Display title |
-| `dify.node.status` | string | `succeeded`, `failed` |
-| `dify.node.error` | string | Error message if failed |
-| `dify.node.elapsed_time` | float | Execution time (seconds) |
-| `dify.node.index` | int | Execution order index |
-| `dify.node.predecessor_node_id` | string | Triggering node ID |
-| `dify.node.iteration_id` | string | Iteration ID (optional) |
-| `dify.node.loop_id` | string | Loop ID (optional) |
-| `dify.node.parallel_id` | string | Parallel branch ID (optional) |
-| `dify.node.invoked_by` | string | User ID who triggered execution |
-| `gen_ai.usage.input_tokens` | int | Prompt tokens (LLM nodes only) |
-| `gen_ai.usage.output_tokens` | int | Completion tokens (LLM nodes only) |
-| `gen_ai.usage.total_tokens` | int | Total tokens (LLM nodes only) |
-| `gen_ai.request.model` | string | LLM model name (LLM nodes only) |
-| `gen_ai.provider.name` | string | LLM provider name (LLM nodes only) |
-| `gen_ai.user.id` | string | End-user identifier (optional) |
-
-### `dify.node.execution.draft`
-
-Same attributes as `dify.node.execution`. Emitted during Preview/Debug runs.
-
-## Counters
-
-All counters are cumulative and emitted at 100% accuracy.
-
-### Token Counters
-
-| Metric | Unit | Description |
-|--------|------|-------------|
-| `dify.tokens.total` | `{token}` | Total tokens consumed |
-| `dify.tokens.input` | `{token}` | Input (prompt) tokens |
-| `dify.tokens.output` | `{token}` | Output (completion) tokens |
-
-**Labels:**
-- `tenant_id`, `app_id`, `operation_type`, `model_provider`, `model_name`, `node_type` (if node_execution)
-
-⚠️ **Warning:** `dify.tokens.total` at workflow level includes all node tokens. Filter by `operation_type` to avoid double-counting.
-
-#### Token Hierarchy & Query Patterns
-
-Token metrics are emitted at multiple layers. Understanding the hierarchy prevents double-counting:
-
-```
-App-level total
-├── workflow          ← sum of all node_execution tokens (DO NOT add both)
-│   └── node_execution ← per-node breakdown
-├── message           ← independent (non-workflow chat apps only)
-├── rule_generate     ← independent helper LLM call
-├── code_generate     ← independent helper LLM call
-├── structured_output ← independent helper LLM call
-└── instruction_modify← independent helper LLM call
-```
-
-**Key rule:** `workflow` tokens already include all `node_execution` tokens. Never sum both.
-
-**Available labels on token metrics:** `tenant_id`, `app_id`, `operation_type`, `model_provider`, `model_name`, `node_type`.
-App name is only available on span attributes (`dify.app.name`), not metric labels — use `app_id` for metric queries.
-
-**Common queries** (PromQL):
-
-```promql
-# ── Totals ──────────────────────────────────────────────────
-# App-level total (exclude node_execution to avoid double-counting)
-sum by (app_id) (dify_tokens_total{operation_type!="node_execution"})
-
-# Single app total
-sum (dify_tokens_total{app_id="<app_id>", operation_type!="node_execution"})
-
-# Per-tenant totals
-sum by (tenant_id) (dify_tokens_total{operation_type!="node_execution"})
-
-# ── Drill-down ──────────────────────────────────────────────
-# Workflow-level tokens for an app
-sum (dify_tokens_total{app_id="<app_id>", operation_type="workflow"})
-
-# Node-level breakdown within an app
-sum by (node_type) (dify_tokens_total{app_id="<app_id>", operation_type="node_execution"})
-
-# Model breakdown for an app
-sum by (model_provider, model_name) (dify_tokens_total{app_id="<app_id>"})
-
-# Input vs output per model
-sum by (model_name) (dify_tokens_input_total{app_id="<app_id>"})
-sum by (model_name) (dify_tokens_output_total{app_id="<app_id>"})
-
-# ── Rates ───────────────────────────────────────────────────
-# Token consumption rate (per hour)
-sum(rate(dify_tokens_total{operation_type!="node_execution"}[1h]))
-
-# Per-app consumption rate
-sum by (app_id) (rate(dify_tokens_total{operation_type!="node_execution"}[1h]))
-```
-
-**Finding `app_id` from app name** (trace query — Tempo / Jaeger):
-
-```
-{ resource.dify.app.name = "My Chatbot" } | select(resource.dify.app.id)
-```
-
-### Request Counters
-
-| Metric | Unit | Description |
-|--------|------|-------------|
-| `dify.requests.total` | `{request}` | Total operations count |
-
-**Labels by type:**
-
-| `type` | Additional Labels |
-|--------|-------------------|
-| `workflow` | `tenant_id`, `app_id`, `status`, `invoke_from` |
-| `node` | `tenant_id`, `app_id`, `node_type`, `model_provider`, `model_name`, `status` |
-| `draft_node` | `tenant_id`, `app_id`, `node_type`, `model_provider`, `model_name`, `status` |
-| `message` | `tenant_id`, `app_id`, `model_provider`, `model_name`, `status`, `invoke_from` |
-| `tool` | `tenant_id`, `app_id`, `tool_name` |
-| `moderation` | `tenant_id`, `app_id` |
-| `suggested_question` | `tenant_id`, `app_id`, `model_provider`, `model_name` |
-| `dataset_retrieval` | `tenant_id`, `app_id` |
-| `generate_name` | `tenant_id`, `app_id` |
-| `prompt_generation` | `tenant_id`, `app_id`, `operation_type`, `model_provider`, `model_name`, `status` |
-
-### Error Counters
-
-| Metric | Unit | Description |
-|--------|------|-------------|
-| `dify.errors.total` | `{error}` | Total failed operations |
-
-**Labels by type:**
-
-| `type` | Additional Labels |
-|--------|-------------------|
-| `workflow` | `tenant_id`, `app_id` |
-| `node` | `tenant_id`, `app_id`, `node_type`, `model_provider`, `model_name` |
-| `draft_node` | `tenant_id`, `app_id`, `node_type`, `model_provider`, `model_name` |
-| `message` | `tenant_id`, `app_id`, `model_provider`, `model_name` |
-| `tool` | `tenant_id`, `app_id`, `tool_name` |
-| `prompt_generation` | `tenant_id`, `app_id`, `operation_type`, `model_provider`, `model_name` |
-
-### Other Counters
-
-| Metric | Unit | Labels |
-|--------|------|--------|
-| `dify.feedback.total` | `{feedback}` | `tenant_id`, `app_id`, `rating` |
-| `dify.dataset.retrievals.total` | `{retrieval}` | `tenant_id`, `app_id`, `dataset_id`, `embedding_model_provider`, `embedding_model`, `rerank_model_provider`, `rerank_model` |
-| `dify.app.created.total` | `{app}` | `tenant_id`, `app_id`, `mode` |
-| `dify.app.updated.total` | `{app}` | `tenant_id`, `app_id` |
-| `dify.app.deleted.total` | `{app}` | `tenant_id`, `app_id` |
-
-## Histograms
-
-| Metric | Unit | Labels |
-|--------|------|--------|
-| `dify.workflow.duration` | `s` | `tenant_id`, `app_id`, `status` |
-| `dify.node.duration` | `s` | `tenant_id`, `app_id`, `node_type`, `model_provider`, `model_name`, `plugin_name` |
-| `dify.message.duration` | `s` | `tenant_id`, `app_id`, `model_provider`, `model_name` |
-| `dify.message.time_to_first_token` | `s` | `tenant_id`, `app_id`, `model_provider`, `model_name` |
-| `dify.tool.duration` | `s` | `tenant_id`, `app_id`, `tool_name` |
-| `dify.prompt_generation.duration` | `s` | `tenant_id`, `app_id`, `operation_type`, `model_provider`, `model_name` |
-
-## Structured Logs
-
-### Span Companion Logs
-
-Logs that accompany spans. Signal type: `span_detail`
-
-#### `dify.workflow.run` Companion Log
-
-**Common attributes:** All span attributes (see Traces section) plus:
-
-| Additional Attribute | Type | Always Present | Description |
-|---------------------|------|----------------|-------------|
-| `dify.app.name` | string | No | Application display name |
-| `dify.workspace.name` | string | No | Workspace display name |
-| `dify.workflow.version` | string | Yes | Workflow definition version |
-| `dify.workflow.inputs` | string/JSON | Yes | Input parameters (content-gated) |
-| `dify.workflow.outputs` | string/JSON | Yes | Output results (content-gated) |
-| `dify.workflow.query` | string | No | User query text (content-gated) |
-
-**Event attributes:**
-- `dify.event.name`: `"dify.workflow.run"`
-- `dify.event.signal`: `"span_detail"`
-- `trace_id`, `span_id`, `tenant_id`, `user_id`
-
-#### `dify.node.execution` and `dify.node.execution.draft` Companion Logs
-
-**Common attributes:** All span attributes (see Traces section) plus:
-
-| Additional Attribute | Type | Always Present | Description |
-|---------------------|------|----------------|-------------|
-| `dify.app.name` | string | No | Application display name |
-| `dify.workspace.name` | string | No | Workspace display name |
-| `dify.invoke_from` | string | No | Invocation source |
-| `gen_ai.tool.name` | string | No | Tool name (tool nodes only) |
-| `dify.node.total_price` | float | No | Cost (LLM nodes only) |
-| `dify.node.currency` | string | No | Currency code (LLM nodes only) |
-| `dify.node.iteration_index` | int | No | Iteration index (iteration nodes) |
-| `dify.node.loop_index` | int | No | Loop index (loop nodes) |
-| `dify.plugin.name` | string | No | Plugin name (tool/knowledge nodes) |
-| `dify.credential.name` | string | No | Credential name (plugin nodes) |
-| `dify.credential.id` | string | No | Credential ID (plugin nodes) |
-| `dify.dataset.ids` | JSON array | No | Dataset IDs (knowledge nodes) |
-| `dify.dataset.names` | JSON array | No | Dataset names (knowledge nodes) |
-| `dify.node.inputs` | string/JSON | Yes | Node inputs (content-gated) |
-| `dify.node.outputs` | string/JSON | Yes | Node outputs (content-gated) |
-| `dify.node.process_data` | string/JSON | No | Processing data (content-gated) |
-
-**Event attributes:**
-- `dify.event.name`: `"dify.node.execution"` or `"dify.node.execution.draft"`
-- `dify.event.signal`: `"span_detail"`
-- `trace_id`, `span_id`, `tenant_id`, `user_id`
-
-### Standalone Logs
-
-Logs without structural spans. Signal type: `metric_only`
-
-#### `dify.message.run`
-
-| Attribute | Type | Description |
-|-----------|------|-------------|
-| `dify.event.name` | string | `"dify.message.run"` |
-| `dify.event.signal` | string | `"metric_only"` |
-| `trace_id` | string | OTEL trace ID (32-char hex) |
-| `span_id` | string | OTEL span ID (16-char hex) |
-| `tenant_id` | string | Tenant identifier |
-| `user_id` | string | User identifier (optional) |
-| `dify.app_id` | string | Application identifier |
-| `dify.message.id` | string | Message identifier |
-| `dify.conversation.id` | string | Conversation ID (optional) |
-| `dify.workflow.run_id` | string | Workflow run ID (optional) |
-| `dify.invoke_from` | string | `service-api`, `web-app`, `debugger`, `explore` |
-| `gen_ai.provider.name` | string | LLM provider |
-| `gen_ai.request.model` | string | LLM model |
-| `gen_ai.usage.input_tokens` | int | Input tokens |
-| `gen_ai.usage.output_tokens` | int | Output tokens |
-| `gen_ai.usage.total_tokens` | int | Total tokens |
-| `dify.message.status` | string | `succeeded`, `failed` |
-| `dify.message.error` | string | Error message (if failed) |
-| `dify.message.duration` | float | Duration (seconds) |
-| `dify.message.time_to_first_token` | float | TTFT (seconds) |
-| `dify.message.inputs` | string/JSON | Inputs (content-gated) |
-| `dify.message.outputs` | string/JSON | Outputs (content-gated) |
-
-#### `dify.tool.execution`
-
-| Attribute | Type | Description |
-|-----------|------|-------------|
-| `dify.event.name` | string | `"dify.tool.execution"` |
-| `dify.event.signal` | string | `"metric_only"` |
-| `trace_id` | string | OTEL trace ID |
-| `span_id` | string | OTEL span ID |
-| `tenant_id` | string | Tenant identifier |
-| `dify.app_id` | string | Application identifier |
-| `dify.message.id` | string | Message identifier |
-| `dify.tool.name` | string | Tool name |
-| `dify.tool.duration` | float | Duration (seconds) |
-| `dify.tool.status` | string | `succeeded`, `failed` |
-| `dify.tool.error` | string | Error message (if failed) |
-| `dify.tool.inputs` | string/JSON | Inputs (content-gated) |
-| `dify.tool.outputs` | string/JSON | Outputs (content-gated) |
-| `dify.tool.parameters` | string/JSON | Parameters (content-gated) |
-| `dify.tool.config` | string/JSON | Configuration (content-gated) |
-
-#### `dify.moderation.check`
-
-| Attribute | Type | Description |
-|-----------|------|-------------|
-| `dify.event.name` | string | `"dify.moderation.check"` |
-| `dify.event.signal` | string | `"metric_only"` |
-| `trace_id` | string | OTEL trace ID |
-| `span_id` | string | OTEL span ID |
-| `tenant_id` | string | Tenant identifier |
-| `dify.app_id` | string | Application identifier |
-| `dify.message.id` | string | Message identifier |
-| `dify.moderation.type` | string | `input`, `output` |
-| `dify.moderation.action` | string | `pass`, `block`, `flag` |
-| `dify.moderation.flagged` | boolean | Whether flagged |
-| `dify.moderation.categories` | JSON array | Flagged categories |
-| `dify.moderation.query` | string | Content (content-gated) |
-
-#### `dify.suggested_question.generation`
-
-| Attribute | Type | Description |
-|-----------|------|-------------|
-| `dify.event.name` | string | `"dify.suggested_question.generation"` |
-| `dify.event.signal` | string | `"metric_only"` |
-| `trace_id` | string | OTEL trace ID |
-| `span_id` | string | OTEL span ID |
-| `tenant_id` | string | Tenant identifier |
-| `dify.app_id` | string | Application identifier |
-| `dify.message.id` | string | Message identifier |
-| `dify.suggested_question.count` | int | Number of questions |
-| `dify.suggested_question.duration` | float | Duration (seconds) |
-| `dify.suggested_question.status` | string | `succeeded`, `failed` |
-| `dify.suggested_question.error` | string | Error message (if failed) |
-| `dify.suggested_question.questions` | JSON array | Questions (content-gated) |
-
-#### `dify.dataset.retrieval`
-
-| Attribute | Type | Description |
-|-----------|------|-------------|
-| `dify.event.name` | string | `"dify.dataset.retrieval"` |
-| `dify.event.signal` | string | `"metric_only"` |
-| `trace_id` | string | OTEL trace ID |
-| `span_id` | string | OTEL span ID |
-| `tenant_id` | string | Tenant identifier |
-| `dify.app_id` | string | Application identifier |
-| `dify.message.id` | string | Message identifier |
-| `dify.dataset.id` | string | Dataset identifier |
-| `dify.dataset.name` | string | Dataset name |
-| `dify.dataset.embedding_providers` | JSON array | Embedding model providers (one per dataset) |
-| `dify.dataset.embedding_models` | JSON array | Embedding models (one per dataset) |
-| `dify.retrieval.rerank_provider` | string | Rerank model provider |
-| `dify.retrieval.rerank_model` | string | Rerank model name |
-| `dify.retrieval.query` | string | Search query (content-gated) |
-| `dify.retrieval.document_count` | int | Documents retrieved |
-| `dify.retrieval.duration` | float | Duration (seconds) |
-| `dify.retrieval.status` | string | `succeeded`, `failed` |
-| `dify.retrieval.error` | string | Error message (if failed) |
-| `dify.dataset.documents` | JSON array | Documents (content-gated) |
-
-#### `dify.generate_name.execution`
-
-| Attribute | Type | Description |
-|-----------|------|-------------|
-| `dify.event.name` | string | `"dify.generate_name.execution"` |
-| `dify.event.signal` | string | `"metric_only"` |
-| `trace_id` | string | OTEL trace ID |
-| `span_id` | string | OTEL span ID |
-| `tenant_id` | string | Tenant identifier |
-| `dify.app_id` | string | Application identifier |
-| `dify.conversation.id` | string | Conversation identifier |
-| `dify.generate_name.duration` | float | Duration (seconds) |
-| `dify.generate_name.status` | string | `succeeded`, `failed` |
-| `dify.generate_name.error` | string | Error message (if failed) |
-| `dify.generate_name.inputs` | string/JSON | Inputs (content-gated) |
-| `dify.generate_name.outputs` | string | Generated name (content-gated) |
-
-#### `dify.prompt_generation.execution`
-
-| Attribute | Type | Description |
-|-----------|------|-------------|
-| `dify.event.name` | string | `"dify.prompt_generation.execution"` |
-| `dify.event.signal` | string | `"metric_only"` |
-| `trace_id` | string | OTEL trace ID |
-| `span_id` | string | OTEL span ID |
-| `tenant_id` | string | Tenant identifier |
-| `dify.app_id` | string | Application identifier |
-| `dify.prompt_generation.operation_type` | string | Operation type (see appendix) |
-| `gen_ai.provider.name` | string | LLM provider |
-| `gen_ai.request.model` | string | LLM model |
-| `gen_ai.usage.input_tokens` | int | Input tokens |
-| `gen_ai.usage.output_tokens` | int | Output tokens |
-| `gen_ai.usage.total_tokens` | int | Total tokens |
-| `dify.prompt_generation.duration` | float | Duration (seconds) |
-| `dify.prompt_generation.status` | string | `succeeded`, `failed` |
-| `dify.prompt_generation.error` | string | Error message (if failed) |
-| `dify.prompt_generation.instruction` | string | Instruction (content-gated) |
-| `dify.prompt_generation.output` | string/JSON | Output (content-gated) |
-
-#### `dify.app.created`
-
-| Attribute | Type | Description |
-|-----------|------|-------------|
-| `dify.event.name` | string | `"dify.app.created"` |
-| `dify.event.signal` | string | `"metric_only"` |
-| `tenant_id` | string | Tenant identifier |
-| `dify.app_id` | string | Application identifier |
-| `dify.app.mode` | string | `chat`, `completion`, `agent-chat`, `workflow` |
-| `dify.app.created_at` | string | Timestamp (ISO 8601) |
-
-#### `dify.app.updated`
-
-| Attribute | Type | Description |
-|-----------|------|-------------|
-| `dify.event.name` | string | `"dify.app.updated"` |
-| `dify.event.signal` | string | `"metric_only"` |
-| `tenant_id` | string | Tenant identifier |
-| `dify.app_id` | string | Application identifier |
-| `dify.app.updated_at` | string | Timestamp (ISO 8601) |
-
-#### `dify.app.deleted`
-
-| Attribute | Type | Description |
-|-----------|------|-------------|
-| `dify.event.name` | string | `"dify.app.deleted"` |
-| `dify.event.signal` | string | `"metric_only"` |
-| `tenant_id` | string | Tenant identifier |
-| `dify.app_id` | string | Application identifier |
-| `dify.app.deleted_at` | string | Timestamp (ISO 8601) |
-
-#### `dify.feedback.created`
-
-| Attribute | Type | Description |
-|-----------|------|-------------|
-| `dify.event.name` | string | `"dify.feedback.created"` |
-| `dify.event.signal` | string | `"metric_only"` |
-| `trace_id` | string | OTEL trace ID |
-| `span_id` | string | OTEL span ID |
-| `tenant_id` | string | Tenant identifier |
-| `dify.app_id` | string | Application identifier |
-| `dify.message.id` | string | Message identifier |
-| `dify.feedback.rating` | string | `like`, `dislike`, `null` |
-| `dify.feedback.content` | string | Feedback text (content-gated) |
-| `dify.feedback.created_at` | string | Timestamp (ISO 8601) |
-
-#### `dify.telemetry.rehydration_failed`
-
-Diagnostic event for telemetry system health monitoring.
-
-| Attribute | Type | Description |
-|-----------|------|-------------|
-| `dify.event.name` | string | `"dify.telemetry.rehydration_failed"` |
-| `dify.event.signal` | string | `"metric_only"` |
-| `tenant_id` | string | Tenant identifier |
-| `dify.telemetry.error` | string | Error message |
-| `dify.telemetry.payload_type` | string | Payload type (see appendix) |
-| `dify.telemetry.correlation_id` | string | Correlation ID |
-
-## Content-Gated Attributes
-
-When `ENTERPRISE_INCLUDE_CONTENT=false`, these attributes are replaced with reference strings (`ref:{id_type}={uuid}`).
-
-| Attribute | Signal |
-|-----------|--------|
-| `dify.workflow.inputs` | `dify.workflow.run` |
-| `dify.workflow.outputs` | `dify.workflow.run` |
-| `dify.workflow.query` | `dify.workflow.run` |
-| `dify.node.inputs` | `dify.node.execution` |
-| `dify.node.outputs` | `dify.node.execution` |
-| `dify.node.process_data` | `dify.node.execution` |
-| `dify.message.inputs` | `dify.message.run` |
-| `dify.message.outputs` | `dify.message.run` |
-| `dify.tool.inputs` | `dify.tool.execution` |
-| `dify.tool.outputs` | `dify.tool.execution` |
-| `dify.tool.parameters` | `dify.tool.execution` |
-| `dify.tool.config` | `dify.tool.execution` |
-| `dify.moderation.query` | `dify.moderation.check` |
-| `dify.suggested_question.questions` | `dify.suggested_question.generation` |
-| `dify.retrieval.query` | `dify.dataset.retrieval` |
-| `dify.dataset.documents` | `dify.dataset.retrieval` |
-| `dify.generate_name.inputs` | `dify.generate_name.execution` |
-| `dify.generate_name.outputs` | `dify.generate_name.execution` |
-| `dify.prompt_generation.instruction` | `dify.prompt_generation.execution` |
-| `dify.prompt_generation.output` | `dify.prompt_generation.execution` |
-| `dify.feedback.content` | `dify.feedback.created` |
-
-## Appendix
-
-### Operation Types
-
-- `workflow`, `node_execution`, `message`, `rule_generate`, `code_generate`, `structured_output`, `instruction_modify`
-
-### Node Types
-
-- `start`, `end`, `answer`, `llm`, `knowledge-retrieval`, `knowledge-index`, `if-else`, `code`, `template-transform`, `question-classifier`, `http-request`, `tool`, `datasource`, `variable-aggregator`, `loop`, `iteration`, `parameter-extractor`, `assigner`, `document-extractor`, `list-operator`, `agent`, `trigger-webhook`, `trigger-schedule`, `trigger-plugin`, `human-input`
-
-### Workflow Statuses
-
-- `running`, `succeeded`, `failed`, `stopped`, `partial-succeeded`, `paused`
-
-### Payload Types
-
-- `workflow`, `node`, `message`, `tool`, `moderation`, `suggested_question`, `dataset_retrieval`, `generate_name`, `prompt_generation`, `app`, `feedback`
-
-### Null Value Behavior
-
-**Spans:** Attributes with `null` values are omitted.
-
-**Logs:** Attributes with `null` values appear as `null` in JSON.
-
-**Content-Gated:** Replaced with reference strings, not set to `null`.

api/enterprise/telemetry/README.md

@@ -1,116 +0,0 @@
-# Dify Enterprise Telemetry
-
-This document provides an overview of the Dify Enterprise OpenTelemetry (OTEL) exporter and how to configure it for integration with observability stacks like Prometheus, Grafana, Jaeger, or Honeycomb.
-
-## Overview
-
-Dify Enterprise uses a "slim span + rich companion log" architecture to provide high-fidelity observability without overwhelming trace storage.
-
-- **Traces (Spans)**: Capture the structure, identity, and timing of high-level operations (Workflows and Nodes).
-- **Structured Logs**: Provide deep context (inputs, outputs, metadata) for every event, correlated to spans via `trace_id` and `span_id`.
-- **Metrics**: Provide 100% accurate counters and histograms for usage, performance, and error tracking.
-
-### Signal Architecture
-
-```mermaid
-graph TD
-    A[Workflow Run] -->|Span| B(dify.workflow.run)
-    A -->|Log| C(dify.workflow.run detail)
-    B ---|trace_id| C
-    
-    D[Node Execution] -->|Span| E(dify.node.execution)
-    D -->|Log| F(dify.node.execution detail)
-    E ---|span_id| F
-    
-    G[Message/Tool/etc] -->|Log| H(dify.* event)
-    G -->|Metric| I(dify.* counter/histogram)
-```
-
-## Configuration
-
-The Enterprise OTEL exporter is configured via environment variables.
-
-| Variable | Description | Default |
-|----------|-------------|---------|
-| `ENTERPRISE_ENABLED` | Master switch for all enterprise features. | `false` |
-| `ENTERPRISE_TELEMETRY_ENABLED` | Master switch for enterprise telemetry. | `false` |
-| `ENTERPRISE_OTLP_ENDPOINT` | OTLP collector endpoint (e.g., `http://otel-collector:4318`). | - |
-| `ENTERPRISE_OTLP_HEADERS` | Custom headers for OTLP requests (e.g., `x-scope-orgid=tenant1`). | - |
-| `ENTERPRISE_OTLP_PROTOCOL` | OTLP transport protocol (`http` or `grpc`). | `http` |
-| `ENTERPRISE_OTLP_API_KEY` | Bearer token for authentication. | - |
-| `ENTERPRISE_INCLUDE_CONTENT` | Whether to include sensitive content (inputs/outputs) in logs. | `true` |
-| `ENTERPRISE_SERVICE_NAME` | Service name reported to OTEL. | `dify` |
-| `ENTERPRISE_OTEL_SAMPLING_RATE` | Sampling rate for traces (0.0 to 1.0). Metrics are always 100%. | `1.0` |
-
-## Correlation Model
-
-Dify uses deterministic ID generation to ensure signals are correlated across different services and asynchronous tasks.
-
-### ID Generation Rules
-- `trace_id`: Derived from the correlation ID (workflow_run_id or node_execution_id for drafts) using `int(UUID(correlation_id))`
-- `span_id`: Derived from the source ID using `SHA256(source_id)[:8]`
-
-### Scenario A: Simple Workflow
-A single workflow run with multiple nodes. All spans and logs share the same `trace_id` (derived from `workflow_run_id`).
-
-```
-trace_id = UUID(workflow_run_id)
-├── [root span] dify.workflow.run (span_id = hash(workflow_run_id))
-│   ├── [child] dify.node.execution - "Start" (span_id = hash(node_exec_id_1))
-│   ├── [child] dify.node.execution - "LLM" (span_id = hash(node_exec_id_2))
-│   └── [child] dify.node.execution - "End" (span_id = hash(node_exec_id_3))
-```
-
-### Scenario B: Nested Sub-Workflow
-A workflow calling another workflow via a Tool or Sub-workflow node. The child workflow's spans are linked to the parent via `parent_span_id`. Both workflows share the same trace_id.
-
-```
-trace_id = UUID(outer_workflow_run_id)     ← shared across both workflows
-├── [root] dify.workflow.run (outer) (span_id = hash(outer_workflow_run_id))
-│   ├── dify.node.execution - "Start Node"
-│   ├── dify.node.execution - "Tool Node" (triggers sub-workflow)
-│   │   └── [child] dify.workflow.run (inner) (span_id = hash(inner_workflow_run_id))
-│   │       ├── dify.node.execution - "Inner Start"
-│   │       └── dify.node.execution - "Inner End"
-│   └── dify.node.execution - "End Node"
-```
-
-**Key attributes for nested workflows:**
-- Inner workflow's `dify.parent.trace_id` = outer `workflow_run_id`
-- Inner workflow's `dify.parent.node.execution_id` = tool node's `execution_id`
-- Inner workflow's `dify.parent.workflow.run_id` = outer `workflow_run_id`
-- Inner workflow's `dify.parent.app.id` = outer `app_id`
-
-### Scenario C: Draft Node Execution
-A single node run in isolation (debugger/preview mode). It creates its own trace where the node span is the root.
-
-```
-trace_id = UUID(node_execution_id)   ← own trace, NOT part of any workflow
-└── dify.node.execution.draft (span_id = hash(node_execution_id))
-```
-
-**Key difference:** Draft executions use `node_execution_id` as the correlation_id, so they are NOT children of any workflow trace.
-
-## Content Gating
-
-When `ENTERPRISE_INCLUDE_CONTENT` is set to `false`, sensitive content attributes (inputs, outputs, queries) are replaced with reference strings (e.g., `ref:workflow_run_id=...`) to prevent data leakage to the OTEL collector.
-
-**Reference String Format:**
-
-```
-ref:{id_type}={uuid}
-```
-
-**Examples:**
-
-```
-ref:workflow_run_id=550e8400-e29b-41d4-a716-446655440000
-ref:node_execution_id=660e8400-e29b-41d4-a716-446655440001
-ref:message_id=770e8400-e29b-41d4-a716-446655440002
-```
-
-To retrieve actual content when gating is enabled, query the Dify database using the provided UUID.
-
-## Reference
-
-For a complete list of telemetry signals, attributes, and data structures, see [DATA_DICTIONARY.md](./DATA_DICTIONARY.md).

api/enterprise/telemetry/contracts.py

@@ -1,73 +0,0 @@
-"""Telemetry gateway contracts and data structures.
-
-This module defines the envelope format for telemetry events and the routing
-configuration that determines how each event type is processed.
-"""
-
-from __future__ import annotations
-
-from enum import StrEnum
-from typing import Any
-
-from pydantic import BaseModel, ConfigDict
-
-
-class TelemetryCase(StrEnum):
-    """Enumeration of all known telemetry event cases."""
-
-    WORKFLOW_RUN = "workflow_run"
-    NODE_EXECUTION = "node_execution"
-    DRAFT_NODE_EXECUTION = "draft_node_execution"
-    MESSAGE_RUN = "message_run"
-    TOOL_EXECUTION = "tool_execution"
-    MODERATION_CHECK = "moderation_check"
-    SUGGESTED_QUESTION = "suggested_question"
-    DATASET_RETRIEVAL = "dataset_retrieval"
-    GENERATE_NAME = "generate_name"
-    PROMPT_GENERATION = "prompt_generation"
-    APP_CREATED = "app_created"
-    APP_UPDATED = "app_updated"
-    APP_DELETED = "app_deleted"
-    FEEDBACK_CREATED = "feedback_created"
-
-
-class SignalType(StrEnum):
-    """Signal routing type for telemetry cases."""
-
-    TRACE = "trace"
-    METRIC_LOG = "metric_log"
-
-
-class CaseRoute(BaseModel):
-    """Routing configuration for a telemetry case.
-
-    Attributes:
-        signal_type: The type of signal (trace or metric_log).
-        ce_eligible: Whether this case is eligible for community edition tracing.
-    """
-
-    signal_type: SignalType
-    ce_eligible: bool
-
-
-class TelemetryEnvelope(BaseModel):
-    """Envelope for telemetry events.
-
-    Attributes:
-        case: The telemetry case type.
-        tenant_id: The tenant identifier.
-        event_id: Unique event identifier for deduplication.
-        payload: The main event payload (inline for small payloads,
-            empty when offloaded to storage via ``payload_ref``).
-        metadata: Optional metadata dictionary.  When the gateway
-            offloads a large payload to object storage, this contains
-            ``{"payload_ref": "<storage_key>"}``.
-    """
-
-    model_config = ConfigDict(extra="forbid", use_enum_values=False)
-
-    case: TelemetryCase
-    tenant_id: str
-    event_id: str
-    payload: dict[str, Any]
-    metadata: dict[str, Any] | None = None

api/enterprise/telemetry/draft_trace.py

@@ -1,77 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Mapping
-from typing import Any
-
-from core.telemetry import TelemetryContext, TelemetryEvent, TraceTaskName
-from core.telemetry import emit as telemetry_emit
-from core.workflow.enums import WorkflowNodeExecutionMetadataKey
-from models.workflow import WorkflowNodeExecutionModel
-
-
-def enqueue_draft_node_execution_trace(
-    *,
-    execution: WorkflowNodeExecutionModel,
-    outputs: Mapping[str, Any] | None,
-    workflow_execution_id: str | None,
-    user_id: str,
-) -> None:
-    node_data = _build_node_execution_data(
-        execution=execution,
-        outputs=outputs,
-        workflow_execution_id=workflow_execution_id,
-    )
-    telemetry_emit(
-        TelemetryEvent(
-            name=TraceTaskName.DRAFT_NODE_EXECUTION_TRACE,
-            context=TelemetryContext(
-                tenant_id=execution.tenant_id,
-                user_id=user_id,
-                app_id=execution.app_id,
-            ),
-            payload={"node_execution_data": node_data},
-        )
-    )
-
-
-def _build_node_execution_data(
-    *,
-    execution: WorkflowNodeExecutionModel,
-    outputs: Mapping[str, Any] | None,
-    workflow_execution_id: str | None,
-) -> dict[str, Any]:
-    metadata = execution.execution_metadata_dict
-    node_outputs = outputs if outputs is not None else execution.outputs_dict
-    execution_id = workflow_execution_id or execution.workflow_run_id or execution.id
-
-    return {
-        "workflow_id": execution.workflow_id,
-        "workflow_execution_id": execution_id,
-        "tenant_id": execution.tenant_id,
-        "app_id": execution.app_id,
-        "node_execution_id": execution.id,
-        "node_id": execution.node_id,
-        "node_type": execution.node_type,
-        "title": execution.title,
-        "status": execution.status,
-        "error": execution.error,
-        "elapsed_time": execution.elapsed_time,
-        "index": execution.index,
-        "predecessor_node_id": execution.predecessor_node_id,
-        "created_at": execution.created_at,
-        "finished_at": execution.finished_at,
-        "total_tokens": metadata.get(WorkflowNodeExecutionMetadataKey.TOTAL_TOKENS, 0),
-        "total_price": metadata.get(WorkflowNodeExecutionMetadataKey.TOTAL_PRICE, 0.0),
-        "currency": metadata.get(WorkflowNodeExecutionMetadataKey.CURRENCY),
-        "tool_name": (metadata.get(WorkflowNodeExecutionMetadataKey.TOOL_INFO) or {}).get("tool_name")
-        if isinstance(metadata.get(WorkflowNodeExecutionMetadataKey.TOOL_INFO), dict)
-        else None,
-        "iteration_id": metadata.get(WorkflowNodeExecutionMetadataKey.ITERATION_ID),
-        "iteration_index": metadata.get(WorkflowNodeExecutionMetadataKey.ITERATION_INDEX),
-        "loop_id": metadata.get(WorkflowNodeExecutionMetadataKey.LOOP_ID),
-        "loop_index": metadata.get(WorkflowNodeExecutionMetadataKey.LOOP_INDEX),
-        "parallel_id": metadata.get(WorkflowNodeExecutionMetadataKey.PARALLEL_ID),
-        "node_inputs": execution.inputs_dict,
-        "node_outputs": node_outputs,
-        "process_data": execution.process_data_dict,
-    }

api/enterprise/telemetry/enterprise_trace.py

@@ -1,938 +0,0 @@
-"""Enterprise trace handler — duck-typed, NOT a BaseTraceInstance subclass.
-
-Invoked directly in the Celery task, not through OpsTraceManager dispatch.
-Only requires a matching ``trace(trace_info)`` method signature.
-
-Signal strategy:
-- **Traces (spans)**: workflow run, node execution, draft node execution only.
-- **Metrics + structured logs**: all other event types.
-
-Token metric labels (unified structure):
-All token metrics (dify.tokens.input, dify.tokens.output, dify.tokens.total) use the
-same label set for consistent filtering and aggregation:
-- tenant_id: Tenant identifier
-- app_id: Application identifier
-- operation_type: Source of token usage (workflow | node_execution | message | rule_generate | etc.)
-- model_provider: LLM provider name (empty string if not applicable)
-- model_name: LLM model name (empty string if not applicable)
-- node_type: Workflow node type (empty string if not node_execution)
-
-This unified structure allows filtering by operation_type to separate:
-- Workflow-level aggregates (operation_type=workflow)
-- Individual node executions (operation_type=node_execution)
-- Direct message calls (operation_type=message)
-- Prompt generation operations (operation_type=rule_generate, code_generate, etc.)
-
-Without this, tokens are double-counted when querying totals (workflow totals include
-node totals, since workflow.total_tokens is the sum of all node tokens).
-"""
-
-from __future__ import annotations
-
-import json
-import logging
-from typing import Any, cast
-
-from opentelemetry.util.types import AttributeValue
-
-from core.ops.entities.trace_entity import (
-    BaseTraceInfo,
-    DatasetRetrievalTraceInfo,
-    DraftNodeExecutionTrace,
-    GenerateNameTraceInfo,
-    MessageTraceInfo,
-    ModerationTraceInfo,
-    OperationType,
-    PromptGenerationTraceInfo,
-    SuggestedQuestionTraceInfo,
-    ToolTraceInfo,
-    WorkflowNodeTraceInfo,
-    WorkflowTraceInfo,
-)
-from enterprise.telemetry.entities import (
-    EnterpriseTelemetryCounter,
-    EnterpriseTelemetryEvent,
-    EnterpriseTelemetryHistogram,
-    EnterpriseTelemetrySpan,
-    TokenMetricLabels,
-)
-from enterprise.telemetry.telemetry_log import emit_metric_only_event, emit_telemetry_log
-
-logger = logging.getLogger(__name__)
-
-
-class EnterpriseOtelTrace:
-    """Duck-typed enterprise trace handler.
-
-    ``*_trace`` methods emit spans (workflow/node only) or structured logs
-    (all other events), plus metrics at 100 % accuracy.
-    """
-
-    def __init__(self) -> None:
-        from extensions.ext_enterprise_telemetry import get_enterprise_exporter
-
-        exporter = get_enterprise_exporter()
-        if exporter is None:
-            raise RuntimeError("EnterpriseOtelTrace instantiated but exporter is not initialized")
-        self._exporter = exporter
-
-    def trace(self, trace_info: BaseTraceInfo) -> None:
-        if isinstance(trace_info, WorkflowTraceInfo):
-            self._workflow_trace(trace_info)
-        elif isinstance(trace_info, MessageTraceInfo):
-            self._message_trace(trace_info)
-        elif isinstance(trace_info, ToolTraceInfo):
-            self._tool_trace(trace_info)
-        elif isinstance(trace_info, DraftNodeExecutionTrace):
-            self._draft_node_execution_trace(trace_info)
-        elif isinstance(trace_info, WorkflowNodeTraceInfo):
-            self._node_execution_trace(trace_info)
-        elif isinstance(trace_info, ModerationTraceInfo):
-            self._moderation_trace(trace_info)
-        elif isinstance(trace_info, SuggestedQuestionTraceInfo):
-            self._suggested_question_trace(trace_info)
-        elif isinstance(trace_info, DatasetRetrievalTraceInfo):
-            self._dataset_retrieval_trace(trace_info)
-        elif isinstance(trace_info, GenerateNameTraceInfo):
-            self._generate_name_trace(trace_info)
-        elif isinstance(trace_info, PromptGenerationTraceInfo):
-            self._prompt_generation_trace(trace_info)
-
-    def _common_attrs(self, trace_info: BaseTraceInfo) -> dict[str, Any]:
-        metadata = self._metadata(trace_info)
-        tenant_id, app_id, user_id = self._context_ids(trace_info, metadata)
-        return {
-            "dify.trace_id": trace_info.resolved_trace_id,
-            "dify.tenant_id": tenant_id,
-            "dify.app_id": app_id,
-            "dify.app.name": metadata.get("app_name"),
-            "dify.workspace.name": metadata.get("workspace_name"),
-            "gen_ai.user.id": user_id,
-            "dify.message.id": trace_info.message_id,
-        }
-
-    def _metadata(self, trace_info: BaseTraceInfo) -> dict[str, Any]:
-        return trace_info.metadata
-
-    def _context_ids(
-        self,
-        trace_info: BaseTraceInfo,
-        metadata: dict[str, Any],
-    ) -> tuple[str | None, str | None, str | None]:
-        tenant_id = getattr(trace_info, "tenant_id", None) or metadata.get("tenant_id")
-        app_id = getattr(trace_info, "app_id", None) or metadata.get("app_id")
-        user_id = getattr(trace_info, "user_id", None) or metadata.get("user_id")
-        return tenant_id, app_id, user_id
-
-    def _labels(self, **values: AttributeValue) -> dict[str, AttributeValue]:
-        return dict(values)
-
-    def _safe_payload_value(self, value: Any) -> str | dict[str, Any] | list[object] | None:
-        if isinstance(value, str):
-            return value
-        if isinstance(value, dict):
-            return cast(dict[str, Any], value)
-        if isinstance(value, list):
-            items: list[object] = []
-            for item in cast(list[object], value):
-                items.append(item)
-            return items
-        return None
-
-    def _content_or_ref(self, value: Any, ref: str) -> Any:
-        if self._exporter.include_content:
-            return self._maybe_json(value)
-        return ref
-
-    def _maybe_json(self, value: Any) -> str | None:
-        if value is None:
-            return None
-        if isinstance(value, str):
-            return value
-        try:
-            return json.dumps(value, default=str)
-        except (TypeError, ValueError):
-            return str(value)
-
-    # ------------------------------------------------------------------
-    # SPAN-emitting handlers (workflow, node execution, draft node)
-    # ------------------------------------------------------------------
-
-    def _workflow_trace(self, info: WorkflowTraceInfo) -> None:
-        metadata = self._metadata(info)
-        tenant_id, app_id, user_id = self._context_ids(info, metadata)
-        # -- Span attrs: identity + structure + status + timing + gen_ai scalars --
-        span_attrs: dict[str, Any] = {
-            "dify.trace_id": info.resolved_trace_id,
-            "dify.tenant_id": tenant_id,
-            "dify.app_id": app_id,
-            "dify.workflow.id": info.workflow_id,
-            "dify.workflow.run_id": info.workflow_run_id,
-            "dify.workflow.status": info.workflow_run_status,
-            "dify.workflow.error": info.error,
-            "dify.workflow.elapsed_time": info.workflow_run_elapsed_time,
-            "dify.invoke_from": metadata.get("triggered_from"),
-            "dify.conversation.id": info.conversation_id,
-            "dify.message.id": info.message_id,
-            "dify.invoked_by": info.invoked_by,
-            "gen_ai.usage.total_tokens": info.total_tokens,
-            "gen_ai.user.id": user_id,
-        }
-
-        trace_correlation_override, parent_span_id_source = info.resolved_parent_context
-
-        parent_ctx = metadata.get("parent_trace_context")
-        if isinstance(parent_ctx, dict):
-            parent_ctx_dict = cast(dict[str, Any], parent_ctx)
-            span_attrs["dify.parent.trace_id"] = parent_ctx_dict.get("trace_id")
-            span_attrs["dify.parent.node.execution_id"] = parent_ctx_dict.get("parent_node_execution_id")
-            span_attrs["dify.parent.workflow.run_id"] = parent_ctx_dict.get("parent_workflow_run_id")
-            span_attrs["dify.parent.app.id"] = parent_ctx_dict.get("parent_app_id")
-
-        self._exporter.export_span(
-            EnterpriseTelemetrySpan.WORKFLOW_RUN,
-            span_attrs,
-            correlation_id=info.workflow_run_id,
-            span_id_source=info.workflow_run_id,
-            start_time=info.start_time,
-            end_time=info.end_time,
-            trace_correlation_override=trace_correlation_override,
-            parent_span_id_source=parent_span_id_source,
-        )
-
-        # -- Companion log: ALL attrs (span + detail) for full picture --
-        log_attrs: dict[str, Any] = {**span_attrs}
-        log_attrs.update(
-            {
-                "dify.app.name": metadata.get("app_name"),
-                "dify.workspace.name": metadata.get("workspace_name"),
-                "gen_ai.user.id": user_id,
-                "gen_ai.usage.total_tokens": info.total_tokens,
-                "dify.workflow.version": info.workflow_run_version,
-            }
-        )
-
-        ref = f"ref:workflow_run_id={info.workflow_run_id}"
-        log_attrs["dify.workflow.inputs"] = self._content_or_ref(info.workflow_run_inputs, ref)
-        log_attrs["dify.workflow.outputs"] = self._content_or_ref(info.workflow_run_outputs, ref)
-        log_attrs["dify.workflow.query"] = self._content_or_ref(info.query, ref)
-
-        emit_telemetry_log(
-            event_name=EnterpriseTelemetryEvent.WORKFLOW_RUN,
-            attributes=log_attrs,
-            signal="span_detail",
-            trace_id_source=info.workflow_run_id,
-            span_id_source=info.workflow_run_id,
-            tenant_id=tenant_id,
-            user_id=user_id,
-        )
-
-        # -- Metrics --
-        labels = self._labels(
-            tenant_id=tenant_id or "",
-            app_id=app_id or "",
-        )
-        token_labels = TokenMetricLabels(
-            tenant_id=tenant_id or "",
-            app_id=app_id or "",
-            operation_type=OperationType.WORKFLOW,
-            model_provider="",
-            model_name="",
-            node_type="",
-        ).to_dict()
-        self._exporter.increment_counter(EnterpriseTelemetryCounter.TOKENS, info.total_tokens, token_labels)
-        if info.prompt_tokens is not None and info.prompt_tokens > 0:
-            self._exporter.increment_counter(EnterpriseTelemetryCounter.INPUT_TOKENS, info.prompt_tokens, token_labels)
-        if info.completion_tokens is not None and info.completion_tokens > 0:
-            self._exporter.increment_counter(
-                EnterpriseTelemetryCounter.OUTPUT_TOKENS, info.completion_tokens, token_labels
-            )
-        invoke_from = metadata.get("triggered_from", "")
-        self._exporter.increment_counter(
-            EnterpriseTelemetryCounter.REQUESTS,
-            1,
-            self._labels(
-                **labels,
-                type="workflow",
-                status=info.workflow_run_status,
-                invoke_from=invoke_from,
-            ),
-        )
-        # Prefer wall-clock timestamps over the elapsed_time field: elapsed_time defaults
-        # to 0 in the DB and can be stale if the Celery write races with the trace task.
-        # start_time = workflow_run.created_at, end_time = workflow_run.finished_at.
-        if info.start_time and info.end_time:
-            workflow_duration = (info.end_time - info.start_time).total_seconds()
-        elif info.workflow_run_elapsed_time:
-            workflow_duration = float(info.workflow_run_elapsed_time)
-        else:
-            workflow_duration = 0.0
-        self._exporter.record_histogram(
-            EnterpriseTelemetryHistogram.WORKFLOW_DURATION,
-            workflow_duration,
-            self._labels(
-                **labels,
-                status=info.workflow_run_status,
-            ),
-        )
-
-        if info.error:
-            self._exporter.increment_counter(
-                EnterpriseTelemetryCounter.ERRORS,
-                1,
-                self._labels(
-                    **labels,
-                    type="workflow",
-                ),
-            )
-
-    def _node_execution_trace(self, info: WorkflowNodeTraceInfo) -> None:
-        self._emit_node_execution_trace(info, EnterpriseTelemetrySpan.NODE_EXECUTION, "node")
-
-    def _draft_node_execution_trace(self, info: DraftNodeExecutionTrace) -> None:
-        self._emit_node_execution_trace(
-            info,
-            EnterpriseTelemetrySpan.DRAFT_NODE_EXECUTION,
-            "draft_node",
-            correlation_id_override=info.node_execution_id,
-            trace_correlation_override_param=info.workflow_run_id,
-        )
-
-    def _emit_node_execution_trace(
-        self,
-        info: WorkflowNodeTraceInfo,
-        span_name: EnterpriseTelemetrySpan,
-        request_type: str,
-        correlation_id_override: str | None = None,
-        trace_correlation_override_param: str | None = None,
-    ) -> None:
-        metadata = self._metadata(info)
-        tenant_id, app_id, user_id = self._context_ids(info, metadata)
-        # -- Span attrs: identity + structure + status + timing + gen_ai scalars --
-        span_attrs: dict[str, Any] = {
-            "dify.trace_id": info.resolved_trace_id,
-            "dify.tenant_id": tenant_id,
-            "dify.app_id": app_id,
-            "dify.workflow.id": info.workflow_id,
-            "dify.workflow.run_id": info.workflow_run_id,
-            "dify.message.id": info.message_id,
-            "dify.conversation.id": metadata.get("conversation_id"),
-            "dify.node.execution_id": info.node_execution_id,
-            "dify.node.id": info.node_id,
-            "dify.node.type": info.node_type,
-            "dify.node.title": info.title,
-            "dify.node.status": info.status,
-            "dify.node.error": info.error,
-            "dify.node.elapsed_time": info.elapsed_time,
-            "dify.node.index": info.index,
-            "dify.node.predecessor_node_id": info.predecessor_node_id,
-            "dify.node.iteration_id": info.iteration_id,
-            "dify.node.loop_id": info.loop_id,
-            "dify.node.parallel_id": info.parallel_id,
-            "dify.node.invoked_by": info.invoked_by,
-            "gen_ai.usage.input_tokens": info.prompt_tokens,
-            "gen_ai.usage.output_tokens": info.completion_tokens,
-            "gen_ai.usage.total_tokens": info.total_tokens,
-            "gen_ai.request.model": info.model_name,
-            "gen_ai.provider.name": info.model_provider,
-            "gen_ai.user.id": user_id,
-        }
-
-        resolved_override, _ = info.resolved_parent_context
-        trace_correlation_override = trace_correlation_override_param or resolved_override
-
-        effective_correlation_id = correlation_id_override or info.workflow_run_id
-        self._exporter.export_span(
-            span_name,
-            span_attrs,
-            correlation_id=effective_correlation_id,
-            span_id_source=info.node_execution_id,
-            start_time=info.start_time,
-            end_time=info.end_time,
-            trace_correlation_override=trace_correlation_override,
-        )
-
-        # -- Companion log: ALL attrs (span + detail) --
-        log_attrs: dict[str, Any] = {**span_attrs}
-        log_attrs.update(
-            {
-                "dify.app.name": metadata.get("app_name"),
-                "dify.workspace.name": metadata.get("workspace_name"),
-                "dify.invoke_from": metadata.get("invoke_from"),
-                "gen_ai.user.id": user_id,
-                "gen_ai.usage.total_tokens": info.total_tokens,
-                "dify.node.total_price": info.total_price,
-                "dify.node.currency": info.currency,
-                "gen_ai.provider.name": info.model_provider,
-                "gen_ai.request.model": info.model_name,
-                "gen_ai.tool.name": info.tool_name,
-                "dify.node.iteration_index": info.iteration_index,
-                "dify.node.loop_index": info.loop_index,
-                "dify.plugin.name": metadata.get("plugin_name"),
-                "dify.credential.name": metadata.get("credential_name"),
-                "dify.credential.id": metadata.get("credential_id"),
-                "dify.dataset.ids": self._maybe_json(metadata.get("dataset_ids")),
-                "dify.dataset.names": self._maybe_json(metadata.get("dataset_names")),
-            }
-        )
-
-        ref = f"ref:node_execution_id={info.node_execution_id}"
-        log_attrs["dify.node.inputs"] = self._content_or_ref(info.node_inputs, ref)
-        log_attrs["dify.node.outputs"] = self._content_or_ref(info.node_outputs, ref)
-        log_attrs["dify.node.process_data"] = self._content_or_ref(info.process_data, ref)
-
-        emit_telemetry_log(
-            event_name=span_name.value,
-            attributes=log_attrs,
-            signal="span_detail",
-            trace_id_source=info.workflow_run_id,
-            span_id_source=info.node_execution_id,
-            tenant_id=tenant_id,
-            user_id=user_id,
-        )
-
-        # -- Metrics --
-        labels = self._labels(
-            tenant_id=tenant_id or "",
-            app_id=app_id or "",
-            node_type=info.node_type,
-            model_provider=info.model_provider or "",
-        )
-        if info.total_tokens:
-            token_labels = TokenMetricLabels(
-                tenant_id=tenant_id or "",
-                app_id=app_id or "",
-                operation_type=OperationType.NODE_EXECUTION,
-                model_provider=info.model_provider or "",
-                model_name=info.model_name or "",
-                node_type=info.node_type,
-            ).to_dict()
-            self._exporter.increment_counter(EnterpriseTelemetryCounter.TOKENS, info.total_tokens, token_labels)
-            if info.prompt_tokens is not None and info.prompt_tokens > 0:
-                self._exporter.increment_counter(
-                    EnterpriseTelemetryCounter.INPUT_TOKENS, info.prompt_tokens, token_labels
-                )
-            if info.completion_tokens is not None and info.completion_tokens > 0:
-                self._exporter.increment_counter(
-                    EnterpriseTelemetryCounter.OUTPUT_TOKENS, info.completion_tokens, token_labels
-                )
-        self._exporter.increment_counter(
-            EnterpriseTelemetryCounter.REQUESTS,
-            1,
-            self._labels(
-                **labels,
-                type=request_type,
-                status=info.status,
-                model_name=info.model_name or "",
-            ),
-        )
-        duration_labels = dict(labels)
-        duration_labels["model_name"] = info.model_name or ""
-        plugin_name = metadata.get("plugin_name")
-        if plugin_name and info.node_type in {"tool", "knowledge-retrieval"}:
-            duration_labels["plugin_name"] = plugin_name
-        self._exporter.record_histogram(EnterpriseTelemetryHistogram.NODE_DURATION, info.elapsed_time, duration_labels)
-
-        if info.error:
-            self._exporter.increment_counter(
-                EnterpriseTelemetryCounter.ERRORS,
-                1,
-                self._labels(
-                    **labels,
-                    type=request_type,
-                    model_name=info.model_name or "",
-                ),
-            )
-
-    # ------------------------------------------------------------------
-    # METRIC-ONLY handlers (structured log + counters/histograms)
-    # ------------------------------------------------------------------
-
-    def _message_trace(self, info: MessageTraceInfo) -> None:
-        metadata = self._metadata(info)
-        tenant_id, app_id, user_id = self._context_ids(info, metadata)
-        attrs = self._common_attrs(info)
-        attrs.update(
-            {
-                "dify.invoke_from": metadata.get("from_source"),
-                "dify.conversation.id": metadata.get("conversation_id"),
-                "dify.conversation.mode": info.conversation_mode,
-                "gen_ai.provider.name": metadata.get("ls_provider"),
-                "gen_ai.request.model": metadata.get("ls_model_name"),
-                "gen_ai.usage.input_tokens": info.message_tokens,
-                "gen_ai.usage.output_tokens": info.answer_tokens,
-                "gen_ai.usage.total_tokens": info.total_tokens,
-                "dify.message.status": metadata.get("status"),
-                "dify.message.error": info.error,
-                "dify.message.from_source": metadata.get("from_source"),
-                "dify.message.from_end_user_id": metadata.get("from_end_user_id"),
-                "dify.message.from_account_id": metadata.get("from_account_id"),
-                "dify.streaming": info.is_streaming_request,
-                "dify.message.time_to_first_token": info.gen_ai_server_time_to_first_token,
-                "dify.message.streaming_duration": info.llm_streaming_time_to_generate,
-                "dify.workflow.run_id": metadata.get("workflow_run_id"),
-            }
-        )
-        node_execution_id = metadata.get("node_execution_id")
-        if node_execution_id:
-            attrs["dify.node.execution_id"] = node_execution_id
-
-        ref = f"ref:message_id={info.message_id}"
-        inputs = self._safe_payload_value(info.inputs)
-        outputs = self._safe_payload_value(info.outputs)
-        attrs["dify.message.inputs"] = self._content_or_ref(inputs, ref)
-        attrs["dify.message.outputs"] = self._content_or_ref(outputs, ref)
-
-        emit_metric_only_event(
-            event_name=EnterpriseTelemetryEvent.MESSAGE_RUN,
-            attributes=attrs,
-            trace_id_source=metadata.get("workflow_run_id") or str(info.message_id) if info.message_id else None,
-            span_id_source=node_execution_id,
-            tenant_id=tenant_id,
-            user_id=user_id,
-        )
-
-        labels = self._labels(
-            tenant_id=tenant_id or "",
-            app_id=app_id or "",
-            model_provider=metadata.get("ls_provider") or "",
-            model_name=metadata.get("ls_model_name") or "",
-        )
-        token_labels = TokenMetricLabels(
-            tenant_id=tenant_id or "",
-            app_id=app_id or "",
-            operation_type=OperationType.MESSAGE,
-            model_provider=metadata.get("ls_provider") or "",
-            model_name=metadata.get("ls_model_name") or "",
-            node_type="",
-        ).to_dict()
-        self._exporter.increment_counter(EnterpriseTelemetryCounter.TOKENS, info.total_tokens, token_labels)
-        if info.message_tokens > 0:
-            self._exporter.increment_counter(EnterpriseTelemetryCounter.INPUT_TOKENS, info.message_tokens, token_labels)
-        if info.answer_tokens > 0:
-            self._exporter.increment_counter(EnterpriseTelemetryCounter.OUTPUT_TOKENS, info.answer_tokens, token_labels)
-        invoke_from = metadata.get("from_source", "")
-        self._exporter.increment_counter(
-            EnterpriseTelemetryCounter.REQUESTS,
-            1,
-            self._labels(
-                **labels,
-                type="message",
-                status=metadata.get("status", ""),
-                invoke_from=invoke_from,
-            ),
-        )
-
-        if info.start_time and info.end_time:
-            duration = (info.end_time - info.start_time).total_seconds()
-            self._exporter.record_histogram(EnterpriseTelemetryHistogram.MESSAGE_DURATION, duration, labels)
-
-        if info.gen_ai_server_time_to_first_token is not None:
-            self._exporter.record_histogram(
-                EnterpriseTelemetryHistogram.MESSAGE_TTFT, info.gen_ai_server_time_to_first_token, labels
-            )
-
-        if info.error:
-            self._exporter.increment_counter(
-                EnterpriseTelemetryCounter.ERRORS,
-                1,
-                self._labels(
-                    **labels,
-                    type="message",
-                ),
-            )
-
-    def _tool_trace(self, info: ToolTraceInfo) -> None:
-        metadata = self._metadata(info)
-        tenant_id, app_id, user_id = self._context_ids(info, metadata)
-        attrs = self._common_attrs(info)
-        attrs.update(
-            {
-                "gen_ai.tool.name": info.tool_name,
-                "dify.tool.time_cost": info.time_cost,
-                "dify.tool.error": info.error,
-                "dify.workflow.run_id": metadata.get("workflow_run_id"),
-            }
-        )
-        node_execution_id = metadata.get("node_execution_id")
-        if node_execution_id:
-            attrs["dify.node.execution_id"] = node_execution_id
-
-        ref = f"ref:message_id={info.message_id}"
-        attrs["dify.tool.inputs"] = self._content_or_ref(info.tool_inputs, ref)
-        attrs["dify.tool.outputs"] = self._content_or_ref(info.tool_outputs, ref)
-        attrs["dify.tool.parameters"] = self._content_or_ref(info.tool_parameters, ref)
-        attrs["dify.tool.config"] = self._content_or_ref(info.tool_config, ref)
-
-        emit_metric_only_event(
-            event_name=EnterpriseTelemetryEvent.TOOL_EXECUTION,
-            attributes=attrs,
-            trace_id_source=info.resolved_trace_id,
-            span_id_source=node_execution_id,
-            tenant_id=tenant_id,
-            user_id=user_id,
-        )
-
-        labels = self._labels(
-            tenant_id=tenant_id or "",
-            app_id=app_id or "",
-            tool_name=info.tool_name,
-        )
-        self._exporter.increment_counter(
-            EnterpriseTelemetryCounter.REQUESTS,
-            1,
-            self._labels(
-                **labels,
-                type="tool",
-            ),
-        )
-        self._exporter.record_histogram(EnterpriseTelemetryHistogram.TOOL_DURATION, float(info.time_cost), labels)
-
-        if info.error:
-            self._exporter.increment_counter(
-                EnterpriseTelemetryCounter.ERRORS,
-                1,
-                self._labels(
-                    **labels,
-                    type="tool",
-                ),
-            )
-
-    def _moderation_trace(self, info: ModerationTraceInfo) -> None:
-        metadata = self._metadata(info)
-        tenant_id, app_id, user_id = self._context_ids(info, metadata)
-        attrs = self._common_attrs(info)
-        attrs.update(
-            {
-                "dify.moderation.flagged": info.flagged,
-                "dify.moderation.action": info.action,
-                "dify.moderation.preset_response": info.preset_response,
-                "dify.workflow.run_id": metadata.get("workflow_run_id"),
-            }
-        )
-        node_execution_id = metadata.get("node_execution_id")
-        if node_execution_id:
-            attrs["dify.node.execution_id"] = node_execution_id
-
-        attrs["dify.moderation.query"] = self._content_or_ref(
-            info.query,
-            f"ref:message_id={info.message_id}",
-        )
-
-        emit_metric_only_event(
-            event_name=EnterpriseTelemetryEvent.MODERATION_CHECK,
-            attributes=attrs,
-            trace_id_source=info.resolved_trace_id,
-            span_id_source=node_execution_id,
-            tenant_id=tenant_id,
-            user_id=user_id,
-        )
-
-        labels = self._labels(
-            tenant_id=tenant_id or "",
-            app_id=app_id or "",
-        )
-        self._exporter.increment_counter(
-            EnterpriseTelemetryCounter.REQUESTS,
-            1,
-            self._labels(
-                **labels,
-                type="moderation",
-            ),
-        )
-
-    def _suggested_question_trace(self, info: SuggestedQuestionTraceInfo) -> None:
-        metadata = self._metadata(info)
-        tenant_id, app_id, user_id = self._context_ids(info, metadata)
-        attrs = self._common_attrs(info)
-        attrs.update(
-            {
-                "gen_ai.usage.total_tokens": info.total_tokens,
-                "dify.suggested_question.status": info.status,
-                "dify.suggested_question.error": info.error,
-                "gen_ai.provider.name": info.model_provider,
-                "gen_ai.request.model": info.model_id,
-                "dify.suggested_question.count": len(info.suggested_question),
-                "dify.workflow.run_id": metadata.get("workflow_run_id"),
-            }
-        )
-        node_execution_id = metadata.get("node_execution_id")
-        if node_execution_id:
-            attrs["dify.node.execution_id"] = node_execution_id
-
-        attrs["dify.suggested_question.questions"] = self._content_or_ref(
-            info.suggested_question,
-            f"ref:message_id={info.message_id}",
-        )
-
-        emit_metric_only_event(
-            event_name=EnterpriseTelemetryEvent.SUGGESTED_QUESTION_GENERATION,
-            attributes=attrs,
-            trace_id_source=info.resolved_trace_id,
-            span_id_source=node_execution_id,
-            tenant_id=tenant_id,
-            user_id=user_id,
-        )
-
-        labels = self._labels(
-            tenant_id=tenant_id or "",
-            app_id=app_id or "",
-        )
-        self._exporter.increment_counter(
-            EnterpriseTelemetryCounter.REQUESTS,
-            1,
-            self._labels(
-                **labels,
-                type="suggested_question",
-                model_provider=info.model_provider or "",
-                model_name=info.model_id or "",
-            ),
-        )
-
-    def _dataset_retrieval_trace(self, info: DatasetRetrievalTraceInfo) -> None:
-        metadata = self._metadata(info)
-        tenant_id, app_id, user_id = self._context_ids(info, metadata)
-        attrs = self._common_attrs(info)
-        attrs["dify.dataset.error"] = info.error
-        attrs["dify.workflow.run_id"] = metadata.get("workflow_run_id")
-        node_execution_id = metadata.get("node_execution_id")
-        if node_execution_id:
-            attrs["dify.node.execution_id"] = node_execution_id
-
-        docs: list[dict[str, Any]] = []
-        documents_any: Any = info.documents
-        documents_list: list[Any] = cast(list[Any], documents_any) if isinstance(documents_any, list) else []
-        for entry in documents_list:
-            if isinstance(entry, dict):
-                entry_dict: dict[str, Any] = cast(dict[str, Any], entry)
-                docs.append(entry_dict)
-        dataset_ids: list[str] = []
-        dataset_names: list[str] = []
-        structured_docs: list[dict[str, Any]] = []
-        for doc in docs:
-            meta_raw = doc.get("metadata")
-            meta: dict[str, Any] = cast(dict[str, Any], meta_raw) if isinstance(meta_raw, dict) else {}
-            did = meta.get("dataset_id")
-            dname = 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)
-            structured_docs.append(
-                {
-                    "dataset_id": did,
-                    "document_id": meta.get("document_id"),
-                    "segment_id": meta.get("segment_id"),
-                    "score": meta.get("score"),
-                }
-            )
-
-        attrs["dify.dataset.ids"] = self._maybe_json(dataset_ids)
-        attrs["dify.dataset.names"] = self._maybe_json(dataset_names)
-        attrs["dify.retrieval.document_count"] = len(docs)
-
-        embedding_models_raw: Any = metadata.get("embedding_models")
-        embedding_models: dict[str, Any] = (
-            cast(dict[str, Any], embedding_models_raw) if isinstance(embedding_models_raw, dict) else {}
-        )
-        if embedding_models:
-            providers: list[str] = []
-            models: list[str] = []
-            for ds_info in embedding_models.values():
-                if isinstance(ds_info, dict):
-                    ds_info_dict: dict[str, Any] = cast(dict[str, Any], ds_info)
-                    p = ds_info_dict.get("embedding_model_provider", "")
-                    m = ds_info_dict.get("embedding_model", "")
-                    if p and p not in providers:
-                        providers.append(p)
-                    if m and m not in models:
-                        models.append(m)
-            attrs["dify.dataset.embedding_providers"] = self._maybe_json(providers)
-            attrs["dify.dataset.embedding_models"] = self._maybe_json(models)
-
-        # Add rerank model to logs
-        rerank_provider = metadata.get("rerank_model_provider", "")
-        rerank_model = metadata.get("rerank_model_name", "")
-        if rerank_provider or rerank_model:
-            attrs["dify.retrieval.rerank_provider"] = rerank_provider
-            attrs["dify.retrieval.rerank_model"] = rerank_model
-
-        ref = f"ref:message_id={info.message_id}"
-        retrieval_inputs = self._safe_payload_value(info.inputs)
-        attrs["dify.retrieval.query"] = self._content_or_ref(retrieval_inputs, ref)
-        attrs["dify.dataset.documents"] = self._content_or_ref(structured_docs, ref)
-
-        emit_metric_only_event(
-            event_name=EnterpriseTelemetryEvent.DATASET_RETRIEVAL,
-            attributes=attrs,
-            trace_id_source=metadata.get("workflow_run_id") or str(info.message_id) if info.message_id else None,
-            span_id_source=node_execution_id or (str(info.message_id) if info.message_id else None),
-            tenant_id=tenant_id,
-            user_id=user_id,
-        )
-
-        labels = self._labels(
-            tenant_id=tenant_id or "",
-            app_id=app_id or "",
-        )
-        self._exporter.increment_counter(
-            EnterpriseTelemetryCounter.REQUESTS,
-            1,
-            self._labels(
-                **labels,
-                type="dataset_retrieval",
-            ),
-        )
-
-        for did in dataset_ids:
-            # Get embedding model for this specific dataset
-            ds_embedding_info = embedding_models.get(did, {})
-            embedding_provider = ds_embedding_info.get("embedding_model_provider", "")
-            embedding_model = ds_embedding_info.get("embedding_model", "")
-
-            # Get rerank model (same for all datasets in this retrieval)
-            rerank_provider = metadata.get("rerank_model_provider", "")
-            rerank_model = metadata.get("rerank_model_name", "")
-
-            self._exporter.increment_counter(
-                EnterpriseTelemetryCounter.DATASET_RETRIEVALS,
-                1,
-                self._labels(
-                    **labels,
-                    dataset_id=did,
-                    embedding_model_provider=embedding_provider,
-                    embedding_model=embedding_model,
-                    rerank_model_provider=rerank_provider,
-                    rerank_model=rerank_model,
-                ),
-            )
-
-    def _generate_name_trace(self, info: GenerateNameTraceInfo) -> None:
-        metadata = self._metadata(info)
-        tenant_id, app_id, user_id = self._context_ids(info, metadata)
-        attrs = self._common_attrs(info)
-        attrs["dify.conversation.id"] = info.conversation_id
-        node_execution_id = metadata.get("node_execution_id")
-        if node_execution_id:
-            attrs["dify.node.execution_id"] = node_execution_id
-
-        ref = f"ref:conversation_id={info.conversation_id}"
-        inputs = self._safe_payload_value(info.inputs)
-        outputs = self._safe_payload_value(info.outputs)
-        attrs["dify.generate_name.inputs"] = self._content_or_ref(inputs, ref)
-        attrs["dify.generate_name.outputs"] = self._content_or_ref(outputs, ref)
-
-        emit_metric_only_event(
-            event_name=EnterpriseTelemetryEvent.GENERATE_NAME_EXECUTION,
-            attributes=attrs,
-            trace_id_source=info.resolved_trace_id,
-            span_id_source=node_execution_id,
-            tenant_id=tenant_id,
-            user_id=user_id,
-        )
-
-        labels = self._labels(
-            tenant_id=tenant_id or "",
-            app_id=app_id or "",
-        )
-        self._exporter.increment_counter(
-            EnterpriseTelemetryCounter.REQUESTS,
-            1,
-            self._labels(
-                **labels,
-                type="generate_name",
-            ),
-        )
-
-    def _prompt_generation_trace(self, info: PromptGenerationTraceInfo) -> None:
-        metadata = self._metadata(info)
-        tenant_id, app_id, user_id = self._context_ids(info, metadata)
-        attrs = {
-            "dify.trace_id": info.resolved_trace_id,
-            "dify.tenant_id": tenant_id,
-            "dify.user.id": user_id,
-            "dify.app.id": app_id or "",
-            "dify.app.name": metadata.get("app_name"),
-            "dify.workspace.name": metadata.get("workspace_name"),
-            "dify.operation.type": info.operation_type,
-            "gen_ai.provider.name": info.model_provider,
-            "gen_ai.request.model": info.model_name,
-            "gen_ai.usage.input_tokens": info.prompt_tokens,
-            "gen_ai.usage.output_tokens": info.completion_tokens,
-            "gen_ai.usage.total_tokens": info.total_tokens,
-            "dify.prompt_generation.latency": info.latency,
-            "dify.prompt_generation.error": info.error,
-        }
-        node_execution_id = metadata.get("node_execution_id")
-        if node_execution_id:
-            attrs["dify.node.execution_id"] = node_execution_id
-
-        if info.total_price is not None:
-            attrs["dify.prompt_generation.total_price"] = info.total_price
-            attrs["dify.prompt_generation.currency"] = info.currency
-
-        ref = f"ref:trace_id={info.trace_id}"
-        outputs = self._safe_payload_value(info.outputs)
-        attrs["dify.prompt_generation.instruction"] = self._content_or_ref(info.instruction, ref)
-        attrs["dify.prompt_generation.output"] = self._content_or_ref(outputs, ref)
-
-        emit_metric_only_event(
-            event_name=EnterpriseTelemetryEvent.PROMPT_GENERATION_EXECUTION,
-            attributes=attrs,
-            trace_id_source=info.resolved_trace_id,
-            span_id_source=node_execution_id,
-            tenant_id=tenant_id,
-            user_id=user_id,
-        )
-
-        token_labels = TokenMetricLabels(
-            tenant_id=tenant_id or "",
-            app_id=app_id or "",
-            operation_type=info.operation_type,
-            model_provider=info.model_provider,
-            model_name=info.model_name,
-            node_type="",
-        ).to_dict()
-
-        labels = self._labels(
-            tenant_id=tenant_id or "",
-            app_id=app_id or "",
-            operation_type=info.operation_type,
-            model_provider=info.model_provider,
-            model_name=info.model_name,
-        )
-
-        self._exporter.increment_counter(EnterpriseTelemetryCounter.TOKENS, info.total_tokens, token_labels)
-        if info.prompt_tokens > 0:
-            self._exporter.increment_counter(EnterpriseTelemetryCounter.INPUT_TOKENS, info.prompt_tokens, token_labels)
-        if info.completion_tokens > 0:
-            self._exporter.increment_counter(
-                EnterpriseTelemetryCounter.OUTPUT_TOKENS, info.completion_tokens, token_labels
-            )
-
-        status = "failed" if info.error else "success"
-        self._exporter.increment_counter(
-            EnterpriseTelemetryCounter.REQUESTS,
-            1,
-            self._labels(
-                **labels,
-                type="prompt_generation",
-                status=status,
-            ),
-        )
-
-        self._exporter.record_histogram(
-            EnterpriseTelemetryHistogram.PROMPT_GENERATION_DURATION,
-            info.latency,
-            labels,
-        )
-
-        if info.error:
-            self._exporter.increment_counter(
-                EnterpriseTelemetryCounter.ERRORS,
-                1,
-                self._labels(
-                    **labels,
-                    type="prompt_generation",
-                ),
-            )

api/enterprise/telemetry/entities/__init__.py

@@ -1,121 +0,0 @@
-from enum import StrEnum
-from typing import cast
-
-from opentelemetry.util.types import AttributeValue
-from pydantic import BaseModel, ConfigDict
-
-
-class EnterpriseTelemetrySpan(StrEnum):
-    WORKFLOW_RUN = "dify.workflow.run"
-    NODE_EXECUTION = "dify.node.execution"
-    DRAFT_NODE_EXECUTION = "dify.node.execution.draft"
-
-
-class EnterpriseTelemetryEvent(StrEnum):
-    """Event names for enterprise telemetry logs."""
-
-    APP_CREATED = "dify.app.created"
-    APP_UPDATED = "dify.app.updated"
-    APP_DELETED = "dify.app.deleted"
-    FEEDBACK_CREATED = "dify.feedback.created"
-    WORKFLOW_RUN = "dify.workflow.run"
-    MESSAGE_RUN = "dify.message.run"
-    TOOL_EXECUTION = "dify.tool.execution"
-    MODERATION_CHECK = "dify.moderation.check"
-    SUGGESTED_QUESTION_GENERATION = "dify.suggested_question.generation"
-    DATASET_RETRIEVAL = "dify.dataset.retrieval"
-    GENERATE_NAME_EXECUTION = "dify.generate_name.execution"
-    PROMPT_GENERATION_EXECUTION = "dify.prompt_generation.execution"
-    REHYDRATION_FAILED = "dify.telemetry.rehydration_failed"
-
-
-class EnterpriseTelemetryCounter(StrEnum):
-    TOKENS = "tokens"
-    INPUT_TOKENS = "input_tokens"
-    OUTPUT_TOKENS = "output_tokens"
-    REQUESTS = "requests"
-    ERRORS = "errors"
-    FEEDBACK = "feedback"
-    DATASET_RETRIEVALS = "dataset_retrievals"
-    APP_CREATED = "app_created"
-    APP_UPDATED = "app_updated"
-    APP_DELETED = "app_deleted"
-
-
-class EnterpriseTelemetryHistogram(StrEnum):
-    WORKFLOW_DURATION = "workflow_duration"
-    NODE_DURATION = "node_duration"
-    MESSAGE_DURATION = "message_duration"
-    MESSAGE_TTFT = "message_ttft"
-    TOOL_DURATION = "tool_duration"
-    PROMPT_GENERATION_DURATION = "prompt_generation_duration"
-
-
-class TokenMetricLabels(BaseModel):
-    """Unified label structure for all dify.token.* metrics.
-
-    All token counters (dify.tokens.input, dify.tokens.output, dify.tokens.total) MUST
-    use this exact label set to ensure consistent filtering and aggregation across
-    different operation types.
-
-    Attributes:
-        tenant_id: Tenant identifier.
-        app_id: Application identifier.
-        operation_type: Source of token usage (workflow | node_execution | message |
-            rule_generate | code_generate | structured_output | instruction_modify).
-        model_provider: LLM provider name. Empty string if not applicable (e.g., workflow-level).
-        model_name: LLM model name. Empty string if not applicable (e.g., workflow-level).
-        node_type: Workflow node type. Empty string unless operation_type=node_execution.
-
-    Usage:
-        labels = TokenMetricLabels(
-            tenant_id="tenant-123",
-            app_id="app-456",
-            operation_type=OperationType.WORKFLOW,
-            model_provider="",
-            model_name="",
-            node_type="",
-        )
-        exporter.increment_counter(
-            EnterpriseTelemetryCounter.INPUT_TOKENS,
-            100,
-            labels.to_dict()
-        )
-
-    Design rationale:
-        Without this unified structure, tokens get double-counted when querying totals
-        because workflow.total_tokens is already the sum of all node tokens. The
-        operation_type label allows filtering to separate workflow-level aggregates from
-        node-level detail, while keeping the same label cardinality for consistent queries.
-    """
-
-    tenant_id: str
-    app_id: str
-    operation_type: str
-    model_provider: str
-    model_name: str
-    node_type: str
-
-    model_config = ConfigDict(extra="forbid", frozen=True)
-
-    def to_dict(self) -> dict[str, AttributeValue]:
-        return cast(
-            dict[str, AttributeValue],
-            {
-                "tenant_id": self.tenant_id,
-                "app_id": self.app_id,
-                "operation_type": self.operation_type,
-                "model_provider": self.model_provider,
-                "model_name": self.model_name,
-                "node_type": self.node_type,
-            },
-        )
-
-
-__all__ = [
-    "EnterpriseTelemetryCounter",
-    "EnterpriseTelemetryEvent",
-    "EnterpriseTelemetryHistogram",
-    "EnterpriseTelemetrySpan",
-    "TokenMetricLabels",
-]

api/enterprise/telemetry/event_handlers.py

@@ -1,99 +0,0 @@
-"""Blinker signal handlers for enterprise telemetry.
-
-Registered at import time via ``@signal.connect`` decorators.
-Import must happen during ``ext_enterprise_telemetry.init_app()`` to
-ensure handlers fire.  Each handler delegates to ``core.telemetry.gateway``
-which handles routing, EE-gating, and dispatch.
-
-All handlers are best-effort: exceptions are caught and logged so that
-telemetry failures never break user-facing operations.
-"""
-
-from __future__ import annotations
-
-import logging
-
-from events.app_event import app_was_created, app_was_deleted, app_was_updated
-from events.feedback_event import feedback_was_created
-
-logger = logging.getLogger(__name__)
-
-__all__ = [
-    "_handle_app_created",
-    "_handle_app_deleted",
-    "_handle_app_updated",
-    "_handle_feedback_created",
-]
-
-
-@app_was_created.connect
-def _handle_app_created(sender: object, **kwargs: object) -> None:
-    try:
-        from core.telemetry.gateway import emit as gateway_emit
-        from enterprise.telemetry.contracts import TelemetryCase
-
-        gateway_emit(
-            case=TelemetryCase.APP_CREATED,
-            context={"tenant_id": str(getattr(sender, "tenant_id", "") or "")},
-            payload={
-                "app_id": getattr(sender, "id", None),
-                "mode": getattr(sender, "mode", None),
-            },
-        )
-    except Exception:
-        logger.warning("Failed to emit app_created telemetry", exc_info=True)
-
-
-@app_was_deleted.connect
-def _handle_app_deleted(sender: object, **kwargs: object) -> None:
-    try:
-        from core.telemetry.gateway import emit as gateway_emit
-        from enterprise.telemetry.contracts import TelemetryCase
-
-        gateway_emit(
-            case=TelemetryCase.APP_DELETED,
-            context={"tenant_id": str(getattr(sender, "tenant_id", "") or "")},
-            payload={"app_id": getattr(sender, "id", None)},
-        )
-    except Exception:
-        logger.warning("Failed to emit app_deleted telemetry", exc_info=True)
-
-
-@app_was_updated.connect
-def _handle_app_updated(sender: object, **kwargs: object) -> None:
-    try:
-        from core.telemetry.gateway import emit as gateway_emit
-        from enterprise.telemetry.contracts import TelemetryCase
-
-        gateway_emit(
-            case=TelemetryCase.APP_UPDATED,
-            context={"tenant_id": str(getattr(sender, "tenant_id", "") or "")},
-            payload={"app_id": getattr(sender, "id", None)},
-        )
-    except Exception:
-        logger.warning("Failed to emit app_updated telemetry", exc_info=True)
-
-
-@feedback_was_created.connect
-def _handle_feedback_created(sender: object, **kwargs: object) -> None:
-    try:
-        from core.telemetry.gateway import emit as gateway_emit
-        from enterprise.telemetry.contracts import TelemetryCase
-
-        tenant_id = str(kwargs.get("tenant_id", "") or "")
-        gateway_emit(
-            case=TelemetryCase.FEEDBACK_CREATED,
-            context={"tenant_id": tenant_id},
-            payload={
-                "message_id": getattr(sender, "message_id", None),
-                "app_id": getattr(sender, "app_id", None),
-                "conversation_id": getattr(sender, "conversation_id", None),
-                "from_end_user_id": getattr(sender, "from_end_user_id", None),
-                "from_account_id": getattr(sender, "from_account_id", None),
-                "rating": getattr(sender, "rating", None),
-                "from_source": getattr(sender, "from_source", None),
-                "content": getattr(sender, "content", None),
-            },
-        )
-    except Exception:
-        logger.warning("Failed to emit feedback_created telemetry", exc_info=True)

api/enterprise/telemetry/exporter.py

@@ -1,284 +0,0 @@
-"""Enterprise OTEL exporter — shared by EnterpriseOtelTrace, event handlers, and direct instrumentation.
-
-Uses dedicated TracerProvider and MeterProvider instances (configurable sampling,
-independent from ext_otel.py infrastructure).
-
-Initialized once during Flask extension init (single-threaded via ext_enterprise_telemetry.py).
-Accessed via ``ext_enterprise_telemetry.get_enterprise_exporter()`` from any thread/process.
-"""
-
-import logging
-import socket
-import uuid
-from datetime import datetime
-from typing import Any, cast
-
-from opentelemetry import trace
-from opentelemetry.context import Context
-from opentelemetry.exporter.otlp.proto.grpc.metric_exporter import OTLPMetricExporter as GRPCMetricExporter
-from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter as GRPCSpanExporter
-from opentelemetry.exporter.otlp.proto.http.metric_exporter import OTLPMetricExporter as HTTPMetricExporter
-from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter as HTTPSpanExporter
-from opentelemetry.sdk.metrics import MeterProvider
-from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
-from opentelemetry.sdk.resources import Resource
-from opentelemetry.sdk.trace import TracerProvider
-from opentelemetry.sdk.trace.export import BatchSpanProcessor
-from opentelemetry.sdk.trace.sampling import ParentBasedTraceIdRatio
-from opentelemetry.semconv.resource import ResourceAttributes
-from opentelemetry.trace import SpanContext, TraceFlags
-from opentelemetry.util.types import Attributes, AttributeValue
-
-from configs import dify_config
-from enterprise.telemetry.entities import EnterpriseTelemetryCounter, EnterpriseTelemetryHistogram
-from enterprise.telemetry.id_generator import (
-    CorrelationIdGenerator,
-    compute_deterministic_span_id,
-    set_correlation_id,
-    set_span_id_source,
-)
-
-logger = logging.getLogger(__name__)
-
-
-def is_enterprise_telemetry_enabled() -> bool:
-    return bool(dify_config.ENTERPRISE_ENABLED and dify_config.ENTERPRISE_TELEMETRY_ENABLED)
-
-
-def _parse_otlp_headers(raw: str) -> dict[str, str]:
-    """Parse ``key=value,key2=value2`` into a dict."""
-    if not raw:
-        return {}
-    headers: dict[str, str] = {}
-    for pair in raw.split(","):
-        if "=" not in pair:
-            continue
-        k, v = pair.split("=", 1)
-        headers[k.strip()] = v.strip()
-    return headers
-
-
-def _datetime_to_ns(dt: datetime) -> int:
-    """Convert a datetime to nanoseconds since epoch (OTEL convention)."""
-    return int(dt.timestamp() * 1_000_000_000)
-
-
-class _ExporterFactory:
-    def __init__(self, protocol: str, endpoint: str, headers: dict[str, str], insecure: bool):
-        self._protocol = protocol
-        self._endpoint = endpoint
-        self._headers = headers
-        self._grpc_headers = tuple(headers.items()) if headers else None
-        self._http_headers = headers or None
-        self._insecure = insecure
-
-    def create_trace_exporter(self) -> HTTPSpanExporter | GRPCSpanExporter:
-        if self._protocol == "grpc":
-            return GRPCSpanExporter(
-                endpoint=self._endpoint or None,
-                headers=self._grpc_headers,
-                insecure=self._insecure,
-            )
-        trace_endpoint = f"{self._endpoint}/v1/traces" if self._endpoint else ""
-        return HTTPSpanExporter(endpoint=trace_endpoint or None, headers=self._http_headers)
-
-    def create_metric_exporter(self) -> HTTPMetricExporter | GRPCMetricExporter:
-        if self._protocol == "grpc":
-            return GRPCMetricExporter(
-                endpoint=self._endpoint or None,
-                headers=self._grpc_headers,
-                insecure=self._insecure,
-            )
-        metric_endpoint = f"{self._endpoint}/v1/metrics" if self._endpoint else ""
-        return HTTPMetricExporter(endpoint=metric_endpoint or None, headers=self._http_headers)
-
-
-class EnterpriseExporter:
-    """Shared OTEL exporter for all enterprise telemetry.
-
-    ``export_span`` creates spans with optional real timestamps, deterministic
-    span/trace IDs, and cross-workflow parent linking.
-    ``increment_counter`` / ``record_histogram`` emit OTEL metrics at 100% accuracy.
-    """
-
-    def __init__(self, config: object) -> None:
-        endpoint: str = getattr(config, "ENTERPRISE_OTLP_ENDPOINT", "")
-        headers_raw: str = getattr(config, "ENTERPRISE_OTLP_HEADERS", "")
-        protocol: str = (getattr(config, "ENTERPRISE_OTLP_PROTOCOL", "http") or "http").lower()
-        service_name: str = getattr(config, "ENTERPRISE_SERVICE_NAME", "dify")
-        sampling_rate: float = getattr(config, "ENTERPRISE_OTEL_SAMPLING_RATE", 1.0)
-        self.include_content: bool = getattr(config, "ENTERPRISE_INCLUDE_CONTENT", True)
-        api_key: str = getattr(config, "ENTERPRISE_OTLP_API_KEY", "")
-
-        # Auto-detect TLS: https:// uses secure, everything else is insecure
-        insecure = not endpoint.startswith("https://")
-
-        resource = Resource(
-            attributes={
-                ResourceAttributes.SERVICE_NAME: service_name,
-                ResourceAttributes.HOST_NAME: socket.gethostname(),
-            }
-        )
-        sampler = ParentBasedTraceIdRatio(sampling_rate)
-        id_generator = CorrelationIdGenerator()
-        self._tracer_provider = TracerProvider(resource=resource, sampler=sampler, id_generator=id_generator)
-
-        headers = _parse_otlp_headers(headers_raw)
-        if api_key:
-            if "authorization" in headers:
-                logger.warning(
-                    "ENTERPRISE_OTLP_API_KEY is set but ENTERPRISE_OTLP_HEADERS also contains "
-                    "'authorization'; the API key will take precedence."
-                )
-            headers["authorization"] = f"Bearer {api_key}"
-        factory = _ExporterFactory(protocol, endpoint, headers, insecure=insecure)
-
-        trace_exporter = factory.create_trace_exporter()
-        self._tracer_provider.add_span_processor(BatchSpanProcessor(trace_exporter))
-        self._tracer = self._tracer_provider.get_tracer("dify.enterprise")
-
-        metric_exporter = factory.create_metric_exporter()
-        self._meter_provider = MeterProvider(
-            resource=resource,
-            metric_readers=[PeriodicExportingMetricReader(metric_exporter)],
-        )
-        meter = self._meter_provider.get_meter("dify.enterprise")
-        self._counters = {
-            EnterpriseTelemetryCounter.TOKENS: meter.create_counter("dify.tokens.total", unit="{token}"),
-            EnterpriseTelemetryCounter.INPUT_TOKENS: meter.create_counter("dify.tokens.input", unit="{token}"),
-            EnterpriseTelemetryCounter.OUTPUT_TOKENS: meter.create_counter("dify.tokens.output", unit="{token}"),
-            EnterpriseTelemetryCounter.REQUESTS: meter.create_counter("dify.requests.total", unit="{request}"),
-            EnterpriseTelemetryCounter.ERRORS: meter.create_counter("dify.errors.total", unit="{error}"),
-            EnterpriseTelemetryCounter.FEEDBACK: meter.create_counter("dify.feedback.total", unit="{feedback}"),
-            EnterpriseTelemetryCounter.DATASET_RETRIEVALS: meter.create_counter(
-                "dify.dataset.retrievals.total", unit="{retrieval}"
-            ),
-            EnterpriseTelemetryCounter.APP_CREATED: meter.create_counter("dify.app.created.total", unit="{app}"),
-            EnterpriseTelemetryCounter.APP_UPDATED: meter.create_counter("dify.app.updated.total", unit="{app}"),
-            EnterpriseTelemetryCounter.APP_DELETED: meter.create_counter("dify.app.deleted.total", unit="{app}"),
-        }
-        self._histograms = {
-            EnterpriseTelemetryHistogram.WORKFLOW_DURATION: meter.create_histogram("dify.workflow.duration", unit="s"),
-            EnterpriseTelemetryHistogram.NODE_DURATION: meter.create_histogram("dify.node.duration", unit="s"),
-            EnterpriseTelemetryHistogram.MESSAGE_DURATION: meter.create_histogram("dify.message.duration", unit="s"),
-            EnterpriseTelemetryHistogram.MESSAGE_TTFT: meter.create_histogram(
-                "dify.message.time_to_first_token", unit="s"
-            ),
-            EnterpriseTelemetryHistogram.TOOL_DURATION: meter.create_histogram("dify.tool.duration", unit="s"),
-            EnterpriseTelemetryHistogram.PROMPT_GENERATION_DURATION: meter.create_histogram(
-                "dify.prompt_generation.duration", unit="s"
-            ),
-        }
-
-    def export_span(
-        self,
-        name: str,
-        attributes: dict[str, Any],
-        correlation_id: str | None = None,
-        span_id_source: str | None = None,
-        start_time: datetime | None = None,
-        end_time: datetime | None = None,
-        trace_correlation_override: str | None = None,
-        parent_span_id_source: str | None = None,
-    ) -> None:
-        """Export an OTEL span with optional deterministic IDs and real timestamps.
-
-        Args:
-            name: Span operation name.
-            attributes: Span attributes dict.
-            correlation_id: Source for trace_id derivation (groups spans in one trace).
-            span_id_source: Source for deterministic span_id (e.g. workflow_run_id or node_execution_id).
-            start_time: Real span start time. When None, uses current time.
-            end_time: Real span end time. When None, span ends immediately.
-            trace_correlation_override: Override trace_id source (for cross-workflow linking).
-                When set, trace_id is derived from this instead of ``correlation_id``.
-            parent_span_id_source: Override parent span_id source (for cross-workflow linking).
-                When set, parent span_id is derived from this value. When None and
-                ``correlation_id`` is set, parent is the workflow root span.
-        """
-        effective_trace_correlation = trace_correlation_override or correlation_id
-        set_correlation_id(effective_trace_correlation)
-        set_span_id_source(span_id_source)
-
-        try:
-            parent_context: Context | None = None
-            # A span is the "root" of its correlation group when span_id_source == correlation_id
-            # (i.e. a workflow root span).  All other spans are children.
-            if parent_span_id_source:
-                # Cross-workflow linking: parent is an explicit span (e.g. tool node in outer workflow)
-                parent_span_id = compute_deterministic_span_id(parent_span_id_source)
-                try:
-                    parent_trace_id = int(uuid.UUID(effective_trace_correlation)) if effective_trace_correlation else 0
-                except (ValueError, AttributeError):
-                    logger.warning(
-                        "Invalid trace correlation UUID for cross-workflow link: %s, span=%s",
-                        effective_trace_correlation,
-                        name,
-                    )
-                    parent_trace_id = 0
-                if parent_trace_id:
-                    parent_span_context = SpanContext(
-                        trace_id=parent_trace_id,
-                        span_id=parent_span_id,
-                        is_remote=True,
-                        trace_flags=TraceFlags(TraceFlags.SAMPLED),
-                    )
-                    parent_context = trace.set_span_in_context(trace.NonRecordingSpan(parent_span_context))
-            elif correlation_id and correlation_id != span_id_source:
-                # Child span: parent is the correlation-group root (workflow root span)
-                parent_span_id = compute_deterministic_span_id(correlation_id)
-                try:
-                    parent_trace_id = int(uuid.UUID(effective_trace_correlation or correlation_id))
-                except (ValueError, AttributeError):
-                    logger.warning(
-                        "Invalid trace correlation UUID for child span link: %s, span=%s",
-                        effective_trace_correlation or correlation_id,
-                        name,
-                    )
-                    parent_trace_id = 0
-                if parent_trace_id:
-                    parent_span_context = SpanContext(
-                        trace_id=parent_trace_id,
-                        span_id=parent_span_id,
-                        is_remote=True,
-                        trace_flags=TraceFlags(TraceFlags.SAMPLED),
-                    )
-                    parent_context = trace.set_span_in_context(trace.NonRecordingSpan(parent_span_context))
-
-            span_start_time = _datetime_to_ns(start_time) if start_time is not None else None
-            span_end_on_exit = end_time is None
-
-            with self._tracer.start_as_current_span(
-                name,
-                context=parent_context,
-                start_time=span_start_time,
-                end_on_exit=span_end_on_exit,
-            ) as span:
-                for key, value in attributes.items():
-                    if value is not None:
-                        span.set_attribute(key, value)
-                if end_time is not None:
-                    span.end(end_time=_datetime_to_ns(end_time))
-        except Exception:
-            logger.exception("Failed to export span %s", name)
-        finally:
-            set_correlation_id(None)
-            set_span_id_source(None)
-
-    def increment_counter(
-        self, name: EnterpriseTelemetryCounter, value: int, labels: dict[str, AttributeValue]
-    ) -> None:
-        counter = self._counters.get(name)
-        if counter:
-            counter.add(value, cast(Attributes, labels))
-
-    def record_histogram(
-        self, name: EnterpriseTelemetryHistogram, value: float, labels: dict[str, AttributeValue]
-    ) -> None:
-        histogram = self._histograms.get(name)
-        if histogram:
-            histogram.record(value, cast(Attributes, labels))
-
-    def shutdown(self) -> None:
-        self._tracer_provider.shutdown()
-        self._meter_provider.shutdown()

api/enterprise/telemetry/id_generator.py

@@ -1,76 +0,0 @@
-"""Custom OTEL ID Generator for correlation-based trace/span ID derivation.
-
-Uses contextvars for thread-safe correlation_id -> trace_id mapping.
-When a span_id_source is set, the span_id is derived deterministically
-from that value, enabling any span to reference another as parent
-without depending on span creation order.
-"""
-
-import random
-import uuid
-from contextvars import ContextVar
-from typing import cast
-
-from opentelemetry.sdk.trace.id_generator import IdGenerator
-
-_correlation_id_context: ContextVar[str | None] = ContextVar("correlation_id", default=None)
-_span_id_source_context: ContextVar[str | None] = ContextVar("span_id_source", default=None)
-
-
-def set_correlation_id(correlation_id: str | None) -> None:
-    _correlation_id_context.set(correlation_id)
-
-
-def get_correlation_id() -> str | None:
-    return _correlation_id_context.get()
-
-
-def set_span_id_source(source_id: str | None) -> None:
-    """Set the source for deterministic span_id generation.
-
-    When set, ``generate_span_id()`` derives the span_id from this value
-    (lower 64 bits of the UUID).  Pass the ``workflow_run_id`` for workflow
-    root spans or ``node_execution_id`` for node spans.
-    """
-    _span_id_source_context.set(source_id)
-
-
-def compute_deterministic_span_id(source_id: str) -> int:
-    """Derive a deterministic span_id from any UUID string.
-
-    Uses the lower 64 bits of the UUID, guaranteeing non-zero output
-    (OTEL requires span_id != 0).
-    """
-    span_id = cast(int, uuid.UUID(source_id).int) & ((1 << 64) - 1)
-    return span_id if span_id != 0 else 1
-
-
-class CorrelationIdGenerator(IdGenerator):
-    """ID generator that derives trace_id and optionally span_id from context.
-
-    - trace_id: always derived from correlation_id (groups all spans in one trace)
-    - span_id: derived from span_id_source when set (enables deterministic
-      parent-child linking), otherwise random
-    """
-
-    def generate_trace_id(self) -> int:
-        correlation_id = _correlation_id_context.get()
-        if correlation_id:
-            try:
-                return cast(int, uuid.UUID(correlation_id).int)
-            except (ValueError, AttributeError):
-                pass
-        return random.getrandbits(128)
-
-    def generate_span_id(self) -> int:
-        source = _span_id_source_context.get()
-        if source:
-            try:
-                return compute_deterministic_span_id(source)
-            except (ValueError, AttributeError):
-                pass
-
-        span_id = random.getrandbits(64)
-        while span_id == 0:
-            span_id = random.getrandbits(64)
-        return span_id

api/enterprise/telemetry/metric_handler.py

@@ -1,381 +0,0 @@
-"""Enterprise metric/log event handler.
-
-This module processes metric and log telemetry events after they've been
-dequeued from the enterprise_telemetry Celery queue. It handles case routing,
-idempotency checking, and payload rehydration.
-"""
-
-from __future__ import annotations
-
-import json
-import logging
-from typing import Any
-
-from enterprise.telemetry.contracts import TelemetryCase, TelemetryEnvelope
-from extensions.ext_redis import redis_client
-from extensions.ext_storage import storage
-
-logger = logging.getLogger(__name__)
-
-
-class EnterpriseMetricHandler:
-    """Handler for enterprise metric and log telemetry events.
-
-    Processes envelopes from the enterprise_telemetry queue, routing each
-    case to the appropriate handler method. Implements idempotency checking
-    and payload rehydration with fallback.
-    """
-
-    def _increment_diagnostic_counter(self, counter_name: str, labels: dict[str, str] | None = None) -> None:
-        """Increment a diagnostic counter for operational monitoring.
-
-        Args:
-            counter_name: Name of the counter (e.g., 'processed_total', 'deduped_total').
-            labels: Optional labels for the counter.
-        """
-        try:
-            from extensions.ext_enterprise_telemetry import get_enterprise_exporter
-
-            exporter = get_enterprise_exporter()
-            if not exporter:
-                return
-
-            full_counter_name = f"enterprise_telemetry.handler.{counter_name}"
-            logger.debug(
-                "Diagnostic counter: %s, labels=%s",
-                full_counter_name,
-                labels or {},
-            )
-        except Exception:
-            logger.debug("Failed to increment diagnostic counter: %s", counter_name, exc_info=True)
-
-    def handle(self, envelope: TelemetryEnvelope) -> None:
-        """Main entry point for processing telemetry envelopes.
-
-        Args:
-            envelope: The telemetry envelope to process.
-        """
-        # Check for duplicate events
-        if self._is_duplicate(envelope):
-            logger.debug(
-                "Skipping duplicate event: tenant_id=%s, event_id=%s",
-                envelope.tenant_id,
-                envelope.event_id,
-            )
-            self._increment_diagnostic_counter("deduped_total")
-            return
-
-        # Route to appropriate handler based on case
-        case = envelope.case
-        if case == TelemetryCase.APP_CREATED:
-            self._on_app_created(envelope)
-            self._increment_diagnostic_counter("processed_total", {"case": "app_created"})
-        elif case == TelemetryCase.APP_UPDATED:
-            self._on_app_updated(envelope)
-            self._increment_diagnostic_counter("processed_total", {"case": "app_updated"})
-        elif case == TelemetryCase.APP_DELETED:
-            self._on_app_deleted(envelope)
-            self._increment_diagnostic_counter("processed_total", {"case": "app_deleted"})
-        elif case == TelemetryCase.FEEDBACK_CREATED:
-            self._on_feedback_created(envelope)
-            self._increment_diagnostic_counter("processed_total", {"case": "feedback_created"})
-        elif case == TelemetryCase.MESSAGE_RUN:
-            self._on_message_run(envelope)
-            self._increment_diagnostic_counter("processed_total", {"case": "message_run"})
-        elif case == TelemetryCase.TOOL_EXECUTION:
-            self._on_tool_execution(envelope)
-            self._increment_diagnostic_counter("processed_total", {"case": "tool_execution"})
-        elif case == TelemetryCase.MODERATION_CHECK:
-            self._on_moderation_check(envelope)
-            self._increment_diagnostic_counter("processed_total", {"case": "moderation_check"})
-        elif case == TelemetryCase.SUGGESTED_QUESTION:
-            self._on_suggested_question(envelope)
-            self._increment_diagnostic_counter("processed_total", {"case": "suggested_question"})
-        elif case == TelemetryCase.DATASET_RETRIEVAL:
-            self._on_dataset_retrieval(envelope)
-            self._increment_diagnostic_counter("processed_total", {"case": "dataset_retrieval"})
-        elif case == TelemetryCase.GENERATE_NAME:
-            self._on_generate_name(envelope)
-            self._increment_diagnostic_counter("processed_total", {"case": "generate_name"})
-        elif case == TelemetryCase.PROMPT_GENERATION:
-            self._on_prompt_generation(envelope)
-            self._increment_diagnostic_counter("processed_total", {"case": "prompt_generation"})
-        else:
-            logger.warning(
-                "Unknown telemetry case: %s (tenant_id=%s, event_id=%s)",
-                case,
-                envelope.tenant_id,
-                envelope.event_id,
-            )
-
-    def _is_duplicate(self, envelope: TelemetryEnvelope) -> bool:
-        """Check if this event has already been processed.
-
-        Uses Redis with TTL for deduplication. Returns True if duplicate,
-        False if first time seeing this event.
-
-        Args:
-            envelope: The telemetry envelope to check.
-
-        Returns:
-            True if this event_id has been seen before, False otherwise.
-        """
-        dedup_key = f"telemetry:dedup:{envelope.tenant_id}:{envelope.event_id}"
-
-        try:
-            # Atomic set-if-not-exists with 1h TTL
-            # Returns True if key was set (first time), None if already exists (duplicate)
-            was_set = redis_client.set(dedup_key, b"1", nx=True, ex=3600)
-            return was_set is None
-        except Exception:
-            # Fail open: if Redis is unavailable, process the event
-            # (prefer occasional duplicate over lost data)
-            logger.warning(
-                "Redis unavailable for deduplication check, processing event anyway: %s",
-                envelope.event_id,
-                exc_info=True,
-            )
-            return False
-
-    def _rehydrate(self, envelope: TelemetryEnvelope) -> dict[str, Any]:
-        """Rehydrate payload from storage reference or inline data.
-
-        If the envelope payload is empty and metadata contains a
-        ``payload_ref``, the full payload is loaded from object storage
-        (where the gateway wrote it as JSON).  When both the inline
-        payload and storage resolution fail, a degraded-event marker
-        is emitted so the gap is observable.
-
-        Args:
-            envelope: The telemetry envelope containing payload data.
-
-        Returns:
-            The rehydrated payload dictionary, or ``{}`` on total failure.
-        """
-        payload = envelope.payload
-
-        # Resolve from object storage when the gateway offloaded a large payload.
-        if not payload and envelope.metadata:
-            payload_ref = envelope.metadata.get("payload_ref")
-            if payload_ref:
-                try:
-                    payload_bytes = storage.load(payload_ref)
-                    payload = json.loads(payload_bytes.decode("utf-8"))
-                    logger.debug("Loaded payload from storage: key=%s", payload_ref)
-                except Exception:
-                    logger.warning(
-                        "Failed to load payload from storage: key=%s, event_id=%s",
-                        payload_ref,
-                        envelope.event_id,
-                        exc_info=True,
-                    )
-
-        if not payload:
-            # Storage resolution failed or no data available — emit degraded event.
-            logger.error(
-                "Payload rehydration failed for event_id=%s, tenant_id=%s, case=%s",
-                envelope.event_id,
-                envelope.tenant_id,
-                envelope.case,
-            )
-            from enterprise.telemetry.entities import EnterpriseTelemetryEvent
-            from enterprise.telemetry.telemetry_log import emit_metric_only_event
-
-            emit_metric_only_event(
-                event_name=EnterpriseTelemetryEvent.REHYDRATION_FAILED,
-                attributes={
-                    "dify.tenant_id": envelope.tenant_id,
-                    "dify.event_id": envelope.event_id,
-                    "dify.case": envelope.case,
-                    "rehydration_failed": True,
-                },
-                tenant_id=envelope.tenant_id,
-            )
-            self._increment_diagnostic_counter("rehydration_failed_total")
-            return {}
-
-        return payload
-
-    # Stub methods for each metric/log case
-    # These will be implemented in later tasks with actual emission logic
-
-    def _on_app_created(self, envelope: TelemetryEnvelope) -> None:
-        """Handle app created event."""
-        from enterprise.telemetry.entities import EnterpriseTelemetryCounter, EnterpriseTelemetryEvent
-        from enterprise.telemetry.telemetry_log import emit_metric_only_event
-        from extensions.ext_enterprise_telemetry import get_enterprise_exporter
-
-        exporter = get_enterprise_exporter()
-        if not exporter:
-            logger.debug("No exporter available for APP_CREATED: event_id=%s", envelope.event_id)
-            return
-
-        payload = self._rehydrate(envelope)
-        if not payload:
-            return
-
-        attrs = {
-            "dify.app.id": payload.get("app_id"),
-            "dify.tenant_id": envelope.tenant_id,
-            "dify.event.id": envelope.event_id,
-            "dify.app.mode": payload.get("mode"),
-        }
-
-        emit_metric_only_event(
-            event_name=EnterpriseTelemetryEvent.APP_CREATED,
-            attributes=attrs,
-            tenant_id=envelope.tenant_id,
-        )
-        exporter.increment_counter(
-            EnterpriseTelemetryCounter.APP_CREATED,
-            1,
-            {
-                "tenant_id": envelope.tenant_id,
-                "app_id": str(payload.get("app_id", "")),
-                "mode": str(payload.get("mode", "")),
-            },
-        )
-
-    def _on_app_updated(self, envelope: TelemetryEnvelope) -> None:
-        """Handle app updated event."""
-        from enterprise.telemetry.entities import EnterpriseTelemetryCounter, EnterpriseTelemetryEvent
-        from enterprise.telemetry.telemetry_log import emit_metric_only_event
-        from extensions.ext_enterprise_telemetry import get_enterprise_exporter
-
-        exporter = get_enterprise_exporter()
-        if not exporter:
-            logger.debug("No exporter available for APP_UPDATED: event_id=%s", envelope.event_id)
-            return
-
-        payload = self._rehydrate(envelope)
-        if not payload:
-            return
-
-        attrs = {
-            "dify.app.id": payload.get("app_id"),
-            "dify.tenant_id": envelope.tenant_id,
-            "dify.event.id": envelope.event_id,
-        }
-
-        emit_metric_only_event(
-            event_name=EnterpriseTelemetryEvent.APP_UPDATED,
-            attributes=attrs,
-            tenant_id=envelope.tenant_id,
-        )
-        exporter.increment_counter(
-            EnterpriseTelemetryCounter.APP_UPDATED,
-            1,
-            {
-                "tenant_id": envelope.tenant_id,
-                "app_id": str(payload.get("app_id", "")),
-            },
-        )
-
-    def _on_app_deleted(self, envelope: TelemetryEnvelope) -> None:
-        """Handle app deleted event."""
-        from enterprise.telemetry.entities import EnterpriseTelemetryCounter, EnterpriseTelemetryEvent
-        from enterprise.telemetry.telemetry_log import emit_metric_only_event
-        from extensions.ext_enterprise_telemetry import get_enterprise_exporter
-
-        exporter = get_enterprise_exporter()
-        if not exporter:
-            logger.debug("No exporter available for APP_DELETED: event_id=%s", envelope.event_id)
-            return
-
-        payload = self._rehydrate(envelope)
-        if not payload:
-            return
-
-        attrs = {
-            "dify.app.id": payload.get("app_id"),
-            "dify.tenant_id": envelope.tenant_id,
-            "dify.event.id": envelope.event_id,
-        }
-
-        emit_metric_only_event(
-            event_name=EnterpriseTelemetryEvent.APP_DELETED,
-            attributes=attrs,
-            tenant_id=envelope.tenant_id,
-        )
-        exporter.increment_counter(
-            EnterpriseTelemetryCounter.APP_DELETED,
-            1,
-            {
-                "tenant_id": envelope.tenant_id,
-                "app_id": str(payload.get("app_id", "")),
-            },
-        )
-
-    def _on_feedback_created(self, envelope: TelemetryEnvelope) -> None:
-        """Handle feedback created event."""
-        from enterprise.telemetry.entities import EnterpriseTelemetryCounter, EnterpriseTelemetryEvent
-        from enterprise.telemetry.telemetry_log import emit_metric_only_event
-        from extensions.ext_enterprise_telemetry import get_enterprise_exporter
-
-        exporter = get_enterprise_exporter()
-        if not exporter:
-            logger.debug("No exporter available for FEEDBACK_CREATED: event_id=%s", envelope.event_id)
-            return
-
-        payload = self._rehydrate(envelope)
-        if not payload:
-            return
-
-        include_content = exporter.include_content
-        attrs: dict = {
-            "dify.message.id": payload.get("message_id"),
-            "dify.tenant_id": envelope.tenant_id,
-            "dify.event.id": envelope.event_id,
-            "dify.app_id": payload.get("app_id"),
-            "dify.conversation.id": payload.get("conversation_id"),
-            "gen_ai.user.id": payload.get("from_end_user_id") or payload.get("from_account_id"),
-            "dify.feedback.rating": payload.get("rating"),
-            "dify.feedback.from_source": payload.get("from_source"),
-        }
-        if include_content:
-            attrs["dify.feedback.content"] = payload.get("content")
-
-        user_id = payload.get("from_end_user_id") or payload.get("from_account_id")
-        emit_metric_only_event(
-            event_name=EnterpriseTelemetryEvent.FEEDBACK_CREATED,
-            attributes=attrs,
-            tenant_id=envelope.tenant_id,
-            user_id=str(user_id or ""),
-        )
-        exporter.increment_counter(
-            EnterpriseTelemetryCounter.FEEDBACK,
-            1,
-            {
-                "tenant_id": envelope.tenant_id,
-                "app_id": str(payload.get("app_id", "")),
-                "rating": str(payload.get("rating", "")),
-            },
-        )
-
-    def _on_message_run(self, envelope: TelemetryEnvelope) -> None:
-        """Handle message run event (stub)."""
-        logger.debug("Processing MESSAGE_RUN: event_id=%s", envelope.event_id)
-
-    def _on_tool_execution(self, envelope: TelemetryEnvelope) -> None:
-        """Handle tool execution event (stub)."""
-        logger.debug("Processing TOOL_EXECUTION: event_id=%s", envelope.event_id)
-
-    def _on_moderation_check(self, envelope: TelemetryEnvelope) -> None:
-        """Handle moderation check event (stub)."""
-        logger.debug("Processing MODERATION_CHECK: event_id=%s", envelope.event_id)
-
-    def _on_suggested_question(self, envelope: TelemetryEnvelope) -> None:
-        """Handle suggested question event (stub)."""
-        logger.debug("Processing SUGGESTED_QUESTION: event_id=%s", envelope.event_id)
-
-    def _on_dataset_retrieval(self, envelope: TelemetryEnvelope) -> None:
-        """Handle dataset retrieval event (stub)."""
-        logger.debug("Processing DATASET_RETRIEVAL: event_id=%s", envelope.event_id)
-
-    def _on_generate_name(self, envelope: TelemetryEnvelope) -> None:
-        """Handle generate name event (stub)."""
-        logger.debug("Processing GENERATE_NAME: event_id=%s", envelope.event_id)
-
-    def _on_prompt_generation(self, envelope: TelemetryEnvelope) -> None:
-        """Handle prompt generation event (stub)."""
-        logger.debug("Processing PROMPT_GENERATION: event_id=%s", envelope.event_id)

api/enterprise/telemetry/telemetry_log.py

@@ -1,122 +0,0 @@
-"""Structured-log emitter for enterprise telemetry events.
-
-Emits structured JSON log lines correlated with OTEL traces via trace_id.
-Picked up by ``StructuredJSONFormatter`` → stdout/Loki/Elastic.
-"""
-
-from __future__ import annotations
-
-import logging
-import uuid
-from functools import lru_cache
-from typing import TYPE_CHECKING, Any
-
-if TYPE_CHECKING:
-    from enterprise.telemetry.entities import EnterpriseTelemetryEvent
-
-logger = logging.getLogger("dify.telemetry")
-
-
-@lru_cache(maxsize=4096)
-def compute_trace_id_hex(uuid_str: str | None) -> str:
-    """Convert a business UUID string to a 32-hex OTEL-compatible trace_id.
-
-    Returns empty string when *uuid_str* is ``None`` or invalid.
-    """
-    if not uuid_str:
-        return ""
-    normalized = uuid_str.strip().lower()
-    if len(normalized) == 32 and all(ch in "0123456789abcdef" for ch in normalized):
-        return normalized
-    try:
-        return f"{uuid.UUID(normalized).int:032x}"
-    except (ValueError, AttributeError):
-        return ""
-
-
-@lru_cache(maxsize=4096)
-def compute_span_id_hex(uuid_str: str | None) -> str:
-    if not uuid_str:
-        return ""
-    normalized = uuid_str.strip().lower()
-    if len(normalized) == 16 and all(ch in "0123456789abcdef" for ch in normalized):
-        return normalized
-    try:
-        from enterprise.telemetry.id_generator import compute_deterministic_span_id
-
-        return f"{compute_deterministic_span_id(normalized):016x}"
-    except (ValueError, AttributeError):
-        return ""
-
-
-def emit_telemetry_log(
-    *,
-    event_name: str | EnterpriseTelemetryEvent,
-    attributes: dict[str, Any],
-    signal: str = "metric_only",
-    trace_id_source: str | None = None,
-    span_id_source: str | None = None,
-    tenant_id: str | None = None,
-    user_id: str | None = None,
-) -> None:
-    """Emit a structured log line for a telemetry event.
-
-    Parameters
-    ----------
-    event_name:
-        Canonical event name, e.g. ``"dify.workflow.run"``.
-    attributes:
-        All event-specific attributes (already built by the caller).
-    signal:
-        ``"metric_only"`` for events with no span, ``"span_detail"``
-        for detail logs accompanying a slim span.
-    trace_id_source:
-        A UUID string (e.g. ``workflow_run_id``) used to derive a 32-hex
-        trace_id for cross-signal correlation.
-    tenant_id:
-        Tenant identifier (for the ``IdentityContextFilter``).
-    user_id:
-        User identifier (for the ``IdentityContextFilter``).
-    """
-    if not logger.isEnabledFor(logging.INFO):
-        return
-    attrs = {
-        "dify.event.name": event_name,
-        "dify.event.signal": signal,
-        **attributes,
-    }
-
-    extra: dict[str, Any] = {"attributes": attrs}
-
-    trace_id_hex = compute_trace_id_hex(trace_id_source)
-    if trace_id_hex:
-        extra["trace_id"] = trace_id_hex
-    span_id_hex = compute_span_id_hex(span_id_source)
-    if span_id_hex:
-        extra["span_id"] = span_id_hex
-    if tenant_id:
-        extra["tenant_id"] = tenant_id
-    if user_id:
-        extra["user_id"] = user_id
-
-    logger.info("telemetry.%s", signal, extra=extra)
-
-
-def emit_metric_only_event(
-    *,
-    event_name: str | EnterpriseTelemetryEvent,
-    attributes: dict[str, Any],
-    trace_id_source: str | None = None,
-    span_id_source: str | None = None,
-    tenant_id: str | None = None,
-    user_id: str | None = None,
-) -> None:
-    emit_telemetry_log(
-        event_name=event_name,
-        attributes=attributes,
-        signal="metric_only",
-        trace_id_source=trace_id_source,
-        span_id_source=span_id_source,
-        tenant_id=tenant_id,
-        user_id=user_id,
-    )

api/events/app_event.py

@@ -3,12 +3,6 @@ from blinker import signal
 # sender: app
 app_was_created = signal("app-was-created")
 
-# sender: app
-app_was_deleted = signal("app-was-deleted")
-
-# sender: app
-app_was_updated = signal("app-was-updated")
-
 # sender: app, kwargs: app_model_config
 app_model_config_was_updated = signal("app-model-config-was-updated")
 

api/events/feedback_event.py

@@ -1,4 +0,0 @@
-from blinker import signal
-
-# sender: MessageFeedback, kwargs: tenant_id
-feedback_was_created = signal("feedback-was-created")

api/extensions/ext_celery.py

@@ -184,8 +184,6 @@ def init_app(app: DifyApp) -> Celery:
             "task": "schedule.trigger_provider_refresh_task.trigger_provider_refresh",
             "schedule": timedelta(minutes=dify_config.TRIGGER_PROVIDER_REFRESH_INTERVAL),
         }
-    if dify_config.ENTERPRISE_TELEMETRY_ENABLED:
-        imports.append("tasks.enterprise_telemetry_task")
     celery_app.conf.update(beat_schedule=beat_schedule, imports=imports)
 
     return celery_app

api/extensions/ext_enterprise_telemetry.py

@@ -1,50 +0,0 @@
-"""Flask extension for enterprise telemetry lifecycle management.
-
-Initializes the EnterpriseExporter singleton during ``create_app()``
-(single-threaded), registers blinker event handlers, and hooks atexit
-for graceful shutdown.
-
-Skipped entirely when ``ENTERPRISE_ENABLED`` and ``ENTERPRISE_TELEMETRY_ENABLED``
-are false (``is_enabled()`` gate).
-"""
-
-from __future__ import annotations
-
-import atexit
-import logging
-from typing import TYPE_CHECKING
-
-from configs import dify_config
-
-if TYPE_CHECKING:
-    from dify_app import DifyApp
-    from enterprise.telemetry.exporter import EnterpriseExporter
-
-logger = logging.getLogger(__name__)
-
-_exporter: EnterpriseExporter | None = None
-
-
-def is_enabled() -> bool:
-    return bool(dify_config.ENTERPRISE_ENABLED and dify_config.ENTERPRISE_TELEMETRY_ENABLED)
-
-
-def init_app(app: DifyApp) -> None:
-    global _exporter
-
-    if not is_enabled():
-        return
-
-    from enterprise.telemetry.exporter import EnterpriseExporter
-
-    _exporter = EnterpriseExporter(dify_config)
-    atexit.register(_exporter.shutdown)
-
-    # Import to trigger @signal.connect decorator registration
-    import enterprise.telemetry.event_handlers  # noqa: F401  # type: ignore[reportUnusedImport]
-
-    logger.info("Enterprise telemetry initialized")
-
-
-def get_enterprise_exporter() -> EnterpriseExporter | None:
-    return _exporter

api/extensions/ext_otel.py

@@ -59,24 +59,16 @@ def init_app(app: DifyApp):
     protocol = (dify_config.OTEL_EXPORTER_OTLP_PROTOCOL or "").lower()
     if dify_config.OTEL_EXPORTER_TYPE == "otlp":
         if protocol == "grpc":
-            # Auto-detect TLS: https:// uses secure, everything else is insecure
-            endpoint = dify_config.OTLP_BASE_ENDPOINT
-            insecure = not endpoint.startswith("https://")
-
             exporter = GRPCSpanExporter(
-                endpoint=endpoint,
+                endpoint=dify_config.OTLP_BASE_ENDPOINT,
                 # Header field names must consist of lowercase letters, check RFC7540
-                headers=(
-                    (("authorization", f"Bearer {dify_config.OTLP_API_KEY}"),) if dify_config.OTLP_API_KEY else None
-                ),
-                insecure=insecure,
+                headers=(("authorization", f"Bearer {dify_config.OTLP_API_KEY}"),),
+                insecure=True,
             )
             metric_exporter = GRPCMetricExporter(
-                endpoint=endpoint,
-                headers=(
-                    (("authorization", f"Bearer {dify_config.OTLP_API_KEY}"),) if dify_config.OTLP_API_KEY else None
-                ),
-                insecure=insecure,
+                endpoint=dify_config.OTLP_BASE_ENDPOINT,
+                headers=(("authorization", f"Bearer {dify_config.OTLP_API_KEY}"),),
+                insecure=True,
             )
         else:
             headers = {"Authorization": f"Bearer {dify_config.OTLP_API_KEY}"} if dify_config.OTLP_API_KEY else None

api/extensions/otel/parser/__init__.py

@@ -5,7 +5,7 @@ This module provides parsers that extract node-specific metadata and set
 OpenTelemetry span attributes according to semantic conventions.
 """
 
-from extensions.otel.parser.base import DefaultNodeOTelParser, NodeOTelParser, safe_json_dumps, should_include_content
+from extensions.otel.parser.base import DefaultNodeOTelParser, NodeOTelParser, safe_json_dumps
 from extensions.otel.parser.llm import LLMNodeOTelParser
 from extensions.otel.parser.retrieval import RetrievalNodeOTelParser
 from extensions.otel.parser.tool import ToolNodeOTelParser
@@ -17,5 +17,4 @@ __all__ = [
     "RetrievalNodeOTelParser",
     "ToolNodeOTelParser",
     "safe_json_dumps",
-    "should_include_content",
 ]

api/extensions/otel/parser/base.py

@@ -1,10 +1,5 @@
 """
 Base parser interface and utilities for OpenTelemetry node parsers.
-
-Content gating: ``should_include_content()`` controls whether content-bearing
-span attributes (inputs, outputs, prompts, completions, documents) are written.
-Gate is only active in EE (``ENTERPRISE_ENABLED=True``) when
-``ENTERPRISE_INCLUDE_CONTENT=False``; CE behaviour is unchanged.
 """
 
 import json
@@ -14,7 +9,6 @@ from opentelemetry.trace import Span
 from opentelemetry.trace.status import Status, StatusCode
 from pydantic import BaseModel
 
-from configs import dify_config
 from core.file.models import File
 from core.variables import Segment
 from core.workflow.enums import NodeType
@@ -23,17 +17,6 @@ from core.workflow.nodes.base.node import Node
 from extensions.otel.semconv.gen_ai import ChainAttributes, GenAIAttributes
 
 
-def should_include_content() -> bool:
-    """Return True if content should be written to spans.
-
-    CE (ENTERPRISE_ENABLED=False): always True — no behaviour change.
-    EE: follows ENTERPRISE_INCLUDE_CONTENT (default True).
-    """
-    if not dify_config.ENTERPRISE_ENABLED:
-        return True
-    return dify_config.ENTERPRISE_INCLUDE_CONTENT
-
-
 def safe_json_dumps(obj: Any, ensure_ascii: bool = False) -> str:
     """
     Safely serialize objects to JSON, handling non-serializable types.
@@ -122,11 +105,10 @@ class DefaultNodeOTelParser:
         # Extract inputs and outputs from result_event
         if result_event and result_event.node_run_result:
             node_run_result = result_event.node_run_result
-            if should_include_content():
-                if node_run_result.inputs:
-                    span.set_attribute(ChainAttributes.INPUT_VALUE, safe_json_dumps(node_run_result.inputs))
-                if node_run_result.outputs:
-                    span.set_attribute(ChainAttributes.OUTPUT_VALUE, safe_json_dumps(node_run_result.outputs))
+            if node_run_result.inputs:
+                span.set_attribute(ChainAttributes.INPUT_VALUE, safe_json_dumps(node_run_result.inputs))
+            if node_run_result.outputs:
+                span.set_attribute(ChainAttributes.OUTPUT_VALUE, safe_json_dumps(node_run_result.outputs))
 
         if error:
             span.record_exception(error)

api/extensions/otel/parser/llm.py

@@ -10,7 +10,7 @@ from opentelemetry.trace import Span
 
 from core.workflow.graph_events import GraphNodeEventBase
 from core.workflow.nodes.base.node import Node
-from extensions.otel.parser.base import DefaultNodeOTelParser, safe_json_dumps, should_include_content
+from extensions.otel.parser.base import DefaultNodeOTelParser, safe_json_dumps
 from extensions.otel.semconv.gen_ai import LLMAttributes
 
 logger = logging.getLogger(__name__)
@@ -132,19 +132,24 @@ class LLMNodeOTelParser:
             span.set_attribute(LLMAttributes.USAGE_OUTPUT_TOKENS, completion_tokens)
             span.set_attribute(LLMAttributes.USAGE_TOTAL_TOKENS, total_tokens)
 
-        # Prompts and completion — gated by content policy
-        if should_include_content():
-            prompts = process_data.get("prompts", [])
-            if prompts:
-                prompts_json = safe_json_dumps(prompts)
-                span.set_attribute(LLMAttributes.PROMPT, prompts_json)
+        # Prompts and completion
+        prompts = process_data.get("prompts", [])
+        if prompts:
+            prompts_json = safe_json_dumps(prompts)
+            span.set_attribute(LLMAttributes.PROMPT, prompts_json)
 
-            text_output = str(outputs.get("text", ""))
-            if text_output:
-                span.set_attribute(LLMAttributes.COMPLETION, text_output)
+        text_output = str(outputs.get("text", ""))
+        if text_output:
+            span.set_attribute(LLMAttributes.COMPLETION, text_output)
 
-            # Structured input/output messages
-            gen_ai_input_message = _format_input_messages(process_data)
-            gen_ai_output_message = _format_output_messages(outputs)
-            span.set_attribute(LLMAttributes.INPUT_MESSAGE, gen_ai_input_message)
-            span.set_attribute(LLMAttributes.OUTPUT_MESSAGE, gen_ai_output_message)
+        # Finish reason
+        finish_reason = outputs.get("finish_reason") or ""
+        if finish_reason:
+            span.set_attribute(LLMAttributes.RESPONSE_FINISH_REASON, finish_reason)
+
+        # Structured input/output messages
+        gen_ai_input_message = _format_input_messages(process_data)
+        gen_ai_output_message = _format_output_messages(outputs)
+
+        span.set_attribute(LLMAttributes.INPUT_MESSAGE, gen_ai_input_message)
+        span.set_attribute(LLMAttributes.OUTPUT_MESSAGE, gen_ai_output_message)

api/extensions/otel/parser/retrieval.py

@@ -11,7 +11,7 @@ from opentelemetry.trace import Span
 from core.variables import Segment
 from core.workflow.graph_events import GraphNodeEventBase
 from core.workflow.nodes.base.node import Node
-from extensions.otel.parser.base import DefaultNodeOTelParser, safe_json_dumps, should_include_content
+from extensions.otel.parser.base import DefaultNodeOTelParser, safe_json_dumps
 from extensions.otel.semconv.gen_ai import RetrieverAttributes
 
 logger = logging.getLogger(__name__)
@@ -83,21 +83,23 @@ class RetrievalNodeOTelParser:
         inputs = node_run_result.inputs or {}
         outputs = node_run_result.outputs or {}
 
-        # Query and documents — gated by content policy
-        if should_include_content():
-            query = str(inputs.get("query", "")) if inputs else ""
-            if query:
-                span.set_attribute(RetrieverAttributes.QUERY, query)
+        # Extract query from inputs
+        query = str(inputs.get("query", "")) if inputs else ""
+        if query:
+            span.set_attribute(RetrieverAttributes.QUERY, query)
 
-            result_value = outputs.get("result") if outputs else None
-            retrieval_documents: list[Any] = []
-            if result_value:
-                value_to_check = result_value
-                if isinstance(result_value, Segment):
-                    value_to_check = result_value.value
-                if isinstance(value_to_check, (list, Sequence)):
-                    retrieval_documents = list(value_to_check)
-            if retrieval_documents:
-                semantic_retrieval_documents = _format_retrieval_documents(retrieval_documents)
-                semantic_retrieval_documents_json = safe_json_dumps(semantic_retrieval_documents)
-                span.set_attribute(RetrieverAttributes.DOCUMENT, semantic_retrieval_documents_json)
+        # Extract and format retrieval documents from outputs
+        result_value = outputs.get("result") if outputs else None
+        retrieval_documents: list[Any] = []
+        if result_value:
+            value_to_check = result_value
+            if isinstance(result_value, Segment):
+                value_to_check = result_value.value
+
+            if isinstance(value_to_check, (list, Sequence)):
+                retrieval_documents = list(value_to_check)
+
+        if retrieval_documents:
+            semantic_retrieval_documents = _format_retrieval_documents(retrieval_documents)
+            semantic_retrieval_documents_json = safe_json_dumps(semantic_retrieval_documents)
+            span.set_attribute(RetrieverAttributes.DOCUMENT, semantic_retrieval_documents_json)

api/extensions/otel/parser/tool.py

@@ -8,7 +8,7 @@ from core.workflow.enums import WorkflowNodeExecutionMetadataKey
 from core.workflow.graph_events import GraphNodeEventBase
 from core.workflow.nodes.base.node import Node
 from core.workflow.nodes.tool.entities import ToolNodeData
-from extensions.otel.parser.base import DefaultNodeOTelParser, safe_json_dumps, should_include_content
+from extensions.otel.parser.base import DefaultNodeOTelParser, safe_json_dumps
 from extensions.otel.semconv.gen_ai import ToolAttributes
 
 
@@ -40,14 +40,8 @@ class ToolNodeOTelParser:
         if tool_info:
             span.set_attribute(ToolAttributes.TOOL_DESCRIPTION, safe_json_dumps(tool_info))
 
-        # Tool call arguments and result — gated by content policy
-        if should_include_content():
-            if result_event and result_event.node_run_result and result_event.node_run_result.inputs:
-                span.set_attribute(
-                    ToolAttributes.TOOL_CALL_ARGUMENTS, safe_json_dumps(result_event.node_run_result.inputs)
-                )
+        if result_event and result_event.node_run_result and result_event.node_run_result.inputs:
+            span.set_attribute(ToolAttributes.TOOL_CALL_ARGUMENTS, safe_json_dumps(result_event.node_run_result.inputs))
 
-            if result_event and result_event.node_run_result and result_event.node_run_result.outputs:
-                span.set_attribute(
-                    ToolAttributes.TOOL_CALL_RESULT, safe_json_dumps(result_event.node_run_result.outputs)
-                )
+        if result_event and result_event.node_run_result and result_event.node_run_result.outputs:
+            span.set_attribute(ToolAttributes.TOOL_CALL_RESULT, safe_json_dumps(result_event.node_run_result.outputs))

api/extensions/otel/semconv/dify.py

@@ -21,15 +21,3 @@ class DifySpanAttributes:
 
     INVOKE_FROM = "dify.invoke_from"
     """Invocation source, e.g. SERVICE_API, WEB_APP, DEBUGGER."""
-
-    INVOKED_BY = "dify.invoked_by"
-    """Invoked by, e.g. end_user, account, user."""
-
-    USAGE_INPUT_TOKENS = "gen_ai.usage.input_tokens"
-    """Number of input tokens (prompt tokens) used."""
-
-    USAGE_OUTPUT_TOKENS = "gen_ai.usage.output_tokens"
-    """Number of output tokens (completion tokens) generated."""
-
-    USAGE_TOTAL_TOKENS = "gen_ai.usage.total_tokens"
-    """Total number of tokens used."""

api/libs/db_migration_lock.py

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

api/migrations/versions/2025_12_25_1039-7df29de0f6be_add_credit_pool.py

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

api/migrations/versions/2026_01_17_1110-f9f6d18a37f9_add_table_explore_banner_and_trial.py

@@ -8,6 +8,7 @@ Create Date: 2026-01-017 11:10:18.079355
 from alembic import op
 import models as models
 import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
 
 # revision identifiers, used by Alembic.
 revision = 'f9f6d18a37f9'
@@ -19,7 +20,7 @@ depends_on = None
 def upgrade():
     # ### commands auto generated by Alembic - please adjust! ###
     op.create_table('account_trial_app_records',
-    sa.Column('id', models.types.StringUUID(), nullable=False),
+    sa.Column('id', models.types.StringUUID(), server_default=sa.text('uuid_generate_v4()'), nullable=False),
     sa.Column('account_id', models.types.StringUUID(), nullable=False),
     sa.Column('app_id', models.types.StringUUID(), nullable=False),
     sa.Column('count', sa.Integer(), nullable=False),
@@ -32,17 +33,17 @@ def upgrade():
         batch_op.create_index('account_trial_app_record_app_id_idx', ['app_id'], unique=False)
 
     op.create_table('exporle_banners',
-    sa.Column('id', models.types.StringUUID(), nullable=False),
+    sa.Column('id', models.types.StringUUID(), server_default=sa.text('uuid_generate_v4()'), nullable=False),
     sa.Column('content', sa.JSON(), nullable=False),
     sa.Column('link', sa.String(length=255), nullable=False),
     sa.Column('sort', sa.Integer(), nullable=False),
-    sa.Column('status', sa.String(length=255), server_default='enabled', nullable=False),
+    sa.Column('status', sa.String(length=255), server_default=sa.text("'enabled'::character varying"), nullable=False),
     sa.Column('created_at', sa.DateTime(), server_default=sa.text('CURRENT_TIMESTAMP'), nullable=False),
-    sa.Column('language', sa.String(length=255), server_default='en-US', nullable=False),
+    sa.Column('language', sa.String(length=255), server_default=sa.text("'en-US'::character varying"), nullable=False),
     sa.PrimaryKeyConstraint('id', name='exporler_banner_pkey')
     )
     op.create_table('trial_apps',
-    sa.Column('id', models.types.StringUUID(), nullable=False),
+    sa.Column('id', models.types.StringUUID(), server_default=sa.text('uuid_generate_v4()'), nullable=False),
     sa.Column('app_id', models.types.StringUUID(), nullable=False),
     sa.Column('tenant_id', models.types.StringUUID(), nullable=False),
     sa.Column('created_at', sa.DateTime(), server_default=sa.text('CURRENT_TIMESTAMP'), nullable=False),

api/models/model.py

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

api/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dify-api"
-version = "1.12.1"
+version = "1.12.0"
 requires-python = ">=3.11,<3.13"
 
 dependencies = [
@@ -22,14 +22,14 @@ dependencies = [
     "flask-sqlalchemy~=3.1.1",
     "gevent~=25.9.1",
     "gmpy2~=2.2.1",
-    "google-api-core>=2.19.1",
+    "google-api-core==2.18.0",
     "google-api-python-client==2.90.0",
-    "google-auth>=2.47.0",
+    "google-auth==2.29.0",
     "google-auth-httplib2==0.2.0",
-    "google-cloud-aiplatform>=1.123.0",
-    "googleapis-common-protos>=1.65.0",
+    "google-cloud-aiplatform==1.49.0",
+    "googleapis-common-protos==1.63.0",
     "gunicorn~=23.0.0",
-    "httpx[socks]~=0.28.0",
+    "httpx[socks]~=0.27.0",
     "jieba==0.42.1",
     "json-repair>=0.55.1",
     "jsonschema>=4.25.1",
@@ -41,23 +41,26 @@ dependencies = [
     "openpyxl~=3.1.5",
     "opik~=1.8.72",
     "litellm==1.77.1", # Pinned to avoid madoka dependency issue
-    "opentelemetry-api==1.28.0",
-    "opentelemetry-distro==0.49b0",
-    "opentelemetry-exporter-otlp==1.28.0",
-    "opentelemetry-exporter-otlp-proto-common==1.28.0",
-    "opentelemetry-exporter-otlp-proto-grpc==1.28.0",
-    "opentelemetry-exporter-otlp-proto-http==1.28.0",
-    "opentelemetry-instrumentation==0.49b0",
-    "opentelemetry-instrumentation-celery==0.49b0",
-    "opentelemetry-instrumentation-flask==0.49b0",
-    "opentelemetry-instrumentation-httpx==0.49b0",
-    "opentelemetry-instrumentation-redis==0.49b0",
-    "opentelemetry-instrumentation-sqlalchemy==0.49b0",
-    "opentelemetry-propagator-b3==1.28.0",
-    "opentelemetry-proto==1.28.0",
-    "opentelemetry-sdk==1.28.0",
-    "opentelemetry-semantic-conventions==0.49b0",
-    "opentelemetry-util-http==0.49b0",
+    "opentelemetry-api==1.27.0",
+    "opentelemetry-distro==0.48b0",
+    "opentelemetry-exporter-otlp==1.27.0",
+    "opentelemetry-exporter-otlp-proto-common==1.27.0",
+    "opentelemetry-exporter-otlp-proto-grpc==1.27.0",
+    "opentelemetry-exporter-otlp-proto-http==1.27.0",
+    "opentelemetry-instrumentation==0.48b0",
+    "opentelemetry-instrumentation-celery==0.48b0",
+    "opentelemetry-instrumentation-flask==0.48b0",
+    "opentelemetry-instrumentation-httpx==0.48b0",
+    "opentelemetry-instrumentation-redis==0.48b0",
+    "opentelemetry-instrumentation-httpx==0.48b0",
+    "opentelemetry-instrumentation-sqlalchemy==0.48b0",
+    "opentelemetry-propagator-b3==1.27.0",
+    # opentelemetry-proto1.28.0 depends on protobuf (>=5.0,<6.0),
+    # which is conflict with googleapis-common-protos (1.63.0)
+    "opentelemetry-proto==1.27.0",
+    "opentelemetry-sdk==1.27.0",
+    "opentelemetry-semantic-conventions==0.48b0",
+    "opentelemetry-util-http==0.48b0",
     "pandas[excel,output-formatting,performance]~=2.2.2",
     "psycogreen~=1.0.2",
     "psycopg2-binary~=2.9.6",
@@ -78,7 +81,7 @@ dependencies = [
     "starlette==0.49.1",
     "tiktoken~=0.9.0",
     "transformers~=4.56.1",
-    "unstructured[docx,epub,md,ppt,pptx]~=0.18.18",
+    "unstructured[docx,epub,md,ppt,pptx]~=0.16.1",
     "yarl~=1.18.3",
     "webvtt-py~=0.5.1",
     "sseclient-py~=1.8.0",

api/services/account_service.py

@@ -74,16 +74,6 @@ from tasks.mail_reset_password_task import (
 logger = logging.getLogger(__name__)
 
 
-def _try_join_enterprise_default_workspace(account_id: str) -> None:
-    """Best-effort join to enterprise default workspace."""
-    if not dify_config.ENTERPRISE_ENABLED:
-        return
-
-    from services.enterprise.enterprise_service import try_join_default_workspace
-
-    try_join_default_workspace(account_id)
-
-
 class TokenPair(BaseModel):
     access_token: str
     refresh_token: str
@@ -297,14 +287,7 @@ class AccountService:
             email=email, name=name, interface_language=interface_language, password=password
         )
 
-        try:
-            TenantService.create_owner_tenant_if_not_exist(account=account)
-        except Exception:
-            # Enterprise-only side-effect should run independently from personal workspace creation.
-            _try_join_enterprise_default_workspace(str(account.id))
-            raise
-
-        _try_join_enterprise_default_workspace(str(account.id))
+        TenantService.create_owner_tenant_if_not_exist(account=account)
 
         return account
 
@@ -344,12 +327,6 @@ class AccountService:
     @staticmethod
     def delete_account(account: Account):
         """Delete account. This method only adds a task to the queue for deletion."""
-        # Queue account deletion sync tasks for all workspaces BEFORE account deletion (enterprise only)
-        from services.enterprise.account_deletion_sync import sync_account_deletion
-
-        sync_account_deletion(account_id=account.id, source="account_deleted")
-
-        # Now proceed with async account deletion
         delete_account_task.delay(account.id)
 
     @staticmethod
@@ -1253,11 +1230,6 @@ class TenantService:
         if dify_config.BILLING_ENABLED:
             BillingService.clean_billing_info_cache(tenant.id)
 
-        # Queue account deletion sync task for enterprise backend to reassign resources (enterprise only)
-        from services.enterprise.account_deletion_sync import sync_workspace_member_removal
-
-        sync_workspace_member_removal(workspace_id=tenant.id, member_id=account.id, source="workspace_member_removed")
-
     @staticmethod
     def update_member_role(tenant: Tenant, member: Account, new_role: str, operator: Account):
         """Update member role"""
@@ -1378,18 +1350,12 @@ class RegisterService:
                 and create_workspace_required
                 and FeatureService.get_system_features().license.workspaces.is_available()
             ):
-                try:
-                    tenant = TenantService.create_tenant(f"{account.name}'s Workspace")
-                    TenantService.create_tenant_member(tenant, account, role="owner")
-                    account.current_tenant = tenant
-                    tenant_was_created.send(tenant)
-                except Exception:
-                    _try_join_enterprise_default_workspace(str(account.id))
-                    raise
+                tenant = TenantService.create_tenant(f"{account.name}'s Workspace")
+                TenantService.create_tenant_member(tenant, account, role="owner")
+                account.current_tenant = tenant
+                tenant_was_created.send(tenant)
 
             db.session.commit()
-
-            _try_join_enterprise_default_workspace(str(account.id))
         except WorkSpaceNotAllowedCreateError:
             db.session.rollback()
             logger.exception("Register failed")

api/services/app_service.py

@@ -14,7 +14,7 @@ from core.model_runtime.entities.model_entities import ModelPropertyKey, ModelTy
 from core.model_runtime.model_providers.__base.large_language_model import LargeLanguageModel
 from core.tools.tool_manager import ToolManager
 from core.tools.utils.configuration import ToolParameterConfigurationManager
-from events.app_event import app_was_created, app_was_deleted
+from events.app_event import app_was_created
 from extensions.ext_database import db
 from libs.datetime_utils import naive_utc_now
 from libs.login import current_user
@@ -340,8 +340,6 @@ class AppService:
         db.session.delete(app)
         db.session.commit()
 
-        app_was_deleted.send(app)
-
         # clean up web app settings
         if FeatureService.get_system_features().webapp_auth.enabled:
             EnterpriseService.WebAppAuth.cleanup_webapp(app.id)

api/services/enterprise/account_deletion_sync.py

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

api/services/enterprise/base.py

@@ -6,13 +6,6 @@ from typing import Any
 import httpx
 
 from core.helper.trace_id_helper import generate_traceparent_header
-from services.errors.enterprise import (
-    EnterpriseAPIBadRequestError,
-    EnterpriseAPIError,
-    EnterpriseAPIForbiddenError,
-    EnterpriseAPINotFoundError,
-    EnterpriseAPIUnauthorizedError,
-)
 
 logger = logging.getLogger(__name__)
 
@@ -46,9 +39,6 @@ class BaseRequest:
         endpoint: str,
         json: Any | None = None,
         params: Mapping[str, Any] | None = None,
-        *,
-        timeout: float | httpx.Timeout | None = None,
-        raise_for_status: bool = False,
     ) -> Any:
         headers = {"Content-Type": "application/json", cls.secret_key_header: cls.secret_key}
         url = f"{cls.base_url}{endpoint}"
@@ -63,64 +53,9 @@ class BaseRequest:
             logger.debug("Failed to generate traceparent header", exc_info=True)
 
         with httpx.Client(mounts=mounts) as client:
-            # IMPORTANT:
-            # - In httpx, passing timeout=None disables timeouts (infinite) and overrides the library default.
-            # - To preserve httpx's default timeout behavior for existing call sites, only pass the kwarg when set.
-            request_kwargs: dict[str, Any] = {"json": json, "params": params, "headers": headers}
-            if timeout is not None:
-                request_kwargs["timeout"] = timeout
-
-            response = client.request(method, url, **request_kwargs)
-
-            # Always validate HTTP status and raise domain-specific errors
-            if not response.is_success:
-                cls._handle_error_response(response)
-
-            # Legacy support: still respect raise_for_status parameter
-            if raise_for_status:
-                response.raise_for_status()
-
+            response = client.request(method, url, json=json, params=params, headers=headers)
         return response.json()
 
-    @classmethod
-    def _handle_error_response(cls, response: httpx.Response) -> None:
-        """
-        Handle non-2xx HTTP responses by raising appropriate domain errors.
-
-        Attempts to extract error message from JSON response body,
-        falls back to status text if parsing fails.
-        """
-        error_message = f"Enterprise API request failed: {response.status_code} {response.reason_phrase}"
-
-        # Try to extract error message from JSON response
-        try:
-            error_data = response.json()
-            if isinstance(error_data, dict):
-                # Common error response formats:
-                # {"error": "...", "message": "..."}
-                # {"message": "..."}
-                # {"detail": "..."}
-                error_message = (
-                    error_data.get("message") or error_data.get("error") or error_data.get("detail") or error_message
-                )
-        except Exception:
-            # If JSON parsing fails, use the default message
-            logger.debug(
-                "Failed to parse error response from enterprise API (status=%s)", response.status_code, exc_info=True
-            )
-
-        # Raise specific error based on status code
-        if response.status_code == 400:
-            raise EnterpriseAPIBadRequestError(error_message)
-        elif response.status_code == 401:
-            raise EnterpriseAPIUnauthorizedError(error_message)
-        elif response.status_code == 403:
-            raise EnterpriseAPIForbiddenError(error_message)
-        elif response.status_code == 404:
-            raise EnterpriseAPINotFoundError(error_message)
-        else:
-            raise EnterpriseAPIError(error_message, status_code=response.status_code)
-
 
 class EnterpriseRequest(BaseRequest):
     base_url = os.environ.get("ENTERPRISE_API_URL", "ENTERPRISE_API_URL")

api/services/enterprise/enterprise_service.py

@@ -1,27 +1,9 @@
-from __future__ import annotations
-
-import logging
-import uuid
 from datetime import datetime
-from typing import TYPE_CHECKING
 
-from pydantic import BaseModel, ConfigDict, Field, model_validator
+from pydantic import BaseModel, Field
 
-from configs import dify_config
-from extensions.ext_redis import redis_client
 from services.enterprise.base import EnterpriseRequest
 
-if TYPE_CHECKING:
-    from services.feature_service import LicenseStatus
-
-logger = logging.getLogger(__name__)
-
-DEFAULT_WORKSPACE_JOIN_TIMEOUT_SECONDS = 1.0
-ALLOWED_ACCESS_MODES = ["public", "private", "private_all", "sso_verified"]
-# License status cache configuration
-LICENSE_STATUS_CACHE_KEY = "enterprise:license:status"
-LICENSE_STATUS_CACHE_TTL = 600  # 10 minutes
-
 
 class WebAppSettings(BaseModel):
     access_mode: str = Field(
@@ -48,55 +30,6 @@ class WorkspacePermission(BaseModel):
     )
 
 
-class DefaultWorkspaceJoinResult(BaseModel):
-    """
-    Result of ensuring an account is a member of the enterprise default workspace.
-
-    - joined=True is idempotent (already a member also returns True)
-    - joined=False means enterprise default workspace is not configured or invalid/archived
-    """
-
-    workspace_id: str = Field(default="", alias="workspaceId")
-    joined: bool
-    message: str
-
-    model_config = ConfigDict(extra="forbid", populate_by_name=True)
-
-    @model_validator(mode="after")
-    def _check_workspace_id_when_joined(self) -> DefaultWorkspaceJoinResult:
-        if self.joined and not self.workspace_id:
-            raise ValueError("workspace_id must be non-empty when joined is True")
-        return self
-
-
-def try_join_default_workspace(account_id: str) -> None:
-    """
-    Enterprise-only side-effect: ensure account is a member of the default workspace.
-
-    This is a best-effort integration. Failures must not block user registration.
-    """
-
-    if not dify_config.ENTERPRISE_ENABLED:
-        return
-
-    try:
-        result = EnterpriseService.join_default_workspace(account_id=account_id)
-        if result.joined:
-            logger.info(
-                "Joined enterprise default workspace for account %s (workspace_id=%s)",
-                account_id,
-                result.workspace_id,
-            )
-        else:
-            logger.info(
-                "Skipped joining enterprise default workspace for account %s (message=%s)",
-                account_id,
-                result.message,
-            )
-    except Exception:
-        logger.warning("Failed to join enterprise default workspace for account %s", account_id, exc_info=True)
-
-
 class EnterpriseService:
     @classmethod
     def get_info(cls):
@@ -106,34 +39,6 @@ class EnterpriseService:
     def get_workspace_info(cls, tenant_id: str):
         return EnterpriseRequest.send_request("GET", f"/workspace/{tenant_id}/info")
 
-    @classmethod
-    def join_default_workspace(cls, *, account_id: str) -> DefaultWorkspaceJoinResult:
-        """
-        Call enterprise inner API to add an account to the default workspace.
-
-        NOTE: EnterpriseRequest.base_url is expected to already include the `/inner/api` prefix,
-        so the endpoint here is `/default-workspace/members`.
-        """
-
-        # Ensure we are sending a UUID-shaped string (enterprise side validates too).
-        try:
-            uuid.UUID(account_id)
-        except ValueError as e:
-            raise ValueError(f"account_id must be a valid UUID: {account_id}") from e
-
-        data = EnterpriseRequest.send_request(
-            "POST",
-            "/default-workspace/members",
-            json={"account_id": account_id},
-            timeout=DEFAULT_WORKSPACE_JOIN_TIMEOUT_SECONDS,
-            raise_for_status=True,
-        )
-        if not isinstance(data, dict):
-            raise ValueError("Invalid response format from enterprise default workspace API")
-        if "joined" not in data or "message" not in data:
-            raise ValueError("Invalid response payload from enterprise default workspace API")
-        return DefaultWorkspaceJoinResult.model_validate(data)
-
     @classmethod
     def get_app_sso_settings_last_update_time(cls) -> datetime:
         data = EnterpriseRequest.send_request("GET", "/sso/app/last-update-time")
@@ -218,8 +123,8 @@ class EnterpriseService:
         def update_app_access_mode(cls, app_id: str, access_mode: str):
             if not app_id:
                 raise ValueError("app_id must be provided.")
-            if access_mode not in ALLOWED_ACCESS_MODES:
-                raise ValueError(f"access_mode must be one of: {', '.join(ALLOWED_ACCESS_MODES)}")
+            if access_mode not in ["public", "private", "private_all"]:
+                raise ValueError("access_mode must be either 'public', 'private', or 'private_all'")
 
             data = {"appId": app_id, "accessMode": access_mode}
 
@@ -234,62 +139,3 @@ class EnterpriseService:
 
             params = {"appId": app_id}
             EnterpriseRequest.send_request("DELETE", "/webapp/clean", params=params)
-
-    @classmethod
-    def get_cached_license_status(cls) -> LicenseStatus | None:
-        """Get enterprise license status with Redis caching to reduce HTTP calls.
-
-        Caches valid statuses (active/expiring) for 10 minutes. Invalid statuses
-        are not cached so license updates are picked up on the next request.
-
-        Returns:
-            LicenseStatus enum value, or None if enterprise is disabled / unreachable.
-        """
-        if not dify_config.ENTERPRISE_ENABLED:
-            return None
-
-        cached = cls._read_cached_license_status()
-        if cached is not None:
-            return cached
-
-        return cls._fetch_and_cache_license_status()
-
-    @classmethod
-    def _read_cached_license_status(cls) -> LicenseStatus | None:
-        """Read license status from Redis cache, returning None on miss or failure."""
-        from services.feature_service import LicenseStatus
-
-        try:
-            raw = redis_client.get(LICENSE_STATUS_CACHE_KEY)
-            if raw:
-                value = raw.decode("utf-8") if isinstance(raw, bytes) else raw
-                return LicenseStatus(value)
-        except Exception:
-            logger.debug("Failed to read license status from cache", exc_info=True)
-        return None
-
-    @classmethod
-    def _fetch_and_cache_license_status(cls) -> LicenseStatus | None:
-        """Fetch license status from enterprise API and cache the result.
-
-        Only caches valid statuses (active/expiring) so license updates
-        for invalid statuses are picked up on the next request.
-        """
-        from services.feature_service import LicenseStatus
-
-        try:
-            info = cls.get_info()
-            license_info = info.get("License")
-            if not license_info:
-                return None
-
-            status = LicenseStatus(license_info.get("status", LicenseStatus.INACTIVE))
-            if status in (LicenseStatus.ACTIVE, LicenseStatus.EXPIRING):
-                try:
-                    redis_client.setex(LICENSE_STATUS_CACHE_KEY, LICENSE_STATUS_CACHE_TTL, status)
-                except Exception:
-                    logger.debug("Failed to cache license status", exc_info=True)
-            return status
-        except Exception:
-            logger.debug("Failed to fetch enterprise license status", exc_info=True)
-        return None

api/services/enterprise/plugin_manager_service.py

@@ -28,11 +28,6 @@ class CheckCredentialPolicyComplianceRequest(BaseModel):
         return data
 
 
-class PreUninstallPluginRequest(BaseModel):
-    tenant_id: str
-    plugin_unique_identifier: str
-
-
 class CredentialPolicyViolationError(BaseServiceError):
     pass
 
@@ -60,19 +55,3 @@ class PluginManagerService:
             body.dify_credential_id,
             ret.get("result", False),
         )
-
-    @classmethod
-    def try_pre_uninstall_plugin(cls, body: PreUninstallPluginRequest):
-        try:
-            # the invocation must be synchronous.
-            EnterprisePluginManagerRequest.send_request(
-                "POST",
-                "/pre-uninstall-plugin",
-                json=body.model_dump(),
-            )
-        except Exception:
-            logger.exception(
-                "failed to perform pre uninstall plugin hook. tenant_id: %s, plugin_unique_identifier: %s",
-                body.tenant_id,
-                body.plugin_unique_identifier,
-            )

api/services/errors/__init__.py

@@ -7,7 +7,6 @@ from . import (
     conversation,
     dataset,
     document,
-    enterprise,
     file,
     index,
     message,
@@ -22,7 +21,6 @@ __all__ = [
     "conversation",
     "dataset",
     "document",
-    "enterprise",
     "file",
     "index",
     "message",

api/services/errors/enterprise.py

@@ -1,45 +0,0 @@
-"""Enterprise service errors."""
-
-from services.errors.base import BaseServiceError
-
-
-class EnterpriseServiceError(BaseServiceError):
-    """Base exception for enterprise service errors."""
-
-    def __init__(self, description: str | None = None, status_code: int | None = None):
-        super().__init__(description)
-        self.status_code = status_code
-
-
-class EnterpriseAPIError(EnterpriseServiceError):
-    """Generic enterprise API error (non-2xx response)."""
-
-    pass
-
-
-class EnterpriseAPINotFoundError(EnterpriseServiceError):
-    """Enterprise API returned 404 Not Found."""
-
-    def __init__(self, description: str | None = None):
-        super().__init__(description, status_code=404)
-
-
-class EnterpriseAPIForbiddenError(EnterpriseServiceError):
-    """Enterprise API returned 403 Forbidden."""
-
-    def __init__(self, description: str | None = None):
-        super().__init__(description, status_code=403)
-
-
-class EnterpriseAPIUnauthorizedError(EnterpriseServiceError):
-    """Enterprise API returned 401 Unauthorized."""
-
-    def __init__(self, description: str | None = None):
-        super().__init__(description, status_code=401)
-
-
-class EnterpriseAPIBadRequestError(EnterpriseServiceError):
-    """Enterprise API returned 400 Bad Request."""
-
-    def __init__(self, description: str | None = None):
-        super().__init__(description, status_code=400)

api/services/feature_service.py

@@ -361,14 +361,11 @@ class FeatureService:
             )
             features.webapp_auth.sso_config.protocol = enterprise_info.get("SSOEnforcedForWebProtocol", "")
 
-        # License status and expiry are always exposed so the login page can
-        # show the expiry UI after a force-logout (the user is unauthenticated
-        # at that point).  Workspace usage details remain auth-gated.
-        if license_info := enterprise_info.get("License"):
+        if is_authenticated and (license_info := enterprise_info.get("License")):
             features.license.status = LicenseStatus(license_info.get("status", LicenseStatus.INACTIVE))
             features.license.expired_at = license_info.get("expiredAt", "")
 
-            if is_authenticated and (workspaces_info := license_info.get("workspaces")):
+            if workspaces_info := license_info.get("workspaces"):
                 features.license.workspaces.enabled = workspaces_info.get("enabled", False)
                 features.license.workspaces.limit = workspaces_info.get("limit", 0)
                 features.license.workspaces.size = workspaces_info.get("used", 0)

api/services/message_service.py

@@ -7,10 +7,9 @@ from core.llm_generator.llm_generator import LLMGenerator
 from core.memory.token_buffer_memory import TokenBufferMemory
 from core.model_manager import ModelManager
 from core.model_runtime.entities.model_entities import ModelType
+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
-from events.feedback_event import feedback_was_created
 from extensions.ext_database import db
 from libs.infinite_scroll_pagination import InfiniteScrollPagination
 from models import Account
@@ -180,9 +179,6 @@ class MessageService:
 
         db.session.commit()
 
-        if feedback and rating:
-            feedback_was_created.send(feedback, tenant_id=app_model.tenant_id)
-
         return feedback
 
     @classmethod
@@ -298,15 +294,10 @@ class MessageService:
             questions: list[str] = list(questions_sequence)
 
         # get tracing instance
-        telemetry_emit(
-            TelemetryEvent(
-                name=TraceTaskName.SUGGESTED_QUESTION_TRACE,
-                context=TelemetryContext(tenant_id=app_model.tenant_id, app_id=app_model.id),
-                payload={
-                    "message_id": message_id,
-                    "suggested_question": questions,
-                    "timer": timer,
-                },
+        trace_manager = TraceQueueManager(app_id=app_model.id)
+        trace_manager.add_trace_task(
+            TraceTask(
+                TraceTaskName.SUGGESTED_QUESTION_TRACE, message_id=message_id, suggested_question=questions, timer=timer
             )
         )
 

api/services/ops_service.py

@@ -1,4 +1,3 @@
-import logging
 from typing import Any
 
 from core.ops.entities.config_entity import BaseTracingConfig
@@ -6,8 +5,6 @@ from core.ops.ops_trace_manager import OpsTraceManager, provider_config_map
 from extensions.ext_database import db
 from models.model import App, TraceAppConfig
 
-logger = logging.getLogger(__name__)
-
 
 class OpsService:
     @classmethod
@@ -138,13 +135,12 @@ class OpsService:
         return trace_config_data.to_dict()
 
     @classmethod
-    def create_tracing_app_config(cls, app_id: str, tracing_provider: str, tracing_config: dict, account_id: str):
+    def create_tracing_app_config(cls, app_id: str, tracing_provider: str, tracing_config: dict):
         """
         Create tracing app config
         :param app_id: app id
         :param tracing_provider: tracing provider
         :param tracing_config: tracing config
-        :param account_id: account id of the user creating the config
         :return:
         """
         try:
@@ -211,19 +207,15 @@ class OpsService:
         db.session.add(trace_config_data)
         db.session.commit()
 
-        # Log the creation with modifier information
-        logger.info("Trace config created: app_id=%s, provider=%s, created_by=%s", app_id, tracing_provider, account_id)
-
         return {"result": "success"}
 
     @classmethod
-    def update_tracing_app_config(cls, app_id: str, tracing_provider: str, tracing_config: dict, account_id: str):
+    def update_tracing_app_config(cls, app_id: str, tracing_provider: str, tracing_config: dict):
         """
         Update tracing app config
         :param app_id: app id
         :param tracing_provider: tracing provider
         :param tracing_config: tracing config
-        :param account_id: account id of the user updating the config
         :return:
         """
         try:
@@ -259,18 +251,14 @@ class OpsService:
         current_trace_config.tracing_config = tracing_config
         db.session.commit()
 
-        # Log the update with modifier information
-        logger.info("Trace config updated: app_id=%s, provider=%s, updated_by=%s", app_id, tracing_provider, account_id)
-
         return current_trace_config.to_dict()
 
     @classmethod
-    def delete_tracing_app_config(cls, app_id: str, tracing_provider: str, account_id: str):
+    def delete_tracing_app_config(cls, app_id: str, tracing_provider: str):
         """
         Delete tracing app config
         :param app_id: app id
         :param tracing_provider: tracing provider
-        :param account_id: account id of the user deleting the config
         :return:
         """
         trace_config = (
@@ -282,9 +270,6 @@ class OpsService:
         if not trace_config:
             return None
 
-        # Log the deletion with modifier information
-        logger.info("Trace config deleted: app_id=%s, provider=%s, deleted_by=%s", app_id, tracing_provider, account_id)
-
         db.session.delete(trace_config)
         db.session.commit()
 

api/services/tools/builtin_tools_manage_service.py

@@ -2,10 +2,7 @@ import json
 import logging
 from collections.abc import Mapping
 from pathlib import Path
-from typing import TYPE_CHECKING, Any
-
-if TYPE_CHECKING:
-    from models.account import Account
+from typing import Any
 
 from sqlalchemy import exists, select
 from sqlalchemy.orm import Session
@@ -409,37 +406,20 @@ class BuiltinToolManageService:
         return {"result": "success"}
 
     @staticmethod
-    def set_default_provider(tenant_id: str, user_id: str, provider: str, id: str, account: "Account | None" = None):
+    def set_default_provider(tenant_id: str, user_id: str, provider: str, id: str):
         """
         set default provider
         """
         with Session(db.engine) as session:
-            # get provider (verify tenant ownership to prevent IDOR)
-            target_provider = session.query(BuiltinToolProvider).filter_by(id=id, tenant_id=tenant_id).first()
+            # get provider
+            target_provider = session.query(BuiltinToolProvider).filter_by(id=id).first()
             if target_provider is None:
                 raise ValueError("provider not found")
 
             # clear default provider
-            if dify_config.ENTERPRISE_ENABLED:
-                # Enterprise: verify admin permission for tenant-wide operation
-                from models.account import TenantAccountRole
-
-                if account is None:
-                    # In enterprise mode, an account context is required to perform permission checks
-                    raise ValueError("Account is required to set default credentials in enterprise mode")
-
-                if not TenantAccountRole.is_privileged_role(account.current_role):
-                    raise ValueError("Only workspace admins/owners can set default credentials in enterprise mode")
-                # Enterprise: clear ALL defaults for this provider in the tenant
-                # (regardless of user_id, since enterprise credentials may have different user_id)
-                session.query(BuiltinToolProvider).filter_by(
-                    tenant_id=tenant_id, provider=provider, is_default=True
-                ).update({"is_default": False})
-            else:
-                # Non-enterprise: only clear defaults for the current user
-                session.query(BuiltinToolProvider).filter_by(
-                    tenant_id=tenant_id, user_id=user_id, provider=provider, is_default=True
-                ).update({"is_default": False})
+            session.query(BuiltinToolProvider).filter_by(
+                tenant_id=tenant_id, user_id=user_id, provider=provider, is_default=True
+            ).update({"is_default": False})
 
             # set new default provider
             target_provider.is_default = True

api/services/tools/tools_transform_service.py

@@ -33,8 +33,6 @@ logger = logging.getLogger(__name__)
 
 
 class ToolTransformService:
-    _MCP_SCHEMA_TYPE_RESOLUTION_MAX_DEPTH = 10
-
     @classmethod
     def get_tool_provider_icon_url(
         cls, provider_type: str, provider_name: str, icon: str | Mapping[str, str]
@@ -437,46 +435,6 @@ class ToolTransformService:
         :return: list of ToolParameter instances
         """
 
-        def resolve_property_type(prop: dict[str, Any], depth: int = 0) -> str:
-            """
-            Resolve a JSON schema property type while guarding against cyclic or deeply nested unions.
-            """
-            if depth >= ToolTransformService._MCP_SCHEMA_TYPE_RESOLUTION_MAX_DEPTH:
-                return "string"
-            prop_type = prop.get("type")
-            if isinstance(prop_type, list):
-                non_null_types = [type_name for type_name in prop_type if type_name != "null"]
-                if non_null_types:
-                    return non_null_types[0]
-                if prop_type:
-                    return "string"
-            elif isinstance(prop_type, str):
-                if prop_type == "null":
-                    return "string"
-                return prop_type
-
-            for union_key in ("anyOf", "oneOf"):
-                union_schemas = prop.get(union_key)
-                if not isinstance(union_schemas, list):
-                    continue
-
-                for union_schema in union_schemas:
-                    if not isinstance(union_schema, dict):
-                        continue
-                    union_type = resolve_property_type(union_schema, depth + 1)
-                    if union_type != "null":
-                        return union_type
-
-            all_of_schemas = prop.get("allOf")
-            if isinstance(all_of_schemas, list):
-                for all_of_schema in all_of_schemas:
-                    if not isinstance(all_of_schema, dict):
-                        continue
-                    all_of_type = resolve_property_type(all_of_schema, depth + 1)
-                    if all_of_type != "null":
-                        return all_of_type
-            return "string"
-
         def create_parameter(
             name: str, description: str, param_type: str, required: bool, input_schema: dict[str, Any] | None = None
         ) -> ToolParameter:
@@ -503,7 +461,10 @@ class ToolTransformService:
             parameters = []
             for name, prop in props.items():
                 current_description = prop.get("description", "")
-                prop_type = resolve_property_type(prop)
+                prop_type = prop.get("type", "string")
+
+                if isinstance(prop_type, list):
+                    prop_type = prop_type[0]
                 if prop_type in TYPE_MAPPING:
                     prop_type = TYPE_MAPPING[prop_type]
                 input_schema = prop if prop_type in COMPLEX_TYPES else None