fix(api): serialize pipeline file-upload created_at (#32098)

Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>

.codex/skills/component-refactoring

@@ -1 +0,0 @@
-../../.agents/skills/component-refactoring

.codex/skills/frontend-code-review

@@ -1 +0,0 @@
-../../.agents/skills/frontend-code-review

.codex/skills/frontend-testing

@@ -1 +0,0 @@
-../../.agents/skills/frontend-testing

.codex/skills/orpc-contract-first

@@ -1 +0,0 @@
-../../.agents/skills/orpc-contract-first

.github/CODEOWNERS

@@ -24,6 +24,10 @@
 /api/services/tools/mcp_tools_manage_service.py @Nov1c444
 /api/controllers/mcp/ @Nov1c444
 /api/controllers/console/app/mcp_server.py @Nov1c444
+
+# Backend - Tests
+/api/tests/ @laipz8200 @QuantumGhost
+
 /api/tests/**/*mcp* @Nov1c444
 
 # Backend - Workflow - Engine (Core graph execution engine)
@@ -234,6 +238,9 @@
 # Frontend - Base Components
 /web/app/components/base/ @iamjoel @zxhlyh
 
+# Frontend - Base Components Tests
+/web/app/components/base/**/*.spec.tsx @hyoban @CodingOnStar
+
 # Frontend - Utils and Hooks
 /web/utils/classnames.ts @iamjoel @zxhlyh
 /web/utils/time.ts @iamjoel @zxhlyh

.github/workflows/autofix.yml

@@ -79,29 +79,6 @@ jobs:
           find . -name "*.py" -type f -exec sed -i.bak -E 's/"([^"]+)" \| None/Optional["\1"]/g; s/'"'"'([^'"'"']+)'"'"' \| None/Optional['"'"'\1'"'"']/g' {} \;
           find . -name "*.py.bak" -type f -delete
 
-      - name: Install pnpm
-        uses: pnpm/action-setup@v4
-        with:
-          package_json_file: web/package.json
-          run_install: false
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v6
-        with:
-          node-version: 24
-          cache: pnpm
-          cache-dependency-path: ./web/pnpm-lock.yaml
-
-      - name: Install web dependencies
-        run: |
-          cd web
-          pnpm install --frozen-lockfile
-
-      - name: ESLint autofix
-        run: |
-          cd web
-          pnpm lint:fix || true
-
       # mdformat breaks YAML front matter in markdown files. Add --exclude for directories containing YAML front matter.
       - name: mdformat
         run: |

.github/workflows/build-push.yml

@@ -8,6 +8,7 @@ on:
       - "build/**"
       - "release/e-*"
       - "hotfix/**"
+      - "feat/hitl-backend"
     tags:
       - "*"
 

.github/workflows/deploy-hitl.yml

@@ -4,8 +4,7 @@ on:
   workflow_run:
     workflows: ["Build and Push API & Web"]
     branches:
-      - "feat/hitl-frontend"
-      - "feat/hitl-backend"
+      - "build/feat/hitl"
     types:
       - completed
 
@@ -14,10 +13,7 @@ jobs:
     runs-on: ubuntu-latest
     if: |
       github.event.workflow_run.conclusion == 'success' &&
-      (
-        github.event.workflow_run.head_branch == 'feat/hitl-frontend' ||
-        github.event.workflow_run.head_branch == 'feat/hitl-backend'
-      )
+      github.event.workflow_run.head_branch == 'build/feat/hitl'
     steps:
       - name: Deploy to server
         uses: appleboy/ssh-action@v1

.github/workflows/web-tests.yml

@@ -39,7 +39,7 @@ jobs:
         run: pnpm install --frozen-lockfile
 
       - name: Run tests
-        run: pnpm test:coverage
+        run: pnpm test:ci
 
       - name: Coverage Summary
         if: always()

.vscode/launch.json.template

@@ -37,7 +37,7 @@
                 "-c",
                 "1",
                 "-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",
+                "dataset,priority_dataset,priority_pipeline,pipeline,mail,ops_trace,app_deletion,plugin,workflow_storage,conversation,workflow,schedule_poller,schedule_executor,triggered_workflow_dispatcher,trigger_refresh_executor,retention,workflow_based_app_execution",
                 "--loglevel",
                 "INFO"
             ],

api/.env.example

@@ -717,3 +717,28 @@ SANDBOX_EXPIRED_RECORDS_CLEAN_GRACEFUL_PERIOD=21
 SANDBOX_EXPIRED_RECORDS_CLEAN_BATCH_SIZE=1000
 SANDBOX_EXPIRED_RECORDS_RETENTION_DAYS=30
 SANDBOX_EXPIRED_RECORDS_CLEAN_TASK_LOCK_TTL=90000
+
+
+# Redis URL used for PubSub between API and
+# celery worker
+# defaults to url constructed from `REDIS_*`
+# configurations
+PUBSUB_REDIS_URL=
+# Pub/sub channel type for streaming events.
+# valid options are:
+#
+# - pubsub: for normal Pub/Sub
+# - sharded: for sharded Pub/Sub
+#
+# It's highly recommended to use sharded Pub/Sub AND redis cluster
+# for large deployments.
+PUBSUB_REDIS_CHANNEL_TYPE=pubsub
+# Whether to use Redis cluster mode while running
+# PubSub.
+#  It's highly recommended to enable this for large deployments.
+PUBSUB_REDIS_USE_CLUSTERS=false
+
+# Whether to Enable human input timeout check task
+ENABLE_HUMAN_INPUT_TIMEOUT_TASK=true
+# Human input timeout check interval in minutes
+HUMAN_INPUT_TIMEOUT_TASK_INTERVAL=1

api/.importlinter

@@ -36,6 +36,8 @@ ignore_imports =
     core.workflow.nodes.loop.loop_node -> core.workflow.graph_engine
     core.workflow.nodes.loop.loop_node -> core.workflow.graph
     core.workflow.nodes.loop.loop_node -> core.workflow.graph_engine.command_channels
+    # TODO(QuantumGhost): fix the import violation later
+    core.workflow.entities.pause_reason -> core.workflow.nodes.human_input.entities
 
 [importlinter:contract:workflow-infrastructure-dependencies]
 name = Workflow Infrastructure Dependencies
@@ -50,14 +52,14 @@ ignore_imports =
     core.workflow.nodes.agent.agent_node -> extensions.ext_database
     core.workflow.nodes.datasource.datasource_node -> extensions.ext_database
     core.workflow.nodes.knowledge_index.knowledge_index_node -> extensions.ext_database
-    core.workflow.nodes.knowledge_retrieval.knowledge_retrieval_node -> extensions.ext_database
     core.workflow.nodes.llm.file_saver -> extensions.ext_database
     core.workflow.nodes.llm.llm_utils -> extensions.ext_database
     core.workflow.nodes.llm.node -> extensions.ext_database
     core.workflow.nodes.tool.tool_node -> extensions.ext_database
     core.workflow.graph_engine.command_channels.redis_channel -> extensions.ext_redis
     core.workflow.graph_engine.manager -> extensions.ext_redis
-    core.workflow.nodes.knowledge_retrieval.knowledge_retrieval_node -> extensions.ext_redis
+    # TODO(QuantumGhost): use DI to avoid depending on global DB.
+    core.workflow.nodes.human_input.human_input_node -> extensions.ext_database
 
 [importlinter:contract:workflow-external-imports]
 name = Workflow External Imports
@@ -122,11 +124,6 @@ ignore_imports =
     core.workflow.nodes.http_request.node -> core.tools.tool_file_manager
     core.workflow.nodes.iteration.iteration_node -> core.app.workflow.node_factory
     core.workflow.nodes.knowledge_index.knowledge_index_node -> core.rag.index_processor.index_processor_factory
-    core.workflow.nodes.knowledge_retrieval.knowledge_retrieval_node -> core.rag.datasource.retrieval_service
-    core.workflow.nodes.knowledge_retrieval.knowledge_retrieval_node -> core.rag.retrieval.dataset_retrieval
-    core.workflow.nodes.knowledge_retrieval.knowledge_retrieval_node -> models.dataset
-    core.workflow.nodes.knowledge_retrieval.knowledge_retrieval_node -> services.feature_service
-    core.workflow.nodes.knowledge_retrieval.knowledge_retrieval_node -> core.model_runtime.model_providers.__base.large_language_model
     core.workflow.nodes.llm.llm_utils -> configs
     core.workflow.nodes.llm.llm_utils -> core.app.entities.app_invoke_entities
     core.workflow.nodes.llm.llm_utils -> core.file.models
@@ -136,7 +133,6 @@ ignore_imports =
     core.workflow.nodes.llm.llm_utils -> models.provider
     core.workflow.nodes.llm.llm_utils -> services.credit_pool_service
     core.workflow.nodes.llm.node -> core.tools.signature
-    core.workflow.nodes.template_transform.template_transform_node -> configs
     core.workflow.nodes.tool.tool_node -> core.callback_handler.workflow_tool_callback_handler
     core.workflow.nodes.tool.tool_node -> core.tools.tool_engine
     core.workflow.nodes.tool.tool_node -> core.tools.tool_manager
@@ -145,9 +141,9 @@ ignore_imports =
     core.workflow.nodes.agent.agent_node -> core.agent.entities
     core.workflow.nodes.agent.agent_node -> core.agent.plugin_entities
     core.workflow.nodes.base.node -> core.app.entities.app_invoke_entities
+    core.workflow.nodes.human_input.human_input_node -> core.app.entities.app_invoke_entities
     core.workflow.nodes.knowledge_index.knowledge_index_node -> core.app.entities.app_invoke_entities
     core.workflow.nodes.knowledge_retrieval.knowledge_retrieval_node -> core.app.app_config.entities
-    core.workflow.nodes.knowledge_retrieval.knowledge_retrieval_node -> core.app.entities.app_invoke_entities
     core.workflow.nodes.llm.node -> core.app.entities.app_invoke_entities
     core.workflow.nodes.parameter_extractor.parameter_extractor_node -> core.app.entities.app_invoke_entities
     core.workflow.nodes.parameter_extractor.parameter_extractor_node -> core.prompt.advanced_prompt_transform
@@ -163,9 +159,6 @@ ignore_imports =
     core.workflow.workflow_entry -> core.app.workflow.node_factory
     core.workflow.nodes.datasource.datasource_node -> core.datasource.datasource_manager
     core.workflow.nodes.datasource.datasource_node -> core.datasource.utils.message_transformer
-    core.workflow.nodes.knowledge_retrieval.knowledge_retrieval_node -> core.entities.agent_entities
-    core.workflow.nodes.knowledge_retrieval.knowledge_retrieval_node -> core.entities.model_entities
-    core.workflow.nodes.knowledge_retrieval.knowledge_retrieval_node -> core.model_manager
     core.workflow.nodes.llm.llm_utils -> core.entities.provider_entities
     core.workflow.nodes.parameter_extractor.parameter_extractor_node -> core.model_manager
     core.workflow.nodes.question_classifier.question_classifier_node -> core.model_manager
@@ -214,7 +207,6 @@ ignore_imports =
     core.workflow.nodes.llm.node -> core.llm_generator.output_parser.structured_output
     core.workflow.nodes.llm.node -> core.model_manager
     core.workflow.nodes.agent.entities -> core.prompt.entities.advanced_prompt_entities
-    core.workflow.nodes.knowledge_retrieval.knowledge_retrieval_node -> core.prompt.simple_prompt_transform
     core.workflow.nodes.llm.entities -> core.prompt.entities.advanced_prompt_entities
     core.workflow.nodes.llm.llm_utils -> core.prompt.entities.advanced_prompt_entities
     core.workflow.nodes.llm.node -> core.prompt.entities.advanced_prompt_entities
@@ -230,7 +222,6 @@ ignore_imports =
     core.workflow.nodes.knowledge_index.knowledge_index_node -> services.summary_index_service
     core.workflow.nodes.knowledge_index.knowledge_index_node -> tasks.generate_summary_index_task
     core.workflow.nodes.knowledge_index.knowledge_index_node -> core.rag.index_processor.processor.paragraph_index_processor
-    core.workflow.nodes.knowledge_retrieval.knowledge_retrieval_node -> core.rag.retrieval.retrieval_methods
     core.workflow.nodes.llm.node -> models.dataset
     core.workflow.nodes.agent.agent_node -> core.tools.utils.message_transformer
     core.workflow.nodes.llm.file_saver -> core.tools.signature
@@ -248,6 +239,7 @@ ignore_imports =
     core.workflow.nodes.document_extractor.node -> core.variables.segments
     core.workflow.nodes.http_request.executor -> core.variables.segments
     core.workflow.nodes.http_request.node -> core.variables.segments
+    core.workflow.nodes.human_input.entities -> core.variables.consts
     core.workflow.nodes.iteration.iteration_node -> core.variables
     core.workflow.nodes.iteration.iteration_node -> core.variables.segments
     core.workflow.nodes.iteration.iteration_node -> core.variables.variables
@@ -288,12 +280,12 @@ ignore_imports =
     core.workflow.nodes.agent.agent_node -> extensions.ext_database
     core.workflow.nodes.datasource.datasource_node -> extensions.ext_database
     core.workflow.nodes.knowledge_index.knowledge_index_node -> extensions.ext_database
-    core.workflow.nodes.knowledge_retrieval.knowledge_retrieval_node -> extensions.ext_database
-    core.workflow.nodes.knowledge_retrieval.knowledge_retrieval_node -> extensions.ext_redis
     core.workflow.nodes.llm.file_saver -> extensions.ext_database
     core.workflow.nodes.llm.llm_utils -> extensions.ext_database
     core.workflow.nodes.llm.node -> extensions.ext_database
     core.workflow.nodes.tool.tool_node -> extensions.ext_database
+    core.workflow.nodes.human_input.human_input_node -> extensions.ext_database
+    core.workflow.nodes.human_input.human_input_node -> core.repositories.human_input_repository
     core.workflow.workflow_entry -> extensions.otel.runtime
     core.workflow.nodes.agent.agent_node -> models
     core.workflow.nodes.base.node -> models.enums

api/README.md

@@ -122,7 +122,7 @@ These commands assume you start from the repository root.
 
    ```bash
    cd api
-   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
+   uv run celery -A app.celery worker -P threads -c 2 --loglevel INFO -Q api_token,dataset,priority_dataset,priority_pipeline,pipeline,mail,ops_trace,app_deletion,plugin,workflow_storage,conversation,workflow,schedule_poller,schedule_executor,triggered_workflow_dispatcher,trigger_refresh_executor,retention
    ```
 
 1. Optional: start Celery Beat (scheduled tasks, in a new terminal).

api/commands.py

@@ -739,8 +739,10 @@ def upgrade_db():
 
             click.echo(click.style("Database migration successful!", fg="green"))
 
-        except Exception:
+        except Exception as e:
             logger.exception("Failed to execute database migration")
+            click.echo(click.style(f"Database migration failed: {e}", fg="red"))
+            raise SystemExit(1)
         finally:
             lock.release()
     else:

api/configs/feature/__init__.py

@@ -1,3 +1,4 @@
+from datetime import timedelta
 from enum import StrEnum
 from typing import Literal
 
@@ -48,6 +49,16 @@ class SecurityConfig(BaseSettings):
         default=5,
     )
 
+    WEB_FORM_SUBMIT_RATE_LIMIT_MAX_ATTEMPTS: PositiveInt = Field(
+        description="Maximum number of web form submissions allowed per IP within the rate limit window",
+        default=30,
+    )
+
+    WEB_FORM_SUBMIT_RATE_LIMIT_WINDOW_SECONDS: PositiveInt = Field(
+        description="Time window in seconds for web form submission rate limiting",
+        default=60,
+    )
+
     LOGIN_DISABLED: bool = Field(
         description="Whether to disable login checks",
         default=False,
@@ -82,6 +93,12 @@ class AppExecutionConfig(BaseSettings):
         default=0,
     )
 
+    HUMAN_INPUT_GLOBAL_TIMEOUT_SECONDS: PositiveInt = Field(
+        description="Maximum seconds a workflow run can stay paused waiting for human input before global timeout.",
+        default=int(timedelta(days=7).total_seconds()),
+        ge=1,
+    )
+
 
 class CodeExecutionSandboxConfig(BaseSettings):
     """
@@ -1134,6 +1151,14 @@ class CeleryScheduleTasksConfig(BaseSettings):
         description="Enable queue monitor task",
         default=False,
     )
+    ENABLE_HUMAN_INPUT_TIMEOUT_TASK: bool = Field(
+        description="Enable human input timeout check task",
+        default=True,
+    )
+    HUMAN_INPUT_TIMEOUT_TASK_INTERVAL: PositiveInt = Field(
+        description="Human input timeout check interval in minutes",
+        default=1,
+    )
     ENABLE_CHECK_UPGRADABLE_PLUGIN_TASK: bool = Field(
         description="Enable check upgradable plugin task",
         default=True,
@@ -1155,6 +1180,16 @@ class CeleryScheduleTasksConfig(BaseSettings):
         default=0,
     )
 
+    # API token last_used_at batch update
+    ENABLE_API_TOKEN_LAST_USED_UPDATE_TASK: bool = Field(
+        description="Enable periodic batch update of API token last_used_at timestamps",
+        default=True,
+    )
+    API_TOKEN_LAST_USED_UPDATE_INTERVAL: int = Field(
+        description="Interval in minutes for batch updating API token last_used_at (default 30)",
+        default=30,
+    )
+
     # Trigger provider refresh (simple version)
     ENABLE_TRIGGER_PROVIDER_REFRESH_TASK: bool = Field(
         description="Enable trigger provider refresh poller",

api/configs/middleware/__init__.py

@@ -6,6 +6,7 @@ from pydantic import Field, NonNegativeFloat, NonNegativeInt, PositiveFloat, Pos
 from pydantic_settings import BaseSettings
 
 from .cache.redis_config import RedisConfig
+from .cache.redis_pubsub_config import RedisPubSubConfig
 from .storage.aliyun_oss_storage_config import AliyunOSSStorageConfig
 from .storage.amazon_s3_storage_config import S3StorageConfig
 from .storage.azure_blob_storage_config import AzureBlobStorageConfig
@@ -317,6 +318,7 @@ class MiddlewareConfig(
     CeleryConfig,  # Note: CeleryConfig already inherits from DatabaseConfig
     KeywordStoreConfig,
     RedisConfig,
+    RedisPubSubConfig,
     # configs of storage and storage providers
     StorageConfig,
     AliyunOSSStorageConfig,

api/configs/middleware/cache/redis_pubsub_config.py

@@ -0,0 +1,96 @@
+from typing import Literal, Protocol
+from urllib.parse import quote_plus, urlunparse
+
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+
+class RedisConfigDefaults(Protocol):
+    REDIS_HOST: str
+    REDIS_PORT: int
+    REDIS_USERNAME: str | None
+    REDIS_PASSWORD: str | None
+    REDIS_DB: int
+    REDIS_USE_SSL: bool
+    REDIS_USE_SENTINEL: bool | None
+    REDIS_USE_CLUSTERS: bool
+
+
+class RedisConfigDefaultsMixin:
+    def _redis_defaults(self: RedisConfigDefaults) -> RedisConfigDefaults:
+        return self
+
+
+class RedisPubSubConfig(BaseSettings, RedisConfigDefaultsMixin):
+    """
+    Configuration settings for Redis pub/sub streaming.
+    """
+
+    PUBSUB_REDIS_URL: str | None = Field(
+        alias="PUBSUB_REDIS_URL",
+        description=(
+            "Redis connection URL for pub/sub streaming events between API "
+            "and celery worker, defaults to url constructed from "
+            "`REDIS_*` configurations"
+        ),
+        default=None,
+    )
+
+    PUBSUB_REDIS_USE_CLUSTERS: bool = Field(
+        description=(
+            "Enable Redis Cluster mode for pub/sub streaming. It's highly "
+            "recommended to enable this for large deployments."
+        ),
+        default=False,
+    )
+
+    PUBSUB_REDIS_CHANNEL_TYPE: Literal["pubsub", "sharded"] = Field(
+        description=(
+            "Pub/sub channel type for streaming events. "
+            "Valid options are:\n"
+            "\n"
+            " - pubsub: for normal Pub/Sub\n"
+            " - sharded: for sharded Pub/Sub\n"
+            "\n"
+            "It's highly recommended to use sharded Pub/Sub AND redis cluster "
+            "for large deployments."
+        ),
+        default="pubsub",
+    )
+
+    def _build_default_pubsub_url(self) -> str:
+        defaults = self._redis_defaults()
+        if not defaults.REDIS_HOST or not defaults.REDIS_PORT:
+            raise ValueError("PUBSUB_REDIS_URL must be set when default Redis URL cannot be constructed")
+
+        scheme = "rediss" if defaults.REDIS_USE_SSL else "redis"
+        username = defaults.REDIS_USERNAME or None
+        password = defaults.REDIS_PASSWORD or None
+
+        userinfo = ""
+        if username:
+            userinfo = quote_plus(username)
+        if password:
+            password_part = quote_plus(password)
+            userinfo = f"{userinfo}:{password_part}" if userinfo else f":{password_part}"
+        if userinfo:
+            userinfo = f"{userinfo}@"
+
+        host = defaults.REDIS_HOST
+        port = defaults.REDIS_PORT
+        db = defaults.REDIS_DB
+
+        netloc = f"{userinfo}{host}:{port}"
+        return urlunparse((scheme, netloc, f"/{db}", "", "", ""))
+
+    @property
+    def normalized_pubsub_redis_url(self) -> str:
+        pubsub_redis_url = self.PUBSUB_REDIS_URL
+        if pubsub_redis_url:
+            cleaned = pubsub_redis_url.strip()
+            pubsub_redis_url = cleaned or None
+
+        if pubsub_redis_url:
+            return pubsub_redis_url
+
+        return self._build_default_pubsub_url()

api/controllers/common/schema.py

@@ -5,8 +5,6 @@ from enum import StrEnum
 from flask_restx import Namespace
 from pydantic import BaseModel, TypeAdapter
 
-from controllers.console import console_ns
-
 DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
 
 
@@ -24,6 +22,9 @@ def register_schema_models(namespace: Namespace, *models: type[BaseModel]) -> No
 
 
 def get_or_create_model(model_name: str, field_def):
+    # Import lazily to avoid circular imports between console controllers and schema helpers.
+    from controllers.console import console_ns
+
     existing = console_ns.models.get(model_name)
     if existing is None:
         existing = console_ns.model(model_name, field_def)

api/controllers/console/__init__.py

@@ -37,6 +37,7 @@ from . import (
     apikey,
     extension,
     feature,
+    human_input_form,
     init_validate,
     ping,
     setup,
@@ -171,6 +172,7 @@ __all__ = [
     "forgot_password",
     "generator",
     "hit_testing",
+    "human_input_form",
     "init_validate",
     "installed_app",
     "load_balancing_config",

api/controllers/console/apikey.py

@@ -10,6 +10,7 @@ from libs.helper import TimestampField
 from libs.login import current_account_with_tenant, login_required
 from models.dataset import Dataset
 from models.model import ApiToken, App
+from services.api_token_service import ApiTokenCache
 
 from . import console_ns
 from .wraps import account_initialization_required, edit_permission_required, setup_required
@@ -131,6 +132,11 @@ class BaseApiKeyResource(Resource):
         if key is None:
             flask_restx.abort(HTTPStatus.NOT_FOUND, message="API key not found")
 
+        # Invalidate cache before deleting from database
+        # Type assertion: key is guaranteed to be non-None here because abort() raises
+        assert key is not None  # nosec - for type checker only
+        ApiTokenCache.delete(key.token, key.type)
+
         db.session.query(ApiToken).where(ApiToken.id == api_key_id).delete()
         db.session.commit()
 

api/controllers/console/app/app.py

@@ -1,3 +1,4 @@
+import logging
 import uuid
 from datetime import datetime
 from typing import Any, Literal, TypeAlias
@@ -54,6 +55,8 @@ 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)")
@@ -499,6 +502,7 @@ 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()
@@ -510,12 +514,14 @@ class AppListApi(Resource):
                 NodeType.TRIGGER_PLUGIN,
             }
             for workflow in draft_workflows:
+                node_id = None
                 try:
-                    for _, node_data in workflow.walk_nodes():
+                    for node_id, 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:

api/controllers/console/app/conversation.py

@@ -89,6 +89,7 @@ status_count_model = console_ns.model(
         "success": fields.Integer,
         "failed": fields.Integer,
         "partial_success": fields.Integer,
+        "paused": fields.Integer,
     },
 )
 

api/controllers/console/app/generator.py

@@ -1,12 +1,8 @@
-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,
@@ -23,7 +19,6 @@ 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
@@ -46,30 +41,6 @@ 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))
 
@@ -79,7 +50,6 @@ reg(RuleCodeGeneratePayload)
 reg(RuleStructuredOutputPayload)
 reg(InstructionGeneratePayload)
 reg(InstructionTemplatePayload)
-reg(FlowchartGeneratePayload)
 reg(ModelConfig)
 
 
@@ -270,52 +240,6 @@ 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/message.py

@@ -33,7 +33,7 @@ from libs.login import current_account_with_tenant, login_required
 from models.model import AppMode, Conversation, Message, MessageAnnotation, MessageFeedback
 from services.errors.conversation import ConversationNotExistsError
 from services.errors.message import MessageNotExistsError, SuggestedQuestionsAfterAnswerDisabledError
-from services.message_service import MessageService
+from services.message_service import MessageService, attach_message_extra_contents
 
 logger = logging.getLogger(__name__)
 
@@ -207,6 +207,7 @@ message_detail_model = console_ns.model(
         "created_at": TimestampField,
         "agent_thoughts": fields.List(fields.Nested(agent_thought_model)),
         "message_files": fields.List(fields.Nested(message_file_model)),
+        "extra_contents": fields.List(fields.Raw),
         "metadata": fields.Raw(attribute="message_metadata_dict"),
         "status": fields.String,
         "error": fields.String,
@@ -299,6 +300,7 @@ class ChatMessageListApi(Resource):
             has_more = False
 
         history_messages = list(reversed(history_messages))
+        attach_message_extra_contents(history_messages)
 
         return InfiniteScrollPagination(data=history_messages, limit=args.limit, has_more=has_more)
 
@@ -481,4 +483,5 @@ class MessageApi(Resource):
         if not message:
             raise NotFound("Message Not Exists.")
 
+        attach_message_extra_contents([message])
         return message

api/controllers/console/app/workflow.py

@@ -507,6 +507,179 @@ class WorkflowDraftRunLoopNodeApi(Resource):
             raise InternalServerError()
 
 
+class HumanInputFormPreviewPayload(BaseModel):
+    inputs: dict[str, Any] = Field(
+        default_factory=dict,
+        description="Values used to fill missing upstream variables referenced in form_content",
+    )
+
+
+class HumanInputFormSubmitPayload(BaseModel):
+    form_inputs: dict[str, Any] = Field(..., description="Values the user provides for the form's own fields")
+    inputs: dict[str, Any] = Field(
+        ...,
+        description="Values used to fill missing upstream variables referenced in form_content",
+    )
+    action: str = Field(..., description="Selected action ID")
+
+
+class HumanInputDeliveryTestPayload(BaseModel):
+    delivery_method_id: str = Field(..., description="Delivery method ID")
+    inputs: dict[str, Any] = Field(
+        default_factory=dict,
+        description="Values used to fill missing upstream variables referenced in form_content",
+    )
+
+
+reg(HumanInputFormPreviewPayload)
+reg(HumanInputFormSubmitPayload)
+reg(HumanInputDeliveryTestPayload)
+
+
+@console_ns.route("/apps/<uuid:app_id>/advanced-chat/workflows/draft/human-input/nodes/<string:node_id>/form/preview")
+class AdvancedChatDraftHumanInputFormPreviewApi(Resource):
+    @console_ns.doc("get_advanced_chat_draft_human_input_form")
+    @console_ns.doc(description="Get human input form preview for advanced chat workflow")
+    @console_ns.doc(params={"app_id": "Application ID", "node_id": "Node ID"})
+    @console_ns.expect(console_ns.models[HumanInputFormPreviewPayload.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_app_model(mode=[AppMode.ADVANCED_CHAT])
+    @edit_permission_required
+    def post(self, app_model: App, node_id: str):
+        """
+        Preview human input form content and placeholders
+        """
+        current_user, _ = current_account_with_tenant()
+        args = HumanInputFormPreviewPayload.model_validate(console_ns.payload or {})
+        inputs = args.inputs
+
+        workflow_service = WorkflowService()
+        preview = workflow_service.get_human_input_form_preview(
+            app_model=app_model,
+            account=current_user,
+            node_id=node_id,
+            inputs=inputs,
+        )
+        return jsonable_encoder(preview)
+
+
+@console_ns.route("/apps/<uuid:app_id>/advanced-chat/workflows/draft/human-input/nodes/<string:node_id>/form/run")
+class AdvancedChatDraftHumanInputFormRunApi(Resource):
+    @console_ns.doc("submit_advanced_chat_draft_human_input_form")
+    @console_ns.doc(description="Submit human input form preview for advanced chat workflow")
+    @console_ns.doc(params={"app_id": "Application ID", "node_id": "Node ID"})
+    @console_ns.expect(console_ns.models[HumanInputFormSubmitPayload.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_app_model(mode=[AppMode.ADVANCED_CHAT])
+    @edit_permission_required
+    def post(self, app_model: App, node_id: str):
+        """
+        Submit human input form preview
+        """
+        current_user, _ = current_account_with_tenant()
+        args = HumanInputFormSubmitPayload.model_validate(console_ns.payload or {})
+        workflow_service = WorkflowService()
+        result = workflow_service.submit_human_input_form_preview(
+            app_model=app_model,
+            account=current_user,
+            node_id=node_id,
+            form_inputs=args.form_inputs,
+            inputs=args.inputs,
+            action=args.action,
+        )
+        return jsonable_encoder(result)
+
+
+@console_ns.route("/apps/<uuid:app_id>/workflows/draft/human-input/nodes/<string:node_id>/form/preview")
+class WorkflowDraftHumanInputFormPreviewApi(Resource):
+    @console_ns.doc("get_workflow_draft_human_input_form")
+    @console_ns.doc(description="Get human input form preview for workflow")
+    @console_ns.doc(params={"app_id": "Application ID", "node_id": "Node ID"})
+    @console_ns.expect(console_ns.models[HumanInputFormPreviewPayload.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_app_model(mode=[AppMode.WORKFLOW])
+    @edit_permission_required
+    def post(self, app_model: App, node_id: str):
+        """
+        Preview human input form content and placeholders
+        """
+        current_user, _ = current_account_with_tenant()
+        args = HumanInputFormPreviewPayload.model_validate(console_ns.payload or {})
+        inputs = args.inputs
+
+        workflow_service = WorkflowService()
+        preview = workflow_service.get_human_input_form_preview(
+            app_model=app_model,
+            account=current_user,
+            node_id=node_id,
+            inputs=inputs,
+        )
+        return jsonable_encoder(preview)
+
+
+@console_ns.route("/apps/<uuid:app_id>/workflows/draft/human-input/nodes/<string:node_id>/form/run")
+class WorkflowDraftHumanInputFormRunApi(Resource):
+    @console_ns.doc("submit_workflow_draft_human_input_form")
+    @console_ns.doc(description="Submit human input form preview for workflow")
+    @console_ns.doc(params={"app_id": "Application ID", "node_id": "Node ID"})
+    @console_ns.expect(console_ns.models[HumanInputFormSubmitPayload.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_app_model(mode=[AppMode.WORKFLOW])
+    @edit_permission_required
+    def post(self, app_model: App, node_id: str):
+        """
+        Submit human input form preview
+        """
+        current_user, _ = current_account_with_tenant()
+        workflow_service = WorkflowService()
+        args = HumanInputFormSubmitPayload.model_validate(console_ns.payload or {})
+        result = workflow_service.submit_human_input_form_preview(
+            app_model=app_model,
+            account=current_user,
+            node_id=node_id,
+            form_inputs=args.form_inputs,
+            inputs=args.inputs,
+            action=args.action,
+        )
+        return jsonable_encoder(result)
+
+
+@console_ns.route("/apps/<uuid:app_id>/workflows/draft/human-input/nodes/<string:node_id>/delivery-test")
+class WorkflowDraftHumanInputDeliveryTestApi(Resource):
+    @console_ns.doc("test_workflow_draft_human_input_delivery")
+    @console_ns.doc(description="Test human input delivery for workflow")
+    @console_ns.doc(params={"app_id": "Application ID", "node_id": "Node ID"})
+    @console_ns.expect(console_ns.models[HumanInputDeliveryTestPayload.__name__])
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_app_model(mode=[AppMode.WORKFLOW, AppMode.ADVANCED_CHAT])
+    @edit_permission_required
+    def post(self, app_model: App, node_id: str):
+        """
+        Test human input delivery
+        """
+        current_user, _ = current_account_with_tenant()
+        workflow_service = WorkflowService()
+        args = HumanInputDeliveryTestPayload.model_validate(console_ns.payload or {})
+        workflow_service.test_human_input_delivery(
+            app_model=app_model,
+            account=current_user,
+            node_id=node_id,
+            delivery_method_id=args.delivery_method_id,
+            inputs=args.inputs,
+        )
+        return jsonable_encoder({})
+
+
 @console_ns.route("/apps/<uuid:app_id>/workflows/draft/run")
 class DraftWorkflowRunApi(Resource):
     @console_ns.doc("run_draft_workflow")

api/controllers/console/app/workflow_run.py

@@ -5,10 +5,15 @@ from flask import request
 from flask_restx import Resource, fields, marshal_with
 from pydantic import BaseModel, Field, field_validator
 from sqlalchemy import select
+from sqlalchemy.orm import sessionmaker
 
+from configs import dify_config
 from controllers.console import console_ns
 from controllers.console.app.wraps import get_app_model
 from controllers.console.wraps import account_initialization_required, setup_required
+from controllers.web.error import NotFoundError
+from core.workflow.entities.pause_reason import HumanInputRequired
+from core.workflow.enums import WorkflowExecutionStatus
 from extensions.ext_database import db
 from fields.end_user_fields import simple_end_user_fields
 from fields.member_fields import simple_account_fields
@@ -27,9 +32,21 @@ from libs.custom_inputs import time_duration
 from libs.helper import uuid_value
 from libs.login import current_user, login_required
 from models import Account, App, AppMode, EndUser, WorkflowArchiveLog, WorkflowRunTriggeredFrom
+from models.workflow import WorkflowRun
+from repositories.factory import DifyAPIRepositoryFactory
 from services.retention.workflow_run.constants import ARCHIVE_BUNDLE_NAME
 from services.workflow_run_service import WorkflowRunService
 
+
+def _build_backstage_input_url(form_token: str | None) -> str | None:
+    if not form_token:
+        return None
+    base_url = dify_config.APP_WEB_URL
+    if not base_url:
+        return None
+    return f"{base_url.rstrip('/')}/form/{form_token}"
+
+
 # Workflow run status choices for filtering
 WORKFLOW_RUN_STATUS_CHOICES = ["running", "succeeded", "failed", "stopped", "partial-succeeded"]
 EXPORT_SIGNED_URL_EXPIRE_SECONDS = 3600
@@ -440,3 +457,68 @@ class WorkflowRunNodeExecutionListApi(Resource):
         )
 
         return {"data": node_executions}
+
+
+@console_ns.route("/workflow/<string:workflow_run_id>/pause-details")
+class ConsoleWorkflowPauseDetailsApi(Resource):
+    """Console API for getting workflow pause details."""
+
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, workflow_run_id: str):
+        """
+        Get workflow pause details.
+
+        GET /console/api/workflow/<workflow_run_id>/pause-details
+
+        Returns information about why and where the workflow is paused.
+        """
+
+        # Query WorkflowRun to determine if workflow is suspended
+        session_maker = sessionmaker(bind=db.engine)
+        workflow_run_repo = DifyAPIRepositoryFactory.create_api_workflow_run_repository(session_maker=session_maker)
+
+        workflow_run = db.session.get(WorkflowRun, workflow_run_id)
+        if not workflow_run:
+            raise NotFoundError("Workflow run not found")
+
+        if workflow_run.tenant_id != current_user.current_tenant_id:
+            raise NotFoundError("Workflow run not found")
+
+        # Check if workflow is suspended
+        is_paused = workflow_run.status == WorkflowExecutionStatus.PAUSED
+        if not is_paused:
+            return {
+                "paused_at": None,
+                "paused_nodes": [],
+            }, 200
+
+        pause_entity = workflow_run_repo.get_workflow_pause(workflow_run_id)
+        pause_reasons = pause_entity.get_pause_reasons() if pause_entity else []
+
+        # Build response
+        paused_at = pause_entity.paused_at if pause_entity else None
+        paused_nodes = []
+        response = {
+            "paused_at": paused_at.isoformat() + "Z" if paused_at else None,
+            "paused_nodes": paused_nodes,
+        }
+
+        for reason in pause_reasons:
+            if isinstance(reason, HumanInputRequired):
+                paused_nodes.append(
+                    {
+                        "node_id": reason.node_id,
+                        "node_title": reason.node_title,
+                        "pause_type": {
+                            "type": "human_input",
+                            "form_id": reason.form_id,
+                            "backstage_input_url": _build_backstage_input_url(reason.form_token),
+                        },
+                    }
+                )
+            else:
+                raise AssertionError("unimplemented.")
+
+        return response, 200

api/controllers/console/datasets/datasets.py

@@ -55,6 +55,7 @@ from libs.login import current_account_with_tenant, login_required
 from models import ApiToken, Dataset, Document, DocumentSegment, UploadFile
 from models.dataset import DatasetPermissionEnum
 from models.provider_ids import ModelProviderID
+from services.api_token_service import ApiTokenCache
 from services.dataset_service import DatasetPermissionService, DatasetService, DocumentService
 
 # Register models for flask_restx to avoid dict type issues in Swagger
@@ -820,6 +821,11 @@ class DatasetApiDeleteApi(Resource):
         if key is None:
             console_ns.abort(404, message="API key not found")
 
+        # Invalidate cache before deleting from database
+        # Type assertion: key is guaranteed to be non-None here because abort() raises
+        assert key is not None  # nosec - for type checker only
+        ApiTokenCache.delete(key.token, key.type)
+
         db.session.query(ApiToken).where(ApiToken.id == api_key_id).delete()
         db.session.commit()
 

api/controllers/console/human_input_form.py

@@ -0,0 +1,217 @@
+"""
+Console/Studio Human Input Form APIs.
+"""
+
+import json
+import logging
+from collections.abc import Generator
+
+from flask import Response, jsonify, request
+from flask_restx import Resource, reqparse
+from sqlalchemy import select
+from sqlalchemy.orm import Session, sessionmaker
+
+from controllers.console import console_ns
+from controllers.console.wraps import account_initialization_required, setup_required
+from controllers.web.error import InvalidArgumentError, NotFoundError
+from core.app.apps.advanced_chat.app_generator import AdvancedChatAppGenerator
+from core.app.apps.common.workflow_response_converter import WorkflowResponseConverter
+from core.app.apps.message_generator import MessageGenerator
+from core.app.apps.workflow.app_generator import WorkflowAppGenerator
+from extensions.ext_database import db
+from libs.login import current_account_with_tenant, login_required
+from models import App
+from models.enums import CreatorUserRole
+from models.human_input import RecipientType
+from models.model import AppMode
+from models.workflow import WorkflowRun
+from repositories.factory import DifyAPIRepositoryFactory
+from services.human_input_service import Form, HumanInputService
+from services.workflow_event_snapshot_service import build_workflow_event_stream
+
+logger = logging.getLogger(__name__)
+
+
+def _jsonify_form_definition(form: Form) -> Response:
+    payload = form.get_definition().model_dump()
+    payload["expiration_time"] = int(form.expiration_time.timestamp())
+    return Response(json.dumps(payload, ensure_ascii=False), mimetype="application/json")
+
+
+@console_ns.route("/form/human_input/<string:form_token>")
+class ConsoleHumanInputFormApi(Resource):
+    """Console API for getting human input form definition."""
+
+    @staticmethod
+    def _ensure_console_access(form: Form):
+        _, current_tenant_id = current_account_with_tenant()
+
+        if form.tenant_id != current_tenant_id:
+            raise NotFoundError("App not found")
+
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def get(self, form_token: str):
+        """
+        Get human input form definition by form token.
+
+        GET /console/api/form/human_input/<form_token>
+        """
+        service = HumanInputService(db.engine)
+        form = service.get_form_definition_by_token_for_console(form_token)
+        if form is None:
+            raise NotFoundError(f"form not found, token={form_token}")
+
+        self._ensure_console_access(form)
+
+        return _jsonify_form_definition(form)
+
+    @account_initialization_required
+    @login_required
+    def post(self, form_token: str):
+        """
+        Submit human input form by form token.
+
+        POST /console/api/form/human_input/<form_token>
+
+        Request body:
+        {
+            "inputs": {
+                "content": "User input content"
+            },
+            "action": "Approve"
+        }
+        """
+        parser = reqparse.RequestParser()
+        parser.add_argument("inputs", type=dict, required=True, location="json")
+        parser.add_argument("action", type=str, required=True, location="json")
+        args = parser.parse_args()
+        current_user, _ = current_account_with_tenant()
+
+        service = HumanInputService(db.engine)
+        form = service.get_form_by_token(form_token)
+        if form is None:
+            raise NotFoundError(f"form not found, token={form_token}")
+
+        self._ensure_console_access(form)
+
+        recipient_type = form.recipient_type
+        if recipient_type not in {RecipientType.CONSOLE, RecipientType.BACKSTAGE}:
+            raise NotFoundError(f"form not found, token={form_token}")
+        # The type checker is not smart enought to validate the following invariant.
+        # So we need to assert it manually.
+        assert recipient_type is not None, "recipient_type cannot be None here."
+
+        service.submit_form_by_token(
+            recipient_type=recipient_type,
+            form_token=form_token,
+            selected_action_id=args["action"],
+            form_data=args["inputs"],
+            submission_user_id=current_user.id,
+        )
+
+        return jsonify({})
+
+
+@console_ns.route("/workflow/<string:workflow_run_id>/events")
+class ConsoleWorkflowEventsApi(Resource):
+    """Console API for getting workflow execution events after resume."""
+
+    @account_initialization_required
+    @login_required
+    def get(self, workflow_run_id: str):
+        """
+        Get workflow execution events stream after resume.
+
+        GET /console/api/workflow/<workflow_run_id>/events
+
+        Returns Server-Sent Events stream.
+        """
+
+        user, tenant_id = current_account_with_tenant()
+        session_maker = sessionmaker(db.engine)
+        repo = DifyAPIRepositoryFactory.create_api_workflow_run_repository(session_maker)
+        workflow_run = repo.get_workflow_run_by_id_and_tenant_id(
+            tenant_id=tenant_id,
+            run_id=workflow_run_id,
+        )
+        if workflow_run is None:
+            raise NotFoundError(f"WorkflowRun not found, id={workflow_run_id}")
+
+        if workflow_run.created_by_role != CreatorUserRole.ACCOUNT:
+            raise NotFoundError(f"WorkflowRun not created by account, id={workflow_run_id}")
+
+        if workflow_run.created_by != user.id:
+            raise NotFoundError(f"WorkflowRun not created by the current account, id={workflow_run_id}")
+
+        with Session(expire_on_commit=False, bind=db.engine) as session:
+            app = _retrieve_app_for_workflow_run(session, workflow_run)
+
+        if workflow_run.finished_at is not None:
+            # TODO(QuantumGhost): should we modify the handling for finished workflow run here?
+            response = WorkflowResponseConverter.workflow_run_result_to_finish_response(
+                task_id=workflow_run.id,
+                workflow_run=workflow_run,
+                creator_user=user,
+            )
+
+            payload = response.model_dump(mode="json")
+            payload["event"] = response.event.value
+
+            def _generate_finished_events() -> Generator[str, None, None]:
+                yield f"data: {json.dumps(payload)}\n\n"
+
+            event_generator = _generate_finished_events
+
+        else:
+            msg_generator = MessageGenerator()
+            if app.mode == AppMode.ADVANCED_CHAT:
+                generator = AdvancedChatAppGenerator()
+            elif app.mode == AppMode.WORKFLOW:
+                generator = WorkflowAppGenerator()
+            else:
+                raise InvalidArgumentError(f"cannot subscribe to workflow run, workflow_run_id={workflow_run.id}")
+
+            include_state_snapshot = request.args.get("include_state_snapshot", "false").lower() == "true"
+
+            def _generate_stream_events():
+                if include_state_snapshot:
+                    return generator.convert_to_event_stream(
+                        build_workflow_event_stream(
+                            app_mode=AppMode(app.mode),
+                            workflow_run=workflow_run,
+                            tenant_id=workflow_run.tenant_id,
+                            app_id=workflow_run.app_id,
+                            session_maker=session_maker,
+                        )
+                    )
+                return generator.convert_to_event_stream(
+                    msg_generator.retrieve_events(AppMode(app.mode), workflow_run.id),
+                )
+
+            event_generator = _generate_stream_events
+
+        return Response(
+            event_generator(),
+            mimetype="text/event-stream",
+            headers={
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+            },
+        )
+
+
+def _retrieve_app_for_workflow_run(session: Session, workflow_run: WorkflowRun):
+    query = select(App).where(
+        App.id == workflow_run.app_id,
+        App.tenant_id == workflow_run.tenant_id,
+    )
+    app = session.scalars(query).first()
+    if app is None:
+        raise AssertionError(
+            f"App not found for WorkflowRun, workflow_run_id={workflow_run.id}, "
+            f"app_id={workflow_run.app_id}, tenant_id={workflow_run.tenant_id}"
+        )
+
+    return app

api/controllers/console/tag/tags.py

@@ -120,7 +120,7 @@ class TagUpdateDeleteApi(Resource):
 
         TagService.delete_tag(tag_id)
 
-        return 204
+        return "", 204
 
 
 @console_ns.route("/tag-bindings/create")

api/controllers/service_api/__init__.py

@@ -34,6 +34,8 @@ from .dataset import (
     metadata,
     segment,
 )
+from .dataset.rag_pipeline import rag_pipeline_workflow
+from .end_user import end_user
 from .workspace import models
 
 __all__ = [
@@ -44,6 +46,7 @@ __all__ = [
     "conversation",
     "dataset",
     "document",
+    "end_user",
     "file",
     "file_preview",
     "hit_testing",
@@ -51,6 +54,7 @@ __all__ = [
     "message",
     "metadata",
     "models",
+    "rag_pipeline_workflow",
     "segment",
     "site",
     "workflow",

api/controllers/service_api/app/workflow.py

@@ -33,8 +33,9 @@ from core.workflow.graph_engine.manager import GraphEngineManager
 from extensions.ext_database import db
 from fields.workflow_app_log_fields import build_workflow_app_log_pagination_model
 from libs import helper
-from libs.helper import TimestampField
+from libs.helper import OptionalTimestampField, TimestampField
 from models.model import App, AppMode, EndUser
+from models.workflow import WorkflowRun
 from repositories.factory import DifyAPIRepositoryFactory
 from services.app_generate_service import AppGenerateService
 from services.errors.app import IsDraftWorkflowError, WorkflowIdFormatError, WorkflowNotFoundError
@@ -63,17 +64,32 @@ class WorkflowLogQuery(BaseModel):
 
 register_schema_models(service_api_ns, WorkflowRunPayload, WorkflowLogQuery)
 
+
+class WorkflowRunStatusField(fields.Raw):
+    def output(self, key, obj: WorkflowRun, **kwargs):
+        return obj.status.value
+
+
+class WorkflowRunOutputsField(fields.Raw):
+    def output(self, key, obj: WorkflowRun, **kwargs):
+        if obj.status == WorkflowExecutionStatus.PAUSED:
+            return {}
+
+        outputs = obj.outputs_dict
+        return outputs or {}
+
+
 workflow_run_fields = {
     "id": fields.String,
     "workflow_id": fields.String,
-    "status": fields.String,
+    "status": WorkflowRunStatusField,
     "inputs": fields.Raw,
-    "outputs": fields.Raw,
+    "outputs": WorkflowRunOutputsField,
     "error": fields.String,
     "total_steps": fields.Integer,
     "total_tokens": fields.Integer,
     "created_at": TimestampField,
-    "finished_at": TimestampField,
+    "finished_at": OptionalTimestampField,
     "elapsed_time": fields.Float,
 }
 

api/controllers/service_api/dataset/dataset.py

@@ -396,7 +396,7 @@ class DatasetApi(DatasetApiResource):
         try:
             if DatasetService.delete_dataset(dataset_id_str, current_user):
                 DatasetPermissionService.clear_partial_member_list(dataset_id_str)
-                return 204
+                return "", 204
             else:
                 raise NotFound("Dataset not found.")
         except services.errors.dataset.DatasetInUseError:
@@ -557,7 +557,7 @@ class DatasetTagsApi(DatasetApiResource):
         payload = TagDeletePayload.model_validate(service_api_ns.payload or {})
         TagService.delete_tag(payload.tag_id)
 
-        return 204
+        return "", 204
 
 
 @service_api_ns.route("/datasets/tags/binding")
@@ -581,7 +581,7 @@ class DatasetTagBindingApi(DatasetApiResource):
         payload = TagBindingPayload.model_validate(service_api_ns.payload or {})
         TagService.save_tag_binding({"tag_ids": payload.tag_ids, "target_id": payload.target_id, "type": "knowledge"})
 
-        return 204
+        return "", 204
 
 
 @service_api_ns.route("/datasets/tags/unbinding")
@@ -605,7 +605,7 @@ class DatasetTagUnbindingApi(DatasetApiResource):
         payload = TagUnbindingPayload.model_validate(service_api_ns.payload or {})
         TagService.delete_tag_binding({"tag_id": payload.tag_id, "target_id": payload.target_id, "type": "knowledge"})
 
-        return 204
+        return "", 204
 
 
 @service_api_ns.route("/datasets/<uuid:dataset_id>/tags")

api/controllers/service_api/dataset/document.py

@@ -746,4 +746,4 @@ class DocumentApi(DatasetApiResource):
         except services.errors.document.DocumentIndexingError:
             raise DocumentIndexingError("Cannot delete document during indexing.")
 
-        return 204
+        return "", 204

api/controllers/service_api/dataset/metadata.py

@@ -128,7 +128,7 @@ class DatasetMetadataServiceApi(DatasetApiResource):
         DatasetService.check_dataset_permission(dataset, current_user)
 
         MetadataService.delete_metadata(dataset_id_str, metadata_id_str)
-        return 204
+        return "", 204
 
 
 @service_api_ns.route("/datasets/<uuid:dataset_id>/metadata/built-in")

api/controllers/service_api/dataset/rag_pipeline/rag_pipeline_workflow.py

@@ -1,5 +1,3 @@
-import string
-import uuid
 from collections.abc import Generator
 from typing import Any
 
@@ -12,6 +10,7 @@ from controllers.common.errors import FilenameNotExistsError, NoFileUploadedErro
 from controllers.common.schema import register_schema_model
 from controllers.service_api import service_api_ns
 from controllers.service_api.dataset.error import PipelineRunError
+from controllers.service_api.dataset.rag_pipeline.serializers import serialize_upload_file
 from controllers.service_api.wraps import DatasetApiResource
 from core.app.apps.pipeline.pipeline_generator import PipelineGenerator
 from core.app.entities.app_invoke_entities import InvokeFrom
@@ -41,7 +40,7 @@ register_schema_model(service_api_ns, DatasourceNodeRunPayload)
 register_schema_model(service_api_ns, PipelineRunApiEntity)
 
 
-@service_api_ns.route(f"/datasets/{uuid:dataset_id}/pipeline/datasource-plugins")
+@service_api_ns.route("/datasets/<uuid:dataset_id>/pipeline/datasource-plugins")
 class DatasourcePluginsApi(DatasetApiResource):
     """Resource for datasource plugins."""
 
@@ -76,7 +75,7 @@ class DatasourcePluginsApi(DatasetApiResource):
         return datasource_plugins, 200
 
 
-@service_api_ns.route(f"/datasets/{uuid:dataset_id}/pipeline/datasource/nodes/{string:node_id}/run")
+@service_api_ns.route("/datasets/<uuid:dataset_id>/pipeline/datasource/nodes/<string:node_id>/run")
 class DatasourceNodeRunApi(DatasetApiResource):
     """Resource for datasource node run."""
 
@@ -131,7 +130,7 @@ class DatasourceNodeRunApi(DatasetApiResource):
         )
 
 
-@service_api_ns.route(f"/datasets/{uuid:dataset_id}/pipeline/run")
+@service_api_ns.route("/datasets/<uuid:dataset_id>/pipeline/run")
 class PipelineRunApi(DatasetApiResource):
     """Resource for datasource node run."""
 
@@ -232,12 +231,4 @@ class KnowledgebasePipelineFileUploadApi(DatasetApiResource):
         except services.errors.file.UnsupportedFileTypeError:
             raise UnsupportedFileTypeError()
 
-        return {
-            "id": upload_file.id,
-            "name": upload_file.name,
-            "size": upload_file.size,
-            "extension": upload_file.extension,
-            "mime_type": upload_file.mime_type,
-            "created_by": upload_file.created_by,
-            "created_at": upload_file.created_at,
-        }, 201
+        return serialize_upload_file(upload_file), 201

api/controllers/service_api/dataset/rag_pipeline/serializers.py

@@ -0,0 +1,22 @@
+"""
+Serialization helpers for Service API knowledge pipeline endpoints.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from models.model import UploadFile
+
+
+def serialize_upload_file(upload_file: UploadFile) -> dict[str, Any]:
+    return {
+        "id": upload_file.id,
+        "name": upload_file.name,
+        "size": upload_file.size,
+        "extension": upload_file.extension,
+        "mime_type": upload_file.mime_type,
+        "created_by": upload_file.created_by,
+        "created_at": upload_file.created_at.isoformat() if upload_file.created_at else None,
+    }

api/controllers/service_api/dataset/segment.py

@@ -233,7 +233,7 @@ class DatasetSegmentApi(DatasetApiResource):
         if not segment:
             raise NotFound("Segment not found.")
         SegmentService.delete_segment(segment, document, dataset)
-        return 204
+        return "", 204
 
     @service_api_ns.expect(service_api_ns.models[SegmentUpdatePayload.__name__])
     @service_api_ns.doc("update_segment")
@@ -499,7 +499,7 @@ class DatasetChildChunkApi(DatasetApiResource):
         except ChildChunkDeleteIndexServiceError as e:
             raise ChildChunkDeleteIndexError(str(e))
 
-        return 204
+        return "", 204
 
     @service_api_ns.expect(service_api_ns.models[ChildChunkUpdatePayload.__name__])
     @service_api_ns.doc("update_child_chunk")

api/controllers/service_api/end_user/__init__.py

@@ -0,0 +1,3 @@
+from . import end_user
+
+__all__ = ["end_user"]

api/controllers/service_api/end_user/end_user.py

@@ -0,0 +1,41 @@
+from uuid import UUID
+
+from flask_restx import Resource
+
+from controllers.service_api import service_api_ns
+from controllers.service_api.end_user.error import EndUserNotFoundError
+from controllers.service_api.wraps import validate_app_token
+from fields.end_user_fields import EndUserDetail
+from models.model import App
+from services.end_user_service import EndUserService
+
+
+@service_api_ns.route("/end-users/<uuid:end_user_id>")
+class EndUserApi(Resource):
+    """Resource for retrieving end user details by ID."""
+
+    @service_api_ns.doc("get_end_user")
+    @service_api_ns.doc(description="Get an end user by ID")
+    @service_api_ns.doc(
+        params={"end_user_id": "End user ID"},
+        responses={
+            200: "End user retrieved successfully",
+            401: "Unauthorized - invalid API token",
+            404: "End user not found",
+        },
+    )
+    @validate_app_token
+    def get(self, app_model: App, end_user_id: UUID):
+        """Get end user detail.
+
+        This endpoint is scoped to the current app token's tenant/app to prevent
+        cross-tenant/app access when an end-user ID is known.
+        """
+
+        end_user = EndUserService.get_end_user_by_id(
+            tenant_id=app_model.tenant_id, app_id=app_model.id, end_user_id=str(end_user_id)
+        )
+        if end_user is None:
+            raise EndUserNotFoundError()
+
+        return EndUserDetail.model_validate(end_user).model_dump(mode="json")

api/controllers/service_api/end_user/error.py

@@ -0,0 +1,7 @@
+from libs.exception import BaseHTTPException
+
+
+class EndUserNotFoundError(BaseHTTPException):
+    error_code = "end_user_not_found"
+    description = "End user not found."
+    code = 404

api/controllers/service_api/wraps.py

@@ -1,27 +1,24 @@
 import logging
 import time
 from collections.abc import Callable
-from datetime import timedelta
 from enum import StrEnum, auto
 from functools import wraps
-from typing import Concatenate, ParamSpec, TypeVar
+from typing import Concatenate, ParamSpec, TypeVar, cast
 
 from flask import current_app, request
 from flask_login import user_logged_in
 from flask_restx import Resource
 from pydantic import BaseModel
-from sqlalchemy import select, update
-from sqlalchemy.orm import Session
 from werkzeug.exceptions import Forbidden, NotFound, Unauthorized
 
 from enums.cloud_plan import CloudPlan
 from extensions.ext_database import db
 from extensions.ext_redis import redis_client
-from libs.datetime_utils import naive_utc_now
 from libs.login import current_user
 from models import Account, Tenant, TenantAccountJoin, TenantStatus
 from models.dataset import Dataset, RateLimitLog
 from models.model import ApiToken, App
+from services.api_token_service import ApiTokenCache, fetch_token_with_single_flight, record_token_usage
 from services.end_user_service import EndUserService
 from services.feature_service import FeatureService
 
@@ -220,6 +217,8 @@ def validate_dataset_token(view: Callable[Concatenate[T, P], R] | None = None):
     def decorator(view: Callable[Concatenate[T, P], R]):
         @wraps(view)
         def decorated(*args: P.args, **kwargs: P.kwargs):
+            api_token = validate_and_get_api_token("dataset")
+
             # get url path dataset_id from positional args or kwargs
             # Flask passes URL path parameters as positional arguments
             dataset_id = None
@@ -256,12 +255,18 @@ def validate_dataset_token(view: Callable[Concatenate[T, P], R] | None = None):
             # Validate dataset if dataset_id is provided
             if dataset_id:
                 dataset_id = str(dataset_id)
-                dataset = db.session.query(Dataset).where(Dataset.id == dataset_id).first()
+                dataset = (
+                    db.session.query(Dataset)
+                    .where(
+                        Dataset.id == dataset_id,
+                        Dataset.tenant_id == api_token.tenant_id,
+                    )
+                    .first()
+                )
                 if not dataset:
                     raise NotFound("Dataset not found.")
                 if not dataset.enable_api:
                     raise Forbidden("Dataset api access is not enabled.")
-            api_token = validate_and_get_api_token("dataset")
             tenant_account_join = (
                 db.session.query(Tenant, TenantAccountJoin)
                 .where(Tenant.id == api_token.tenant_id)
@@ -296,7 +301,14 @@ def validate_dataset_token(view: Callable[Concatenate[T, P], R] | None = None):
 
 def validate_and_get_api_token(scope: str | None = None):
     """
-    Validate and get API token.
+    Validate and get API token with Redis caching.
+
+    This function uses a two-tier approach:
+    1. First checks Redis cache for the token
+    2. If not cached, queries database and caches the result
+
+    The last_used_at field is updated asynchronously via Celery task
+    to avoid blocking the request.
     """
     auth_header = request.headers.get("Authorization")
     if auth_header is None or " " not in auth_header:
@@ -308,29 +320,18 @@ def validate_and_get_api_token(scope: str | None = None):
     if auth_scheme != "bearer":
         raise Unauthorized("Authorization scheme must be 'Bearer'")
 
-    current_time = naive_utc_now()
-    cutoff_time = current_time - timedelta(minutes=1)
-    with Session(db.engine, expire_on_commit=False) as session:
-        update_stmt = (
-            update(ApiToken)
-            .where(
-                ApiToken.token == auth_token,
-                (ApiToken.last_used_at.is_(None) | (ApiToken.last_used_at < cutoff_time)),
-                ApiToken.type == scope,
-            )
-            .values(last_used_at=current_time)
-        )
-        stmt = select(ApiToken).where(ApiToken.token == auth_token, ApiToken.type == scope)
-        result = session.execute(update_stmt)
-        api_token = session.scalar(stmt)
+    # Try to get token from cache first
+    # Returns a CachedApiToken (plain Python object), not a SQLAlchemy model
+    cached_token = ApiTokenCache.get(auth_token, scope)
+    if cached_token is not None:
+        logger.debug("Token validation served from cache for scope: %s", scope)
+        # Record usage in Redis for later batch update (no Celery task per request)
+        record_token_usage(auth_token, scope)
+        return cast(ApiToken, cached_token)
 
-        if hasattr(result, "rowcount") and result.rowcount > 0:
-            session.commit()
-
-        if not api_token:
-            raise Unauthorized("Access token is invalid")
-
-    return api_token
+    # Cache miss - use Redis lock for single-flight mode
+    # This ensures only one request queries DB for the same token concurrently
+    return fetch_token_with_single_flight(auth_token, scope)
 
 
 class DatasetApiResource(Resource):

api/controllers/web/__init__.py

@@ -23,6 +23,7 @@ from . import (
     feature,
     files,
     forgot_password,
+    human_input_form,
     login,
     message,
     passport,
@@ -30,6 +31,7 @@ from . import (
     saved_message,
     site,
     workflow,
+    workflow_events,
 )
 
 api.add_namespace(web_ns)
@@ -44,6 +46,7 @@ __all__ = [
     "feature",
     "files",
     "forgot_password",
+    "human_input_form",
     "login",
     "message",
     "passport",
@@ -52,4 +55,5 @@ __all__ = [
     "site",
     "web_ns",
     "workflow",
+    "workflow_events",
 ]

api/controllers/web/error.py

@@ -117,6 +117,12 @@ class InvokeRateLimitError(BaseHTTPException):
     code = 429
 
 
+class WebFormRateLimitExceededError(BaseHTTPException):
+    error_code = "web_form_rate_limit_exceeded"
+    description = "Too many form requests. Please try again later."
+    code = 429
+
+
 class NotFoundError(BaseHTTPException):
     error_code = "not_found"
     code = 404

api/controllers/web/human_input_form.py

@@ -0,0 +1,161 @@
+"""
+Web App Human Input Form APIs.
+"""
+
+import json
+import logging
+from datetime import datetime
+
+from flask import Response, request
+from flask_restx import Resource, reqparse
+from werkzeug.exceptions import Forbidden
+
+from configs import dify_config
+from controllers.web import web_ns
+from controllers.web.error import NotFoundError, WebFormRateLimitExceededError
+from controllers.web.site import serialize_app_site_payload
+from extensions.ext_database import db
+from libs.helper import RateLimiter, extract_remote_ip
+from models.account import TenantStatus
+from models.model import App, Site
+from services.human_input_service import Form, FormNotFoundError, HumanInputService
+
+logger = logging.getLogger(__name__)
+
+_FORM_SUBMIT_RATE_LIMITER = RateLimiter(
+    prefix="web_form_submit_rate_limit",
+    max_attempts=dify_config.WEB_FORM_SUBMIT_RATE_LIMIT_MAX_ATTEMPTS,
+    time_window=dify_config.WEB_FORM_SUBMIT_RATE_LIMIT_WINDOW_SECONDS,
+)
+_FORM_ACCESS_RATE_LIMITER = RateLimiter(
+    prefix="web_form_access_rate_limit",
+    max_attempts=dify_config.WEB_FORM_SUBMIT_RATE_LIMIT_MAX_ATTEMPTS,
+    time_window=dify_config.WEB_FORM_SUBMIT_RATE_LIMIT_WINDOW_SECONDS,
+)
+
+
+def _stringify_default_values(values: dict[str, object]) -> dict[str, str]:
+    result: dict[str, str] = {}
+    for key, value in values.items():
+        if value is None:
+            result[key] = ""
+        elif isinstance(value, (dict, list)):
+            result[key] = json.dumps(value, ensure_ascii=False)
+        else:
+            result[key] = str(value)
+    return result
+
+
+def _to_timestamp(value: datetime) -> int:
+    return int(value.timestamp())
+
+
+def _jsonify_form_definition(form: Form, site_payload: dict | None = None) -> Response:
+    """Return the form payload (optionally with site) as a JSON response."""
+    definition_payload = form.get_definition().model_dump()
+    payload = {
+        "form_content": definition_payload["rendered_content"],
+        "inputs": definition_payload["inputs"],
+        "resolved_default_values": _stringify_default_values(definition_payload["default_values"]),
+        "user_actions": definition_payload["user_actions"],
+        "expiration_time": _to_timestamp(form.expiration_time),
+    }
+    if site_payload is not None:
+        payload["site"] = site_payload
+    return Response(json.dumps(payload, ensure_ascii=False), mimetype="application/json")
+
+
+@web_ns.route("/form/human_input/<string:form_token>")
+class HumanInputFormApi(Resource):
+    """API for getting and submitting human input forms via the web app."""
+
+    # NOTE(QuantumGhost): this endpoint is unauthenticated on purpose for now.
+
+    # def get(self, _app_model: App, _end_user: EndUser, form_token: str):
+    def get(self, form_token: str):
+        """
+        Get human input form definition by token.
+
+        GET /api/form/human_input/<form_token>
+        """
+        ip_address = extract_remote_ip(request)
+        if _FORM_ACCESS_RATE_LIMITER.is_rate_limited(ip_address):
+            raise WebFormRateLimitExceededError()
+        _FORM_ACCESS_RATE_LIMITER.increment_rate_limit(ip_address)
+
+        service = HumanInputService(db.engine)
+        # TODO(QuantumGhost): forbid submision for form tokens
+        # that are only for console.
+        form = service.get_form_by_token(form_token)
+
+        if form is None:
+            raise NotFoundError("Form not found")
+
+        service.ensure_form_active(form)
+        app_model, site = _get_app_site_from_form(form)
+
+        return _jsonify_form_definition(form, site_payload=serialize_app_site_payload(app_model, site, None))
+
+    # def post(self, _app_model: App, _end_user: EndUser, form_token: str):
+    def post(self, form_token: str):
+        """
+        Submit human input form by token.
+
+        POST /api/form/human_input/<form_token>
+
+        Request body:
+        {
+            "inputs": {
+                "content": "User input content"
+            },
+            "action": "Approve"
+        }
+        """
+        parser = reqparse.RequestParser()
+        parser.add_argument("inputs", type=dict, required=True, location="json")
+        parser.add_argument("action", type=str, required=True, location="json")
+        args = parser.parse_args()
+
+        ip_address = extract_remote_ip(request)
+        if _FORM_SUBMIT_RATE_LIMITER.is_rate_limited(ip_address):
+            raise WebFormRateLimitExceededError()
+        _FORM_SUBMIT_RATE_LIMITER.increment_rate_limit(ip_address)
+
+        service = HumanInputService(db.engine)
+        form = service.get_form_by_token(form_token)
+        if form is None:
+            raise NotFoundError("Form not found")
+
+        if (recipient_type := form.recipient_type) is None:
+            logger.warning("Recipient type is None for form, form_id=%", form.id)
+            raise AssertionError("Recipient type is None")
+
+        try:
+            service.submit_form_by_token(
+                recipient_type=recipient_type,
+                form_token=form_token,
+                selected_action_id=args["action"],
+                form_data=args["inputs"],
+                submission_end_user_id=None,
+                # submission_end_user_id=_end_user.id,
+            )
+        except FormNotFoundError:
+            raise NotFoundError("Form not found")
+
+        return {}, 200
+
+
+def _get_app_site_from_form(form: Form) -> tuple[App, Site]:
+    """Resolve App/Site for the form's app and validate tenant status."""
+    app_model = db.session.query(App).where(App.id == form.app_id).first()
+    if app_model is None or app_model.tenant_id != form.tenant_id:
+        raise NotFoundError("Form not found")
+
+    site = db.session.query(Site).where(Site.app_id == app_model.id).first()
+    if site is None:
+        raise Forbidden()
+
+    if app_model.tenant and app_model.tenant.status == TenantStatus.ARCHIVE:
+        raise Forbidden()
+
+    return app_model, site

api/controllers/web/site.py

@@ -1,4 +1,6 @@
-from flask_restx import fields, marshal_with
+from typing import cast
+
+from flask_restx import fields, marshal, marshal_with
 from werkzeug.exceptions import Forbidden
 
 from configs import dify_config
@@ -7,7 +9,7 @@ from controllers.web.wraps import WebApiResource
 from extensions.ext_database import db
 from libs.helper import AppIconUrlField
 from models.account import TenantStatus
-from models.model import Site
+from models.model import App, Site
 from services.feature_service import FeatureService
 
 
@@ -108,3 +110,14 @@ class AppSiteInfo:
                 "remove_webapp_brand": remove_webapp_brand,
                 "replace_webapp_logo": replace_webapp_logo,
             }
+
+
+def serialize_site(site: Site) -> dict:
+    """Serialize Site model using the same schema as AppSiteApi."""
+    return cast(dict, marshal(site, AppSiteApi.site_fields))
+
+
+def serialize_app_site_payload(app_model: App, site: Site, end_user_id: str | None) -> dict:
+    can_replace_logo = FeatureService.get_features(app_model.tenant_id).can_replace_logo
+    app_site_info = AppSiteInfo(app_model.tenant, app_model, site, end_user_id, can_replace_logo)
+    return cast(dict, marshal(app_site_info, AppSiteApi.app_fields))

api/controllers/web/workflow_events.py

@@ -0,0 +1,112 @@
+"""
+Web App Workflow Resume APIs.
+"""
+
+import json
+from collections.abc import Generator
+
+from flask import Response, request
+from sqlalchemy.orm import sessionmaker
+
+from controllers.web import api
+from controllers.web.error import InvalidArgumentError, NotFoundError
+from controllers.web.wraps import WebApiResource
+from core.app.apps.advanced_chat.app_generator import AdvancedChatAppGenerator
+from core.app.apps.base_app_generator import BaseAppGenerator
+from core.app.apps.common.workflow_response_converter import WorkflowResponseConverter
+from core.app.apps.message_generator import MessageGenerator
+from core.app.apps.workflow.app_generator import WorkflowAppGenerator
+from extensions.ext_database import db
+from models.enums import CreatorUserRole
+from models.model import App, AppMode, EndUser
+from repositories.factory import DifyAPIRepositoryFactory
+from services.workflow_event_snapshot_service import build_workflow_event_stream
+
+
+class WorkflowEventsApi(WebApiResource):
+    """API for getting workflow execution events after resume."""
+
+    def get(self, app_model: App, end_user: EndUser, task_id: str):
+        """
+        Get workflow execution events stream after resume.
+
+        GET /api/workflow/<task_id>/events
+
+        Returns Server-Sent Events stream.
+        """
+        workflow_run_id = task_id
+        session_maker = sessionmaker(db.engine)
+        repo = DifyAPIRepositoryFactory.create_api_workflow_run_repository(session_maker)
+        workflow_run = repo.get_workflow_run_by_id_and_tenant_id(
+            tenant_id=app_model.tenant_id,
+            run_id=workflow_run_id,
+        )
+
+        if workflow_run is None:
+            raise NotFoundError(f"WorkflowRun not found, id={workflow_run_id}")
+
+        if workflow_run.app_id != app_model.id:
+            raise NotFoundError(f"WorkflowRun not found, id={workflow_run_id}")
+
+        if workflow_run.created_by_role != CreatorUserRole.END_USER:
+            raise NotFoundError(f"WorkflowRun not created by end user, id={workflow_run_id}")
+
+        if workflow_run.created_by != end_user.id:
+            raise NotFoundError(f"WorkflowRun not created by the current end user, id={workflow_run_id}")
+
+        if workflow_run.finished_at is not None:
+            response = WorkflowResponseConverter.workflow_run_result_to_finish_response(
+                task_id=workflow_run.id,
+                workflow_run=workflow_run,
+                creator_user=end_user,
+            )
+
+            payload = response.model_dump(mode="json")
+            payload["event"] = response.event.value
+
+            def _generate_finished_events() -> Generator[str, None, None]:
+                yield f"data: {json.dumps(payload)}\n\n"
+
+            event_generator = _generate_finished_events
+        else:
+            app_mode = AppMode.value_of(app_model.mode)
+            msg_generator = MessageGenerator()
+            generator: BaseAppGenerator
+            if app_mode == AppMode.ADVANCED_CHAT:
+                generator = AdvancedChatAppGenerator()
+            elif app_mode == AppMode.WORKFLOW:
+                generator = WorkflowAppGenerator()
+            else:
+                raise InvalidArgumentError(f"cannot subscribe to workflow run, workflow_run_id={workflow_run.id}")
+
+            include_state_snapshot = request.args.get("include_state_snapshot", "false").lower() == "true"
+
+            def _generate_stream_events():
+                if include_state_snapshot:
+                    return generator.convert_to_event_stream(
+                        build_workflow_event_stream(
+                            app_mode=app_mode,
+                            workflow_run=workflow_run,
+                            tenant_id=app_model.tenant_id,
+                            app_id=app_model.id,
+                            session_maker=session_maker,
+                        )
+                    )
+                return generator.convert_to_event_stream(
+                    msg_generator.retrieve_events(app_mode, workflow_run.id),
+                )
+
+            event_generator = _generate_stream_events
+
+        return Response(
+            event_generator(),
+            mimetype="text/event-stream",
+            headers={
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+            },
+        )
+
+
+# Register the APIs
+api.add_resource(WorkflowEventsApi, "/workflow/<string:task_id>/events")

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

@@ -4,8 +4,8 @@ import contextvars
 import logging
 import threading
 import uuid
-from collections.abc import Generator, Mapping
-from typing import TYPE_CHECKING, Any, Literal, Union, overload
+from collections.abc import Generator, Mapping, Sequence
+from typing import TYPE_CHECKING, Any, Literal, TypeVar, Union, overload
 
 from flask import Flask, current_app
 from pydantic import ValidationError
@@ -29,21 +29,25 @@ from core.app.apps.message_based_app_generator import MessageBasedAppGenerator
 from core.app.apps.message_based_app_queue_manager import MessageBasedAppQueueManager
 from core.app.entities.app_invoke_entities import AdvancedChatAppGenerateEntity, InvokeFrom
 from core.app.entities.task_entities import ChatbotAppBlockingResponse, ChatbotAppStreamResponse
+from core.app.layers.pause_state_persist_layer import PauseStateLayerConfig, PauseStatePersistenceLayer
 from core.helper.trace_id_helper import extract_external_trace_id_from_args
 from core.model_runtime.errors.invoke import InvokeAuthorizationError
 from core.ops.ops_trace_manager import TraceQueueManager
 from core.prompt.utils.get_thread_messages_length import get_thread_messages_length
 from core.repositories import DifyCoreRepositoryFactory
+from core.workflow.graph_engine.layers.base import GraphEngineLayer
 from core.workflow.repositories.draft_variable_repository import (
     DraftVariableSaverFactory,
 )
 from core.workflow.repositories.workflow_execution_repository import WorkflowExecutionRepository
 from core.workflow.repositories.workflow_node_execution_repository import WorkflowNodeExecutionRepository
+from core.workflow.runtime import GraphRuntimeState
 from core.workflow.variable_loader import DUMMY_VARIABLE_LOADER, VariableLoader
 from extensions.ext_database import db
 from factories import file_factory
 from libs.flask_utils import preserve_flask_contexts
 from models import Account, App, Conversation, EndUser, Message, Workflow, WorkflowNodeExecutionTriggeredFrom
+from models.base import Base
 from models.enums import WorkflowRunTriggeredFrom
 from services.conversation_service import ConversationService
 from services.workflow_draft_variable_service import (
@@ -65,7 +69,9 @@ class AdvancedChatAppGenerator(MessageBasedAppGenerator):
         user: Union[Account, EndUser],
         args: Mapping[str, Any],
         invoke_from: InvokeFrom,
+        workflow_run_id: str,
         streaming: Literal[False],
+        pause_state_config: PauseStateLayerConfig | None = None,
     ) -> Mapping[str, Any]: ...
 
     @overload
@@ -74,9 +80,11 @@ class AdvancedChatAppGenerator(MessageBasedAppGenerator):
         app_model: App,
         workflow: Workflow,
         user: Union[Account, EndUser],
-        args: Mapping,
+        args: Mapping[str, Any],
         invoke_from: InvokeFrom,
+        workflow_run_id: str,
         streaming: Literal[True],
+        pause_state_config: PauseStateLayerConfig | None = None,
     ) -> Generator[Mapping | str, None, None]: ...
 
     @overload
@@ -85,9 +93,11 @@ class AdvancedChatAppGenerator(MessageBasedAppGenerator):
         app_model: App,
         workflow: Workflow,
         user: Union[Account, EndUser],
-        args: Mapping,
+        args: Mapping[str, Any],
         invoke_from: InvokeFrom,
+        workflow_run_id: str,
         streaming: bool,
+        pause_state_config: PauseStateLayerConfig | None = None,
     ) -> Mapping[str, Any] | Generator[str | Mapping, None, None]: ...
 
     def generate(
@@ -95,9 +105,11 @@ class AdvancedChatAppGenerator(MessageBasedAppGenerator):
         app_model: App,
         workflow: Workflow,
         user: Union[Account, EndUser],
-        args: Mapping,
+        args: Mapping[str, Any],
         invoke_from: InvokeFrom,
+        workflow_run_id: str,
         streaming: bool = True,
+        pause_state_config: PauseStateLayerConfig | None = None,
     ) -> Mapping[str, Any] | Generator[str | Mapping, None, None]:
         """
         Generate App response.
@@ -161,7 +173,6 @@ class AdvancedChatAppGenerator(MessageBasedAppGenerator):
             # always enable retriever resource in debugger mode
             app_config.additional_features.show_retrieve_source = True  # type: ignore
 
-        workflow_run_id = str(uuid.uuid4())
         # init application generate entity
         application_generate_entity = AdvancedChatAppGenerateEntity(
             task_id=str(uuid.uuid4()),
@@ -179,7 +190,7 @@ class AdvancedChatAppGenerator(MessageBasedAppGenerator):
             invoke_from=invoke_from,
             extras=extras,
             trace_manager=trace_manager,
-            workflow_run_id=workflow_run_id,
+            workflow_run_id=str(workflow_run_id),
         )
         contexts.plugin_tool_providers.set({})
         contexts.plugin_tool_providers_lock.set(threading.Lock())
@@ -216,6 +227,38 @@ class AdvancedChatAppGenerator(MessageBasedAppGenerator):
             workflow_node_execution_repository=workflow_node_execution_repository,
             conversation=conversation,
             stream=streaming,
+            pause_state_config=pause_state_config,
+        )
+
+    def resume(
+        self,
+        *,
+        app_model: App,
+        workflow: Workflow,
+        user: Union[Account, EndUser],
+        conversation: Conversation,
+        message: Message,
+        application_generate_entity: AdvancedChatAppGenerateEntity,
+        workflow_execution_repository: WorkflowExecutionRepository,
+        workflow_node_execution_repository: WorkflowNodeExecutionRepository,
+        graph_runtime_state: GraphRuntimeState,
+        pause_state_config: PauseStateLayerConfig | None = None,
+    ):
+        """
+        Resume a paused advanced chat execution.
+        """
+        return self._generate(
+            workflow=workflow,
+            user=user,
+            invoke_from=application_generate_entity.invoke_from,
+            application_generate_entity=application_generate_entity,
+            workflow_execution_repository=workflow_execution_repository,
+            workflow_node_execution_repository=workflow_node_execution_repository,
+            conversation=conversation,
+            message=message,
+            stream=application_generate_entity.stream,
+            pause_state_config=pause_state_config,
+            graph_runtime_state=graph_runtime_state,
         )
 
     def single_iteration_generate(
@@ -396,8 +439,12 @@ class AdvancedChatAppGenerator(MessageBasedAppGenerator):
         workflow_execution_repository: WorkflowExecutionRepository,
         workflow_node_execution_repository: WorkflowNodeExecutionRepository,
         conversation: Conversation | None = None,
+        message: Message | None = None,
         stream: bool = True,
         variable_loader: VariableLoader = DUMMY_VARIABLE_LOADER,
+        pause_state_config: PauseStateLayerConfig | None = None,
+        graph_runtime_state: GraphRuntimeState | None = None,
+        graph_engine_layers: Sequence[GraphEngineLayer] = (),
     ) -> Mapping[str, Any] | Generator[str | Mapping[str, Any], Any, None]:
         """
         Generate App response.
@@ -411,12 +458,12 @@ class AdvancedChatAppGenerator(MessageBasedAppGenerator):
         :param conversation: conversation
         :param stream: is stream
         """
-        is_first_conversation = False
-        if not conversation:
-            is_first_conversation = True
+        is_first_conversation = conversation is None
 
-        # init generate records
-        (conversation, message) = self._init_generate_records(application_generate_entity, conversation)
+        if conversation is not None and message is not None:
+            pass
+        else:
+            conversation, message = self._init_generate_records(application_generate_entity, conversation)
 
         if is_first_conversation:
             # update conversation features
@@ -439,6 +486,16 @@ class AdvancedChatAppGenerator(MessageBasedAppGenerator):
             message_id=message.id,
         )
 
+        graph_layers: list[GraphEngineLayer] = list(graph_engine_layers)
+        if pause_state_config is not None:
+            graph_layers.append(
+                PauseStatePersistenceLayer(
+                    session_factory=pause_state_config.session_factory,
+                    generate_entity=application_generate_entity,
+                    state_owner_user_id=pause_state_config.state_owner_user_id,
+                )
+            )
+
         # new thread with request context and contextvars
         context = contextvars.copy_context()
 
@@ -454,14 +511,25 @@ class AdvancedChatAppGenerator(MessageBasedAppGenerator):
                 "variable_loader": variable_loader,
                 "workflow_execution_repository": workflow_execution_repository,
                 "workflow_node_execution_repository": workflow_node_execution_repository,
+                "graph_engine_layers": tuple(graph_layers),
+                "graph_runtime_state": graph_runtime_state,
             },
         )
 
         worker_thread.start()
 
         # release database connection, because the following new thread operations may take a long time
-        db.session.refresh(workflow)
-        db.session.refresh(message)
+        with Session(bind=db.engine, expire_on_commit=False) as session:
+            workflow = _refresh_model(session, workflow)
+            message = _refresh_model(session, message)
+        #     workflow_ = session.get(Workflow, workflow.id)
+        #     assert workflow_ is not None
+        #     workflow = workflow_
+        #     message_ = session.get(Message, message.id)
+        #     assert message_ is not None
+        #     message = message_
+        # db.session.refresh(workflow)
+        # db.session.refresh(message)
         # db.session.refresh(user)
         db.session.close()
 
@@ -490,6 +558,8 @@ class AdvancedChatAppGenerator(MessageBasedAppGenerator):
         variable_loader: VariableLoader,
         workflow_execution_repository: WorkflowExecutionRepository,
         workflow_node_execution_repository: WorkflowNodeExecutionRepository,
+        graph_engine_layers: Sequence[GraphEngineLayer] = (),
+        graph_runtime_state: GraphRuntimeState | None = None,
     ):
         """
         Generate worker in a new thread.
@@ -547,6 +617,8 @@ class AdvancedChatAppGenerator(MessageBasedAppGenerator):
                 app=app,
                 workflow_execution_repository=workflow_execution_repository,
                 workflow_node_execution_repository=workflow_node_execution_repository,
+                graph_engine_layers=graph_engine_layers,
+                graph_runtime_state=graph_runtime_state,
             )
 
             try:
@@ -614,3 +686,13 @@ class AdvancedChatAppGenerator(MessageBasedAppGenerator):
             else:
                 logger.exception("Failed to process generate task pipeline, conversation_id: %s", conversation.id)
                 raise e
+
+
+_T = TypeVar("_T", bound=Base)
+
+
+def _refresh_model(session, model: _T) -> _T:
+    with Session(bind=db.engine, expire_on_commit=False) as session:
+        detach_model = session.get(type(model), model.id)
+        assert detach_model is not None
+        return detach_model

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

@@ -66,6 +66,7 @@ class AdvancedChatAppRunner(WorkflowBasedAppRunner):
         workflow_execution_repository: WorkflowExecutionRepository,
         workflow_node_execution_repository: WorkflowNodeExecutionRepository,
         graph_engine_layers: Sequence[GraphEngineLayer] = (),
+        graph_runtime_state: GraphRuntimeState | None = None,
     ):
         super().__init__(
             queue_manager=queue_manager,
@@ -82,6 +83,7 @@ class AdvancedChatAppRunner(WorkflowBasedAppRunner):
         self._app = app
         self._workflow_execution_repository = workflow_execution_repository
         self._workflow_node_execution_repository = workflow_node_execution_repository
+        self._resume_graph_runtime_state = graph_runtime_state
 
     @trace_span(WorkflowAppRunnerHandler)
     def run(self):
@@ -110,7 +112,21 @@ class AdvancedChatAppRunner(WorkflowBasedAppRunner):
             invoke_from = InvokeFrom.DEBUGGER
         user_from = self._resolve_user_from(invoke_from)
 
-        if self.application_generate_entity.single_iteration_run or self.application_generate_entity.single_loop_run:
+        resume_state = self._resume_graph_runtime_state
+
+        if resume_state is not None:
+            graph_runtime_state = resume_state
+            variable_pool = graph_runtime_state.variable_pool
+            graph = self._init_graph(
+                graph_config=self._workflow.graph_dict,
+                graph_runtime_state=graph_runtime_state,
+                workflow_id=self._workflow.id,
+                tenant_id=self._workflow.tenant_id,
+                user_id=self.application_generate_entity.user_id,
+                invoke_from=invoke_from,
+                user_from=user_from,
+            )
+        elif self.application_generate_entity.single_iteration_run or self.application_generate_entity.single_loop_run:
             # Handle single iteration or single loop run
             graph, variable_pool, graph_runtime_state = self._prepare_single_node_execution(
                 workflow=self._workflow,

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

@@ -24,6 +24,8 @@ from core.app.entities.queue_entities import (
     QueueAgentLogEvent,
     QueueAnnotationReplyEvent,
     QueueErrorEvent,
+    QueueHumanInputFormFilledEvent,
+    QueueHumanInputFormTimeoutEvent,
     QueueIterationCompletedEvent,
     QueueIterationNextEvent,
     QueueIterationStartEvent,
@@ -42,6 +44,7 @@ from core.app.entities.queue_entities import (
     QueueTextChunkEvent,
     QueueWorkflowFailedEvent,
     QueueWorkflowPartialSuccessEvent,
+    QueueWorkflowPausedEvent,
     QueueWorkflowStartedEvent,
     QueueWorkflowSucceededEvent,
     WorkflowQueueMessage,
@@ -63,6 +66,8 @@ 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.repositories.human_input_repository import HumanInputFormRepositoryImpl
+from core.workflow.entities.pause_reason import HumanInputRequired
 from core.workflow.enums import WorkflowExecutionStatus
 from core.workflow.nodes import NodeType
 from core.workflow.repositories.draft_variable_repository import DraftVariableSaverFactory
@@ -71,7 +76,8 @@ from core.workflow.system_variable import SystemVariable
 from extensions.ext_database import db
 from libs.datetime_utils import naive_utc_now
 from models import Account, Conversation, EndUser, Message, MessageFile
-from models.enums import CreatorUserRole
+from models.enums import CreatorUserRole, MessageStatus
+from models.execution_extra_content import HumanInputContent
 from models.workflow import Workflow
 
 logger = logging.getLogger(__name__)
@@ -128,6 +134,7 @@ class AdvancedChatAppGenerateTaskPipeline(GraphRuntimeStateSupport):
         )
 
         self._task_state = WorkflowTaskState()
+        self._seed_task_state_from_message(message)
         self._message_cycle_manager = MessageCycleManager(
             application_generate_entity=application_generate_entity, task_state=self._task_state
         )
@@ -135,6 +142,7 @@ class AdvancedChatAppGenerateTaskPipeline(GraphRuntimeStateSupport):
         self._application_generate_entity = application_generate_entity
         self._workflow_id = workflow.id
         self._workflow_features_dict = workflow.features_dict
+        self._workflow_tenant_id = workflow.tenant_id
         self._conversation_id = conversation.id
         self._conversation_mode = conversation.mode
         self._message_id = message.id
@@ -144,8 +152,13 @@ class AdvancedChatAppGenerateTaskPipeline(GraphRuntimeStateSupport):
         self._workflow_run_id: str = ""
         self._draft_var_saver_factory = draft_var_saver_factory
         self._graph_runtime_state: GraphRuntimeState | None = None
+        self._message_saved_on_pause = False
         self._seed_graph_runtime_state_from_queue_manager()
 
+    def _seed_task_state_from_message(self, message: Message) -> None:
+        if message.status == MessageStatus.PAUSED and message.answer:
+            self._task_state.answer = message.answer
+
     def process(self) -> Union[ChatbotAppBlockingResponse, Generator[ChatbotAppStreamResponse, None, None]]:
         """
         Process generate task pipeline.
@@ -308,6 +321,7 @@ class AdvancedChatAppGenerateTaskPipeline(GraphRuntimeStateSupport):
             task_id=self._application_generate_entity.task_id,
             workflow_run_id=run_id,
             workflow_id=self._workflow_id,
+            reason=event.reason,
         )
 
         yield workflow_start_resp
@@ -525,6 +539,35 @@ class AdvancedChatAppGenerateTaskPipeline(GraphRuntimeStateSupport):
         )
 
         yield workflow_finish_resp
+
+    def _handle_workflow_paused_event(
+        self,
+        event: QueueWorkflowPausedEvent,
+        **kwargs,
+    ) -> Generator[StreamResponse, None, None]:
+        """Handle workflow paused events."""
+        validated_state = self._ensure_graph_runtime_initialized()
+        responses = self._workflow_response_converter.workflow_pause_to_stream_response(
+            event=event,
+            task_id=self._application_generate_entity.task_id,
+            graph_runtime_state=validated_state,
+        )
+        for reason in event.reasons:
+            if isinstance(reason, HumanInputRequired):
+                self._persist_human_input_extra_content(form_id=reason.form_id, node_id=reason.node_id)
+        yield from responses
+        resolved_state: GraphRuntimeState | None = None
+        try:
+            resolved_state = self._ensure_graph_runtime_initialized()
+        except ValueError:
+            resolved_state = None
+
+        with self._database_session() as session:
+            self._save_message(session=session, graph_runtime_state=resolved_state)
+            message = self._get_message(session=session)
+            if message is not None:
+                message.status = MessageStatus.PAUSED
+            self._message_saved_on_pause = True
         self._base_task_pipeline.queue_manager.publish(QueueAdvancedChatMessageEndEvent(), PublishFrom.TASK_PIPELINE)
 
     def _handle_workflow_failed_event(
@@ -614,9 +657,10 @@ class AdvancedChatAppGenerateTaskPipeline(GraphRuntimeStateSupport):
                 reason=QueueMessageReplaceEvent.MessageReplaceReason.OUTPUT_MODERATION,
             )
 
-        # Save message
-        with self._database_session() as session:
-            self._save_message(session=session, graph_runtime_state=resolved_state)
+        # Save message unless it has already been persisted on pause.
+        if not self._message_saved_on_pause:
+            with self._database_session() as session:
+                self._save_message(session=session, graph_runtime_state=resolved_state)
 
         yield self._message_end_to_stream_response()
 
@@ -642,6 +686,65 @@ class AdvancedChatAppGenerateTaskPipeline(GraphRuntimeStateSupport):
         """Handle message replace events."""
         yield self._message_cycle_manager.message_replace_to_stream_response(answer=event.text, reason=event.reason)
 
+    def _handle_human_input_form_filled_event(
+        self, event: QueueHumanInputFormFilledEvent, **kwargs
+    ) -> Generator[StreamResponse, None, None]:
+        """Handle human input form filled events."""
+        self._persist_human_input_extra_content(node_id=event.node_id)
+        yield self._workflow_response_converter.human_input_form_filled_to_stream_response(
+            event=event, task_id=self._application_generate_entity.task_id
+        )
+
+    def _handle_human_input_form_timeout_event(
+        self, event: QueueHumanInputFormTimeoutEvent, **kwargs
+    ) -> Generator[StreamResponse, None, None]:
+        """Handle human input form timeout events."""
+        yield self._workflow_response_converter.human_input_form_timeout_to_stream_response(
+            event=event, task_id=self._application_generate_entity.task_id
+        )
+
+    def _persist_human_input_extra_content(self, *, node_id: str | None = None, form_id: str | None = None) -> None:
+        if not self._workflow_run_id or not self._message_id:
+            return
+
+        if form_id is None:
+            if node_id is None:
+                return
+            form_id = self._load_human_input_form_id(node_id=node_id)
+            if form_id is None:
+                logger.warning(
+                    "HumanInput form not found for workflow run %s node %s",
+                    self._workflow_run_id,
+                    node_id,
+                )
+                return
+
+        with self._database_session() as session:
+            exists_stmt = select(HumanInputContent).where(
+                HumanInputContent.workflow_run_id == self._workflow_run_id,
+                HumanInputContent.message_id == self._message_id,
+                HumanInputContent.form_id == form_id,
+            )
+            if session.scalar(exists_stmt) is not None:
+                return
+
+            content = HumanInputContent(
+                workflow_run_id=self._workflow_run_id,
+                message_id=self._message_id,
+                form_id=form_id,
+            )
+            session.add(content)
+
+    def _load_human_input_form_id(self, *, node_id: str) -> str | None:
+        form_repository = HumanInputFormRepositoryImpl(
+            session_factory=db.engine,
+            tenant_id=self._workflow_tenant_id,
+        )
+        form = form_repository.get_form(self._workflow_run_id, node_id)
+        if form is None:
+            return None
+        return form.id
+
     def _handle_agent_log_event(self, event: QueueAgentLogEvent, **kwargs) -> Generator[StreamResponse, None, None]:
         """Handle agent log events."""
         yield self._workflow_response_converter.handle_agent_log(
@@ -659,6 +762,7 @@ class AdvancedChatAppGenerateTaskPipeline(GraphRuntimeStateSupport):
             QueueWorkflowStartedEvent: self._handle_workflow_started_event,
             QueueWorkflowSucceededEvent: self._handle_workflow_succeeded_event,
             QueueWorkflowPartialSuccessEvent: self._handle_workflow_partial_success_event,
+            QueueWorkflowPausedEvent: self._handle_workflow_paused_event,
             QueueWorkflowFailedEvent: self._handle_workflow_failed_event,
             # Node events
             QueueNodeRetryEvent: self._handle_node_retry_event,
@@ -680,6 +784,8 @@ class AdvancedChatAppGenerateTaskPipeline(GraphRuntimeStateSupport):
             QueueMessageReplaceEvent: self._handle_message_replace_event,
             QueueAdvancedChatMessageEndEvent: self._handle_advanced_chat_message_end_event,
             QueueAgentLogEvent: self._handle_agent_log_event,
+            QueueHumanInputFormFilledEvent: self._handle_human_input_form_filled_event,
+            QueueHumanInputFormTimeoutEvent: self._handle_human_input_form_timeout_event,
         }
 
     def _dispatch_event(
@@ -747,6 +853,9 @@ class AdvancedChatAppGenerateTaskPipeline(GraphRuntimeStateSupport):
                 case QueueWorkflowFailedEvent():
                     yield from self._handle_workflow_failed_event(event, trace_manager=trace_manager)
                     break
+                case QueueWorkflowPausedEvent():
+                    yield from self._handle_workflow_paused_event(event)
+                    break
 
                 case QueueStopEvent():
                     yield from self._handle_stop_event(event, graph_runtime_state=None, trace_manager=trace_manager)
@@ -772,6 +881,11 @@ class AdvancedChatAppGenerateTaskPipeline(GraphRuntimeStateSupport):
 
     def _save_message(self, *, session: Session, graph_runtime_state: GraphRuntimeState | None = None):
         message = self._get_message(session=session)
+        if message is None:
+            return
+
+        if message.status == MessageStatus.PAUSED:
+            message.status = MessageStatus.NORMAL
 
         # If there are assistant files, remove markdown image links from answer
         answer_text = self._task_state.answer

api/core/app/apps/common/workflow_response_converter.py

@@ -5,9 +5,14 @@ from dataclasses import dataclass
 from datetime import datetime
 from typing import Any, NewType, Union
 
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
 from core.app.entities.app_invoke_entities import AdvancedChatAppGenerateEntity, InvokeFrom, WorkflowAppGenerateEntity
 from core.app.entities.queue_entities import (
     QueueAgentLogEvent,
+    QueueHumanInputFormFilledEvent,
+    QueueHumanInputFormTimeoutEvent,
     QueueIterationCompletedEvent,
     QueueIterationNextEvent,
     QueueIterationStartEvent,
@@ -19,9 +24,13 @@ from core.app.entities.queue_entities import (
     QueueNodeRetryEvent,
     QueueNodeStartedEvent,
     QueueNodeSucceededEvent,
+    QueueWorkflowPausedEvent,
 )
 from core.app.entities.task_entities import (
     AgentLogStreamResponse,
+    HumanInputFormFilledResponse,
+    HumanInputFormTimeoutResponse,
+    HumanInputRequiredResponse,
     IterationNodeCompletedStreamResponse,
     IterationNodeNextStreamResponse,
     IterationNodeStartStreamResponse,
@@ -31,7 +40,9 @@ from core.app.entities.task_entities import (
     NodeFinishStreamResponse,
     NodeRetryStreamResponse,
     NodeStartStreamResponse,
+    StreamResponse,
     WorkflowFinishStreamResponse,
+    WorkflowPauseStreamResponse,
     WorkflowStartStreamResponse,
 )
 from core.file import FILE_MODEL_IDENTITY, File
@@ -40,6 +51,8 @@ from core.tools.entities.tool_entities import ToolProviderType
 from core.tools.tool_manager import ToolManager
 from core.trigger.trigger_manager import TriggerManager
 from core.variables.segments import ArrayFileSegment, FileSegment, Segment
+from core.workflow.entities.pause_reason import HumanInputRequired
+from core.workflow.entities.workflow_start_reason import WorkflowStartReason
 from core.workflow.enums import (
     NodeType,
     SystemVariableKey,
@@ -51,8 +64,11 @@ from core.workflow.runtime import GraphRuntimeState
 from core.workflow.system_variable import SystemVariable
 from core.workflow.workflow_entry import WorkflowEntry
 from core.workflow.workflow_type_encoder import WorkflowRuntimeTypeConverter
+from extensions.ext_database import db
 from libs.datetime_utils import naive_utc_now
 from models import Account, EndUser
+from models.human_input import HumanInputForm
+from models.workflow import WorkflowRun
 from services.variable_truncator import BaseTruncator, DummyVariableTruncator, VariableTruncator
 
 NodeExecutionId = NewType("NodeExecutionId", str)
@@ -191,6 +207,7 @@ class WorkflowResponseConverter:
         task_id: str,
         workflow_run_id: str,
         workflow_id: str,
+        reason: WorkflowStartReason,
     ) -> WorkflowStartStreamResponse:
         run_id = self._ensure_workflow_run_id(workflow_run_id)
         started_at = naive_utc_now()
@@ -204,6 +221,7 @@ class WorkflowResponseConverter:
                 workflow_id=workflow_id,
                 inputs=self._workflow_inputs,
                 created_at=int(started_at.timestamp()),
+                reason=reason,
             ),
         )
 
@@ -264,6 +282,160 @@ class WorkflowResponseConverter:
             ),
         )
 
+    def workflow_pause_to_stream_response(
+        self,
+        *,
+        event: QueueWorkflowPausedEvent,
+        task_id: str,
+        graph_runtime_state: GraphRuntimeState,
+    ) -> list[StreamResponse]:
+        run_id = self._ensure_workflow_run_id()
+        started_at = self._workflow_started_at
+        if started_at is None:
+            raise ValueError(
+                "workflow_pause_to_stream_response called before workflow_start_to_stream_response",
+            )
+        paused_at = naive_utc_now()
+        elapsed_time = (paused_at - started_at).total_seconds()
+        encoded_outputs = self._encode_outputs(event.outputs) or {}
+        if self._application_generate_entity.invoke_from == InvokeFrom.SERVICE_API:
+            encoded_outputs = {}
+        pause_reasons = [reason.model_dump(mode="json") for reason in event.reasons]
+        human_input_form_ids = [reason.form_id for reason in event.reasons if isinstance(reason, HumanInputRequired)]
+        expiration_times_by_form_id: dict[str, datetime] = {}
+        if human_input_form_ids:
+            stmt = select(HumanInputForm.id, HumanInputForm.expiration_time).where(
+                HumanInputForm.id.in_(human_input_form_ids)
+            )
+            with Session(bind=db.engine) as session:
+                for form_id, expiration_time in session.execute(stmt):
+                    expiration_times_by_form_id[str(form_id)] = expiration_time
+
+        responses: list[StreamResponse] = []
+
+        for reason in event.reasons:
+            if isinstance(reason, HumanInputRequired):
+                expiration_time = expiration_times_by_form_id.get(reason.form_id)
+                if expiration_time is None:
+                    raise ValueError(f"HumanInputForm not found for pause reason, form_id={reason.form_id}")
+                responses.append(
+                    HumanInputRequiredResponse(
+                        task_id=task_id,
+                        workflow_run_id=run_id,
+                        data=HumanInputRequiredResponse.Data(
+                            form_id=reason.form_id,
+                            node_id=reason.node_id,
+                            node_title=reason.node_title,
+                            form_content=reason.form_content,
+                            inputs=reason.inputs,
+                            actions=reason.actions,
+                            display_in_ui=reason.display_in_ui,
+                            form_token=reason.form_token,
+                            resolved_default_values=reason.resolved_default_values,
+                            expiration_time=int(expiration_time.timestamp()),
+                        ),
+                    )
+                )
+
+        responses.append(
+            WorkflowPauseStreamResponse(
+                task_id=task_id,
+                workflow_run_id=run_id,
+                data=WorkflowPauseStreamResponse.Data(
+                    workflow_run_id=run_id,
+                    paused_nodes=list(event.paused_nodes),
+                    outputs=encoded_outputs,
+                    reasons=pause_reasons,
+                    status=WorkflowExecutionStatus.PAUSED,
+                    created_at=int(started_at.timestamp()),
+                    elapsed_time=elapsed_time,
+                    total_tokens=graph_runtime_state.total_tokens,
+                    total_steps=graph_runtime_state.node_run_steps,
+                ),
+            )
+        )
+
+        return responses
+
+    def human_input_form_filled_to_stream_response(
+        self, *, event: QueueHumanInputFormFilledEvent, task_id: str
+    ) -> HumanInputFormFilledResponse:
+        run_id = self._ensure_workflow_run_id()
+        return HumanInputFormFilledResponse(
+            task_id=task_id,
+            workflow_run_id=run_id,
+            data=HumanInputFormFilledResponse.Data(
+                node_id=event.node_id,
+                node_title=event.node_title,
+                rendered_content=event.rendered_content,
+                action_id=event.action_id,
+                action_text=event.action_text,
+            ),
+        )
+
+    def human_input_form_timeout_to_stream_response(
+        self, *, event: QueueHumanInputFormTimeoutEvent, task_id: str
+    ) -> HumanInputFormTimeoutResponse:
+        run_id = self._ensure_workflow_run_id()
+        return HumanInputFormTimeoutResponse(
+            task_id=task_id,
+            workflow_run_id=run_id,
+            data=HumanInputFormTimeoutResponse.Data(
+                node_id=event.node_id,
+                node_title=event.node_title,
+                expiration_time=int(event.expiration_time.timestamp()),
+            ),
+        )
+
+    @classmethod
+    def workflow_run_result_to_finish_response(
+        cls,
+        *,
+        task_id: str,
+        workflow_run: WorkflowRun,
+        creator_user: Account | EndUser,
+    ) -> WorkflowFinishStreamResponse:
+        run_id = workflow_run.id
+        elapsed_time = workflow_run.elapsed_time
+
+        encoded_outputs = workflow_run.outputs_dict
+        finished_at = workflow_run.finished_at
+        assert finished_at is not None
+
+        created_by: Mapping[str, object]
+        user = creator_user
+        if isinstance(user, Account):
+            created_by = {
+                "id": user.id,
+                "name": user.name,
+                "email": user.email,
+            }
+        else:
+            created_by = {
+                "id": user.id,
+                "user": user.session_id,
+            }
+
+        return WorkflowFinishStreamResponse(
+            task_id=task_id,
+            workflow_run_id=run_id,
+            data=WorkflowFinishStreamResponse.Data(
+                id=run_id,
+                workflow_id=workflow_run.workflow_id,
+                status=workflow_run.status,
+                outputs=encoded_outputs,
+                error=workflow_run.error,
+                elapsed_time=elapsed_time,
+                total_tokens=workflow_run.total_tokens,
+                total_steps=workflow_run.total_steps,
+                created_by=created_by,
+                created_at=int(workflow_run.created_at.timestamp()),
+                finished_at=int(finished_at.timestamp()),
+                files=cls.fetch_files_from_node_outputs(encoded_outputs),
+                exceptions_count=workflow_run.exceptions_count,
+            ),
+        )
+
     def workflow_node_start_to_stream_response(
         self,
         *,
@@ -592,7 +764,8 @@ class WorkflowResponseConverter:
             ),
         )
 
-    def fetch_files_from_node_outputs(self, outputs_dict: Mapping[str, Any] | None) -> Sequence[Mapping[str, Any]]:
+    @classmethod
+    def fetch_files_from_node_outputs(cls, outputs_dict: Mapping[str, Any] | None) -> Sequence[Mapping[str, Any]]:
         """
         Fetch files from node outputs
         :param outputs_dict: node outputs dict
@@ -601,7 +774,7 @@ class WorkflowResponseConverter:
         if not outputs_dict:
             return []
 
-        files = [self._fetch_files_from_variable_value(output_value) for output_value in outputs_dict.values()]
+        files = [cls._fetch_files_from_variable_value(output_value) for output_value in outputs_dict.values()]
         # Remove None
         files = [file for file in files if file]
         # Flatten list

api/core/app/apps/message_based_app_generator.py

@@ -1,6 +1,6 @@
 import json
 import logging
-from collections.abc import Generator
+from collections.abc import Callable, Generator, Mapping
 from typing import Union, cast
 
 from sqlalchemy import select
@@ -10,12 +10,14 @@ from core.app.app_config.entities import EasyUIBasedAppConfig, EasyUIBasedAppMod
 from core.app.apps.base_app_generator import BaseAppGenerator
 from core.app.apps.base_app_queue_manager import AppQueueManager
 from core.app.apps.exc import GenerateTaskStoppedError
+from core.app.apps.streaming_utils import stream_topic_events
 from core.app.entities.app_invoke_entities import (
     AdvancedChatAppGenerateEntity,
     AgentChatAppGenerateEntity,
     AppGenerateEntity,
     ChatAppGenerateEntity,
     CompletionAppGenerateEntity,
+    ConversationAppGenerateEntity,
     InvokeFrom,
 )
 from core.app.entities.task_entities import (
@@ -27,6 +29,8 @@ from core.app.entities.task_entities import (
 from core.app.task_pipeline.easy_ui_based_generate_task_pipeline import EasyUIBasedGenerateTaskPipeline
 from core.prompt.utils.prompt_template_parser import PromptTemplateParser
 from extensions.ext_database import db
+from extensions.ext_redis import get_pubsub_broadcast_channel
+from libs.broadcast_channel.channel import Topic
 from libs.datetime_utils import naive_utc_now
 from models import Account
 from models.enums import CreatorUserRole
@@ -156,6 +160,7 @@ class MessageBasedAppGenerator(BaseAppGenerator):
         query = application_generate_entity.query or "New conversation"
         conversation_name = (query[:20] + "…") if len(query) > 20 else query
 
+        created_new_conversation = conversation is None
         try:
             if not conversation:
                 conversation = Conversation(
@@ -232,6 +237,10 @@ class MessageBasedAppGenerator(BaseAppGenerator):
                 db.session.add_all(message_files)
 
             db.session.commit()
+
+            if isinstance(application_generate_entity, ConversationAppGenerateEntity):
+                application_generate_entity.conversation_id = conversation.id
+                application_generate_entity.is_new_conversation = created_new_conversation
             return conversation, message
         except Exception:
             db.session.rollback()
@@ -284,3 +293,29 @@ class MessageBasedAppGenerator(BaseAppGenerator):
             raise MessageNotExistsError("Message not exists")
 
         return message
+
+    @staticmethod
+    def _make_channel_key(app_mode: AppMode, workflow_run_id: str):
+        return f"channel:{app_mode}:{workflow_run_id}"
+
+    @classmethod
+    def get_response_topic(cls, app_mode: AppMode, workflow_run_id: str) -> Topic:
+        key = cls._make_channel_key(app_mode, workflow_run_id)
+        channel = get_pubsub_broadcast_channel()
+        topic = channel.topic(key)
+        return topic
+
+    @classmethod
+    def retrieve_events(
+        cls,
+        app_mode: AppMode,
+        workflow_run_id: str,
+        idle_timeout=300,
+        on_subscribe: Callable[[], None] | None = None,
+    ) -> Generator[Mapping | str, None, None]:
+        topic = cls.get_response_topic(app_mode, workflow_run_id)
+        return stream_topic_events(
+            topic=topic,
+            idle_timeout=idle_timeout,
+            on_subscribe=on_subscribe,
+        )

api/core/app/apps/message_generator.py

@@ -0,0 +1,36 @@
+from collections.abc import Callable, Generator, Mapping
+
+from core.app.apps.streaming_utils import stream_topic_events
+from extensions.ext_redis import get_pubsub_broadcast_channel
+from libs.broadcast_channel.channel import Topic
+from models.model import AppMode
+
+
+class MessageGenerator:
+    @staticmethod
+    def _make_channel_key(app_mode: AppMode, workflow_run_id: str):
+        return f"channel:{app_mode}:{str(workflow_run_id)}"
+
+    @classmethod
+    def get_response_topic(cls, app_mode: AppMode, workflow_run_id: str) -> Topic:
+        key = cls._make_channel_key(app_mode, workflow_run_id)
+        channel = get_pubsub_broadcast_channel()
+        topic = channel.topic(key)
+        return topic
+
+    @classmethod
+    def retrieve_events(
+        cls,
+        app_mode: AppMode,
+        workflow_run_id: str,
+        idle_timeout=300,
+        ping_interval: float = 10.0,
+        on_subscribe: Callable[[], None] | None = None,
+    ) -> Generator[Mapping | str, None, None]:
+        topic = cls.get_response_topic(app_mode, workflow_run_id)
+        return stream_topic_events(
+            topic=topic,
+            idle_timeout=idle_timeout,
+            ping_interval=ping_interval,
+            on_subscribe=on_subscribe,
+        )

api/core/app/apps/streaming_utils.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+import json
+import time
+from collections.abc import Callable, Generator, Iterable, Mapping
+from typing import Any
+
+from core.app.entities.task_entities import StreamEvent
+from libs.broadcast_channel.channel import Topic
+from libs.broadcast_channel.exc import SubscriptionClosedError
+
+
+def stream_topic_events(
+    *,
+    topic: Topic,
+    idle_timeout: float,
+    ping_interval: float | None = None,
+    on_subscribe: Callable[[], None] | None = None,
+    terminal_events: Iterable[str | StreamEvent] | None = None,
+) -> Generator[Mapping[str, Any] | str, None, None]:
+    # send a PING event immediately to prevent the connection staying in pending state for a long time.
+    #
+    # This simplify the debugging process as the DevTools in Chrome does not
+    # provide complete curl command for pending connections.
+    yield StreamEvent.PING.value
+
+    terminal_values = _normalize_terminal_events(terminal_events)
+    last_msg_time = time.time()
+    last_ping_time = last_msg_time
+    with topic.subscribe() as sub:
+        # on_subscribe fires only after the Redis subscription is active.
+        # This is used to gate task start and reduce pub/sub race for the first event.
+        if on_subscribe is not None:
+            on_subscribe()
+        while True:
+            try:
+                msg = sub.receive(timeout=0.1)
+            except SubscriptionClosedError:
+                return
+            if msg is None:
+                current_time = time.time()
+                if current_time - last_msg_time > idle_timeout:
+                    return
+                if ping_interval is not None and current_time - last_ping_time >= ping_interval:
+                    yield StreamEvent.PING.value
+                    last_ping_time = current_time
+                continue
+
+            last_msg_time = time.time()
+            last_ping_time = last_msg_time
+            event = json.loads(msg)
+            yield event
+            if not isinstance(event, dict):
+                continue
+
+            event_type = event.get("event")
+            if event_type in terminal_values:
+                return
+
+
+def _normalize_terminal_events(terminal_events: Iterable[str | StreamEvent] | None) -> set[str]:
+    if not terminal_events:
+        return {StreamEvent.WORKFLOW_FINISHED.value, StreamEvent.WORKFLOW_PAUSED.value}
+    values: set[str] = set()
+    for item in terminal_events:
+        if isinstance(item, StreamEvent):
+            values.add(item.value)
+        else:
+            values.add(str(item))
+    return values

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

@@ -25,6 +25,7 @@ from core.app.apps.workflow.generate_response_converter import WorkflowAppGenera
 from core.app.apps.workflow.generate_task_pipeline import WorkflowAppGenerateTaskPipeline
 from core.app.entities.app_invoke_entities import InvokeFrom, WorkflowAppGenerateEntity
 from core.app.entities.task_entities import WorkflowAppBlockingResponse, WorkflowAppStreamResponse
+from core.app.layers.pause_state_persist_layer import PauseStateLayerConfig, PauseStatePersistenceLayer
 from core.db.session_factory import session_factory
 from core.helper.trace_id_helper import extract_external_trace_id_from_args
 from core.model_runtime.errors.invoke import InvokeAuthorizationError
@@ -34,12 +35,15 @@ from core.workflow.graph_engine.layers.base import GraphEngineLayer
 from core.workflow.repositories.draft_variable_repository import DraftVariableSaverFactory
 from core.workflow.repositories.workflow_execution_repository import WorkflowExecutionRepository
 from core.workflow.repositories.workflow_node_execution_repository import WorkflowNodeExecutionRepository
+from core.workflow.runtime import GraphRuntimeState
 from core.workflow.variable_loader import DUMMY_VARIABLE_LOADER, VariableLoader
 from extensions.ext_database import db
 from factories import file_factory
 from libs.flask_utils import preserve_flask_contexts
-from models import Account, App, EndUser, Workflow, WorkflowNodeExecutionTriggeredFrom
+from models.account import Account
 from models.enums import WorkflowRunTriggeredFrom
+from models.model import App, EndUser
+from models.workflow import Workflow, WorkflowNodeExecutionTriggeredFrom
 from services.workflow_draft_variable_service import DraftVarLoader, WorkflowDraftVariableService
 
 if TYPE_CHECKING:
@@ -66,9 +70,11 @@ class WorkflowAppGenerator(BaseAppGenerator):
         invoke_from: InvokeFrom,
         streaming: Literal[True],
         call_depth: int,
+        workflow_run_id: str | uuid.UUID | None = None,
         triggered_from: WorkflowRunTriggeredFrom | None = None,
         root_node_id: str | None = None,
         graph_engine_layers: Sequence[GraphEngineLayer] = (),
+        pause_state_config: PauseStateLayerConfig | None = None,
     ) -> Generator[Mapping[str, Any] | str, None, None]: ...
 
     @overload
@@ -82,9 +88,11 @@ class WorkflowAppGenerator(BaseAppGenerator):
         invoke_from: InvokeFrom,
         streaming: Literal[False],
         call_depth: int,
+        workflow_run_id: str | uuid.UUID | None = None,
         triggered_from: WorkflowRunTriggeredFrom | None = None,
         root_node_id: str | None = None,
         graph_engine_layers: Sequence[GraphEngineLayer] = (),
+        pause_state_config: PauseStateLayerConfig | None = None,
     ) -> Mapping[str, Any]: ...
 
     @overload
@@ -98,9 +106,11 @@ class WorkflowAppGenerator(BaseAppGenerator):
         invoke_from: InvokeFrom,
         streaming: bool,
         call_depth: int,
+        workflow_run_id: str | uuid.UUID | None = None,
         triggered_from: WorkflowRunTriggeredFrom | None = None,
         root_node_id: str | None = None,
         graph_engine_layers: Sequence[GraphEngineLayer] = (),
+        pause_state_config: PauseStateLayerConfig | None = None,
     ) -> Union[Mapping[str, Any], Generator[Mapping[str, Any] | str, None, None]]: ...
 
     def generate(
@@ -113,9 +123,11 @@ class WorkflowAppGenerator(BaseAppGenerator):
         invoke_from: InvokeFrom,
         streaming: bool = True,
         call_depth: int = 0,
+        workflow_run_id: str | uuid.UUID | None = None,
         triggered_from: WorkflowRunTriggeredFrom | None = None,
         root_node_id: str | None = None,
         graph_engine_layers: Sequence[GraphEngineLayer] = (),
+        pause_state_config: PauseStateLayerConfig | None = None,
     ) -> Union[Mapping[str, Any], Generator[Mapping[str, Any] | str, None, None]]:
         files: Sequence[Mapping[str, Any]] = args.get("files") or []
 
@@ -150,7 +162,7 @@ class WorkflowAppGenerator(BaseAppGenerator):
         extras = {
             **extract_external_trace_id_from_args(args),
         }
-        workflow_run_id = str(uuid.uuid4())
+        workflow_run_id = str(workflow_run_id or uuid.uuid4())
         # FIXME (Yeuoly): we need to remove the SKIP_PREPARE_USER_INPUTS_KEY from the args
         # trigger shouldn't prepare user inputs
         if self._should_prepare_user_inputs(args):
@@ -216,13 +228,40 @@ class WorkflowAppGenerator(BaseAppGenerator):
             streaming=streaming,
             root_node_id=root_node_id,
             graph_engine_layers=graph_engine_layers,
+            pause_state_config=pause_state_config,
         )
 
-    def resume(self, *, workflow_run_id: str) -> None:
+    def resume(
+        self,
+        *,
+        app_model: App,
+        workflow: Workflow,
+        user: Union[Account, EndUser],
+        application_generate_entity: WorkflowAppGenerateEntity,
+        graph_runtime_state: GraphRuntimeState,
+        workflow_execution_repository: WorkflowExecutionRepository,
+        workflow_node_execution_repository: WorkflowNodeExecutionRepository,
+        graph_engine_layers: Sequence[GraphEngineLayer] = (),
+        pause_state_config: PauseStateLayerConfig | None = None,
+        variable_loader: VariableLoader = DUMMY_VARIABLE_LOADER,
+    ) -> Union[Mapping[str, Any], Generator[str | Mapping[str, Any], None, None]]:
         """
-        @TBD
+        Resume a paused workflow execution using the persisted runtime state.
         """
-        pass
+        return self._generate(
+            app_model=app_model,
+            workflow=workflow,
+            user=user,
+            application_generate_entity=application_generate_entity,
+            invoke_from=application_generate_entity.invoke_from,
+            workflow_execution_repository=workflow_execution_repository,
+            workflow_node_execution_repository=workflow_node_execution_repository,
+            streaming=application_generate_entity.stream,
+            variable_loader=variable_loader,
+            graph_engine_layers=graph_engine_layers,
+            graph_runtime_state=graph_runtime_state,
+            pause_state_config=pause_state_config,
+        )
 
     def _generate(
         self,
@@ -238,6 +277,8 @@ class WorkflowAppGenerator(BaseAppGenerator):
         variable_loader: VariableLoader = DUMMY_VARIABLE_LOADER,
         root_node_id: str | None = None,
         graph_engine_layers: Sequence[GraphEngineLayer] = (),
+        graph_runtime_state: GraphRuntimeState | None = None,
+        pause_state_config: PauseStateLayerConfig | None = None,
     ) -> Union[Mapping[str, Any], Generator[str | Mapping[str, Any], None, None]]:
         """
         Generate App response.
@@ -251,6 +292,8 @@ class WorkflowAppGenerator(BaseAppGenerator):
         :param workflow_node_execution_repository: repository for workflow node execution
         :param streaming: is stream
         """
+        graph_layers: list[GraphEngineLayer] = list(graph_engine_layers)
+
         # init queue manager
         queue_manager = WorkflowAppQueueManager(
             task_id=application_generate_entity.task_id,
@@ -259,6 +302,15 @@ class WorkflowAppGenerator(BaseAppGenerator):
             app_mode=app_model.mode,
         )
 
+        if pause_state_config is not None:
+            graph_layers.append(
+                PauseStatePersistenceLayer(
+                    session_factory=pause_state_config.session_factory,
+                    generate_entity=application_generate_entity,
+                    state_owner_user_id=pause_state_config.state_owner_user_id,
+                )
+            )
+
         # new thread with request context and contextvars
         context = contextvars.copy_context()
 
@@ -276,7 +328,8 @@ class WorkflowAppGenerator(BaseAppGenerator):
                 "root_node_id": root_node_id,
                 "workflow_execution_repository": workflow_execution_repository,
                 "workflow_node_execution_repository": workflow_node_execution_repository,
-                "graph_engine_layers": graph_engine_layers,
+                "graph_engine_layers": tuple(graph_layers),
+                "graph_runtime_state": graph_runtime_state,
             },
         )
 
@@ -378,6 +431,7 @@ class WorkflowAppGenerator(BaseAppGenerator):
             workflow_node_execution_repository=workflow_node_execution_repository,
             streaming=streaming,
             variable_loader=var_loader,
+            pause_state_config=None,
         )
 
     def single_loop_generate(
@@ -459,6 +513,7 @@ class WorkflowAppGenerator(BaseAppGenerator):
             workflow_node_execution_repository=workflow_node_execution_repository,
             streaming=streaming,
             variable_loader=var_loader,
+            pause_state_config=None,
         )
 
     def _generate_worker(
@@ -472,6 +527,7 @@ class WorkflowAppGenerator(BaseAppGenerator):
         workflow_node_execution_repository: WorkflowNodeExecutionRepository,
         root_node_id: str | None = None,
         graph_engine_layers: Sequence[GraphEngineLayer] = (),
+        graph_runtime_state: GraphRuntimeState | None = None,
     ) -> None:
         """
         Generate worker in a new thread.
@@ -517,6 +573,7 @@ class WorkflowAppGenerator(BaseAppGenerator):
                 workflow_node_execution_repository=workflow_node_execution_repository,
                 root_node_id=root_node_id,
                 graph_engine_layers=graph_engine_layers,
+                graph_runtime_state=graph_runtime_state,
             )
 
             try:

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

@@ -42,6 +42,7 @@ class WorkflowAppRunner(WorkflowBasedAppRunner):
         workflow_execution_repository: WorkflowExecutionRepository,
         workflow_node_execution_repository: WorkflowNodeExecutionRepository,
         graph_engine_layers: Sequence[GraphEngineLayer] = (),
+        graph_runtime_state: GraphRuntimeState | None = None,
     ):
         super().__init__(
             queue_manager=queue_manager,
@@ -55,6 +56,7 @@ class WorkflowAppRunner(WorkflowBasedAppRunner):
         self._root_node_id = root_node_id
         self._workflow_execution_repository = workflow_execution_repository
         self._workflow_node_execution_repository = workflow_node_execution_repository
+        self._resume_graph_runtime_state = graph_runtime_state
 
     @trace_span(WorkflowAppRunnerHandler)
     def run(self):
@@ -63,23 +65,28 @@ class WorkflowAppRunner(WorkflowBasedAppRunner):
         """
         app_config = self.application_generate_entity.app_config
         app_config = cast(WorkflowAppConfig, app_config)
-
-        system_inputs = SystemVariable(
-            files=self.application_generate_entity.files,
-            user_id=self._sys_user_id,
-            app_id=app_config.app_id,
-            timestamp=int(naive_utc_now().timestamp()),
-            workflow_id=app_config.workflow_id,
-            workflow_execution_id=self.application_generate_entity.workflow_execution_id,
-        )
-
         invoke_from = self.application_generate_entity.invoke_from
         # if only single iteration or single loop run is requested
         if self.application_generate_entity.single_iteration_run or self.application_generate_entity.single_loop_run:
             invoke_from = InvokeFrom.DEBUGGER
         user_from = self._resolve_user_from(invoke_from)
 
-        if self.application_generate_entity.single_iteration_run or self.application_generate_entity.single_loop_run:
+        resume_state = self._resume_graph_runtime_state
+
+        if resume_state is not None:
+            graph_runtime_state = resume_state
+            variable_pool = graph_runtime_state.variable_pool
+            graph = self._init_graph(
+                graph_config=self._workflow.graph_dict,
+                graph_runtime_state=graph_runtime_state,
+                workflow_id=self._workflow.id,
+                tenant_id=self._workflow.tenant_id,
+                user_id=self.application_generate_entity.user_id,
+                user_from=user_from,
+                invoke_from=invoke_from,
+                root_node_id=self._root_node_id,
+            )
+        elif self.application_generate_entity.single_iteration_run or self.application_generate_entity.single_loop_run:
             graph, variable_pool, graph_runtime_state = self._prepare_single_node_execution(
                 workflow=self._workflow,
                 single_iteration_run=self.application_generate_entity.single_iteration_run,
@@ -89,7 +96,14 @@ class WorkflowAppRunner(WorkflowBasedAppRunner):
             inputs = self.application_generate_entity.inputs
 
             # Create a variable pool.
-
+            system_inputs = SystemVariable(
+                files=self.application_generate_entity.files,
+                user_id=self._sys_user_id,
+                app_id=app_config.app_id,
+                timestamp=int(naive_utc_now().timestamp()),
+                workflow_id=app_config.workflow_id,
+                workflow_execution_id=self.application_generate_entity.workflow_execution_id,
+            )
             variable_pool = VariablePool(
                 system_variables=system_inputs,
                 user_inputs=inputs,
@@ -98,8 +112,6 @@ class WorkflowAppRunner(WorkflowBasedAppRunner):
             )
 
             graph_runtime_state = GraphRuntimeState(variable_pool=variable_pool, start_at=time.perf_counter())
-
-            # init graph
             graph = self._init_graph(
                 graph_config=self._workflow.graph_dict,
                 graph_runtime_state=graph_runtime_state,

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

@@ -0,0 +1,7 @@
+from libs.exception import BaseHTTPException
+
+
+class WorkflowPausedInBlockingModeError(BaseHTTPException):
+    error_code = "workflow_paused_in_blocking_mode"
+    description = "Workflow execution paused for human input; blocking response mode is not supported."
+    code = 400

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

@@ -16,6 +16,8 @@ from core.app.entities.queue_entities import (
     MessageQueueMessage,
     QueueAgentLogEvent,
     QueueErrorEvent,
+    QueueHumanInputFormFilledEvent,
+    QueueHumanInputFormTimeoutEvent,
     QueueIterationCompletedEvent,
     QueueIterationNextEvent,
     QueueIterationStartEvent,
@@ -32,6 +34,7 @@ from core.app.entities.queue_entities import (
     QueueTextChunkEvent,
     QueueWorkflowFailedEvent,
     QueueWorkflowPartialSuccessEvent,
+    QueueWorkflowPausedEvent,
     QueueWorkflowStartedEvent,
     QueueWorkflowSucceededEvent,
     WorkflowQueueMessage,
@@ -46,11 +49,13 @@ from core.app.entities.task_entities import (
     WorkflowAppBlockingResponse,
     WorkflowAppStreamResponse,
     WorkflowFinishStreamResponse,
+    WorkflowPauseStreamResponse,
     WorkflowStartStreamResponse,
 )
 from core.app.task_pipeline.based_generate_task_pipeline import BasedGenerateTaskPipeline
 from core.base.tts import AppGeneratorTTSPublisher, AudioTrunk
 from core.ops.ops_trace_manager import TraceQueueManager
+from core.workflow.entities.workflow_start_reason import WorkflowStartReason
 from core.workflow.enums import WorkflowExecutionStatus
 from core.workflow.repositories.draft_variable_repository import DraftVariableSaverFactory
 from core.workflow.runtime import GraphRuntimeState
@@ -132,6 +137,25 @@ class WorkflowAppGenerateTaskPipeline(GraphRuntimeStateSupport):
         for stream_response in generator:
             if isinstance(stream_response, ErrorStreamResponse):
                 raise stream_response.err
+            elif isinstance(stream_response, WorkflowPauseStreamResponse):
+                response = WorkflowAppBlockingResponse(
+                    task_id=self._application_generate_entity.task_id,
+                    workflow_run_id=stream_response.data.workflow_run_id,
+                    data=WorkflowAppBlockingResponse.Data(
+                        id=stream_response.data.workflow_run_id,
+                        workflow_id=self._workflow.id,
+                        status=stream_response.data.status,
+                        outputs=stream_response.data.outputs or {},
+                        error=None,
+                        elapsed_time=stream_response.data.elapsed_time,
+                        total_tokens=stream_response.data.total_tokens,
+                        total_steps=stream_response.data.total_steps,
+                        created_at=stream_response.data.created_at,
+                        finished_at=None,
+                    ),
+                )
+
+                return response
             elif isinstance(stream_response, WorkflowFinishStreamResponse):
                 response = WorkflowAppBlockingResponse(
                     task_id=self._application_generate_entity.task_id,
@@ -146,7 +170,7 @@ class WorkflowAppGenerateTaskPipeline(GraphRuntimeStateSupport):
                         total_tokens=stream_response.data.total_tokens,
                         total_steps=stream_response.data.total_steps,
                         created_at=int(stream_response.data.created_at),
-                        finished_at=int(stream_response.data.finished_at),
+                        finished_at=int(stream_response.data.finished_at) if stream_response.data.finished_at else None,
                     ),
                 )
 
@@ -259,13 +283,15 @@ class WorkflowAppGenerateTaskPipeline(GraphRuntimeStateSupport):
         run_id = self._extract_workflow_run_id(runtime_state)
         self._workflow_execution_id = run_id
 
-        with self._database_session() as session:
-            self._save_workflow_app_log(session=session, workflow_run_id=self._workflow_execution_id)
+        if event.reason == WorkflowStartReason.INITIAL:
+            with self._database_session() as session:
+                self._save_workflow_app_log(session=session, workflow_run_id=self._workflow_execution_id)
 
         start_resp = self._workflow_response_converter.workflow_start_to_stream_response(
             task_id=self._application_generate_entity.task_id,
             workflow_run_id=run_id,
             workflow_id=self._workflow.id,
+            reason=event.reason,
         )
         yield start_resp
 
@@ -440,6 +466,21 @@ class WorkflowAppGenerateTaskPipeline(GraphRuntimeStateSupport):
         )
         yield workflow_finish_resp
 
+    def _handle_workflow_paused_event(
+        self,
+        event: QueueWorkflowPausedEvent,
+        **kwargs,
+    ) -> Generator[StreamResponse, None, None]:
+        """Handle workflow paused events."""
+        self._ensure_workflow_initialized()
+        validated_state = self._ensure_graph_runtime_initialized()
+        responses = self._workflow_response_converter.workflow_pause_to_stream_response(
+            event=event,
+            task_id=self._application_generate_entity.task_id,
+            graph_runtime_state=validated_state,
+        )
+        yield from responses
+
     def _handle_workflow_failed_and_stop_events(
         self,
         event: Union[QueueWorkflowFailedEvent, QueueStopEvent],
@@ -495,6 +536,22 @@ class WorkflowAppGenerateTaskPipeline(GraphRuntimeStateSupport):
             task_id=self._application_generate_entity.task_id, event=event
         )
 
+    def _handle_human_input_form_filled_event(
+        self, event: QueueHumanInputFormFilledEvent, **kwargs
+    ) -> Generator[StreamResponse, None, None]:
+        """Handle human input form filled events."""
+        yield self._workflow_response_converter.human_input_form_filled_to_stream_response(
+            event=event, task_id=self._application_generate_entity.task_id
+        )
+
+    def _handle_human_input_form_timeout_event(
+        self, event: QueueHumanInputFormTimeoutEvent, **kwargs
+    ) -> Generator[StreamResponse, None, None]:
+        """Handle human input form timeout events."""
+        yield self._workflow_response_converter.human_input_form_timeout_to_stream_response(
+            event=event, task_id=self._application_generate_entity.task_id
+        )
+
     def _get_event_handlers(self) -> dict[type, Callable]:
         """Get mapping of event types to their handlers using fluent pattern."""
         return {
@@ -506,6 +563,7 @@ class WorkflowAppGenerateTaskPipeline(GraphRuntimeStateSupport):
             QueueWorkflowStartedEvent: self._handle_workflow_started_event,
             QueueWorkflowSucceededEvent: self._handle_workflow_succeeded_event,
             QueueWorkflowPartialSuccessEvent: self._handle_workflow_partial_success_event,
+            QueueWorkflowPausedEvent: self._handle_workflow_paused_event,
             # Node events
             QueueNodeRetryEvent: self._handle_node_retry_event,
             QueueNodeStartedEvent: self._handle_node_started_event,
@@ -520,6 +578,8 @@ class WorkflowAppGenerateTaskPipeline(GraphRuntimeStateSupport):
             QueueLoopCompletedEvent: self._handle_loop_completed_event,
             # Agent events
             QueueAgentLogEvent: self._handle_agent_log_event,
+            QueueHumanInputFormFilledEvent: self._handle_human_input_form_filled_event,
+            QueueHumanInputFormTimeoutEvent: self._handle_human_input_form_timeout_event,
         }
 
     def _dispatch_event(
@@ -602,6 +662,9 @@ class WorkflowAppGenerateTaskPipeline(GraphRuntimeStateSupport):
                 case QueueWorkflowFailedEvent():
                     yield from self._handle_workflow_failed_and_stop_events(event)
                     break
+                case QueueWorkflowPausedEvent():
+                    yield from self._handle_workflow_paused_event(event)
+                    break
 
                 case QueueStopEvent():
                     yield from self._handle_workflow_failed_and_stop_events(event)

api/core/app/apps/workflow_app_runner.py

@@ -1,3 +1,4 @@
+import logging
 import time
 from collections.abc import Mapping, Sequence
 from typing import Any, cast
@@ -7,6 +8,8 @@ from core.app.entities.app_invoke_entities import InvokeFrom
 from core.app.entities.queue_entities import (
     AppQueueEvent,
     QueueAgentLogEvent,
+    QueueHumanInputFormFilledEvent,
+    QueueHumanInputFormTimeoutEvent,
     QueueIterationCompletedEvent,
     QueueIterationNextEvent,
     QueueIterationStartEvent,
@@ -22,22 +25,27 @@ from core.app.entities.queue_entities import (
     QueueTextChunkEvent,
     QueueWorkflowFailedEvent,
     QueueWorkflowPartialSuccessEvent,
+    QueueWorkflowPausedEvent,
     QueueWorkflowStartedEvent,
     QueueWorkflowSucceededEvent,
 )
 from core.app.workflow.node_factory import DifyNodeFactory
 from core.workflow.entities import GraphInitParams
+from core.workflow.entities.pause_reason import HumanInputRequired
 from core.workflow.graph import Graph
 from core.workflow.graph_engine.layers.base import GraphEngineLayer
 from core.workflow.graph_events import (
     GraphEngineEvent,
     GraphRunFailedEvent,
     GraphRunPartialSucceededEvent,
+    GraphRunPausedEvent,
     GraphRunStartedEvent,
     GraphRunSucceededEvent,
     NodeRunAgentLogEvent,
     NodeRunExceptionEvent,
     NodeRunFailedEvent,
+    NodeRunHumanInputFormFilledEvent,
+    NodeRunHumanInputFormTimeoutEvent,
     NodeRunIterationFailedEvent,
     NodeRunIterationNextEvent,
     NodeRunIterationStartedEvent,
@@ -61,6 +69,9 @@ from core.workflow.variable_loader import DUMMY_VARIABLE_LOADER, VariableLoader,
 from core.workflow.workflow_entry import WorkflowEntry
 from models.enums import UserFrom
 from models.workflow import Workflow
+from tasks.mail_human_input_delivery_task import dispatch_human_input_email_task
+
+logger = logging.getLogger(__name__)
 
 
 class WorkflowBasedAppRunner:
@@ -327,7 +338,7 @@ class WorkflowBasedAppRunner:
         :param event: event
         """
         if isinstance(event, GraphRunStartedEvent):
-            self._publish_event(QueueWorkflowStartedEvent())
+            self._publish_event(QueueWorkflowStartedEvent(reason=event.reason))
         elif isinstance(event, GraphRunSucceededEvent):
             self._publish_event(QueueWorkflowSucceededEvent(outputs=event.outputs))
         elif isinstance(event, GraphRunPartialSucceededEvent):
@@ -338,6 +349,38 @@ class WorkflowBasedAppRunner:
             self._publish_event(QueueWorkflowFailedEvent(error=event.error, exceptions_count=event.exceptions_count))
         elif isinstance(event, GraphRunAbortedEvent):
             self._publish_event(QueueWorkflowFailedEvent(error=event.reason or "Unknown error", exceptions_count=0))
+        elif isinstance(event, GraphRunPausedEvent):
+            runtime_state = workflow_entry.graph_engine.graph_runtime_state
+            paused_nodes = runtime_state.get_paused_nodes()
+            self._enqueue_human_input_notifications(event.reasons)
+            self._publish_event(
+                QueueWorkflowPausedEvent(
+                    reasons=event.reasons,
+                    outputs=event.outputs,
+                    paused_nodes=paused_nodes,
+                )
+            )
+        elif isinstance(event, NodeRunHumanInputFormFilledEvent):
+            self._publish_event(
+                QueueHumanInputFormFilledEvent(
+                    node_execution_id=event.id,
+                    node_id=event.node_id,
+                    node_type=event.node_type,
+                    node_title=event.node_title,
+                    rendered_content=event.rendered_content,
+                    action_id=event.action_id,
+                    action_text=event.action_text,
+                )
+            )
+        elif isinstance(event, NodeRunHumanInputFormTimeoutEvent):
+            self._publish_event(
+                QueueHumanInputFormTimeoutEvent(
+                    node_id=event.node_id,
+                    node_type=event.node_type,
+                    node_title=event.node_title,
+                    expiration_time=event.expiration_time,
+                )
+            )
         elif isinstance(event, NodeRunRetryEvent):
             node_run_result = event.node_run_result
             inputs = node_run_result.inputs
@@ -544,5 +587,19 @@ class WorkflowBasedAppRunner:
                 )
             )
 
+    def _enqueue_human_input_notifications(self, reasons: Sequence[object]) -> None:
+        for reason in reasons:
+            if not isinstance(reason, HumanInputRequired):
+                continue
+            if not reason.form_id:
+                continue
+            try:
+                dispatch_human_input_email_task.apply_async(
+                    kwargs={"form_id": reason.form_id, "node_title": reason.node_title},
+                    queue="mail",
+                )
+            except Exception:  # pragma: no cover - defensive logging
+                logger.exception("Failed to enqueue human input email task for form %s", reason.form_id)
+
     def _publish_event(self, event: AppQueueEvent):
         self._queue_manager.publish(event, PublishFrom.APPLICATION_MANAGER)

api/core/app/entities/app_invoke_entities.py

@@ -132,7 +132,7 @@ class AppGenerateEntity(BaseModel):
     extras: dict[str, Any] = Field(default_factory=dict)
 
     # tracing instance
-    trace_manager: Optional["TraceQueueManager"] = None
+    trace_manager: Optional["TraceQueueManager"] = Field(default=None, exclude=True, repr=False)
 
 
 class EasyUIBasedAppGenerateEntity(AppGenerateEntity):
@@ -156,6 +156,7 @@ class ConversationAppGenerateEntity(AppGenerateEntity):
     """
 
     conversation_id: str | None = None
+    is_new_conversation: bool = False
     parent_message_id: str | None = Field(
         default=None,
         description=(

api/core/app/entities/queue_entities.py

@@ -8,6 +8,8 @@ from pydantic import BaseModel, ConfigDict, Field
 from core.model_runtime.entities.llm_entities import LLMResult, LLMResultChunk
 from core.rag.entities.citation_metadata import RetrievalSourceMetadata
 from core.workflow.entities import AgentNodeStrategyInit
+from core.workflow.entities.pause_reason import PauseReason
+from core.workflow.entities.workflow_start_reason import WorkflowStartReason
 from core.workflow.enums import WorkflowNodeExecutionMetadataKey
 from core.workflow.nodes import NodeType
 
@@ -46,6 +48,9 @@ class QueueEvent(StrEnum):
     PING = "ping"
     STOP = "stop"
     RETRY = "retry"
+    PAUSE = "pause"
+    HUMAN_INPUT_FORM_FILLED = "human_input_form_filled"
+    HUMAN_INPUT_FORM_TIMEOUT = "human_input_form_timeout"
 
 
 class AppQueueEvent(BaseModel):
@@ -261,6 +266,8 @@ class QueueWorkflowStartedEvent(AppQueueEvent):
     """QueueWorkflowStartedEvent entity."""
 
     event: QueueEvent = QueueEvent.WORKFLOW_STARTED
+    # Always present; mirrors GraphRunStartedEvent.reason for downstream consumers.
+    reason: WorkflowStartReason = WorkflowStartReason.INITIAL
 
 
 class QueueWorkflowSucceededEvent(AppQueueEvent):
@@ -484,6 +491,35 @@ class QueueStopEvent(AppQueueEvent):
         return reason_mapping.get(self.stopped_by, "Stopped by unknown reason.")
 
 
+class QueueHumanInputFormFilledEvent(AppQueueEvent):
+    """
+    QueueHumanInputFormFilledEvent entity
+    """
+
+    event: QueueEvent = QueueEvent.HUMAN_INPUT_FORM_FILLED
+
+    node_execution_id: str
+    node_id: str
+    node_type: NodeType
+    node_title: str
+    rendered_content: str
+    action_id: str
+    action_text: str
+
+
+class QueueHumanInputFormTimeoutEvent(AppQueueEvent):
+    """
+    QueueHumanInputFormTimeoutEvent entity
+    """
+
+    event: QueueEvent = QueueEvent.HUMAN_INPUT_FORM_TIMEOUT
+
+    node_id: str
+    node_type: NodeType
+    node_title: str
+    expiration_time: datetime
+
+
 class QueueMessage(BaseModel):
     """
     QueueMessage abstract entity
@@ -509,3 +545,14 @@ class WorkflowQueueMessage(QueueMessage):
     """
 
     pass
+
+
+class QueueWorkflowPausedEvent(AppQueueEvent):
+    """
+    QueueWorkflowPausedEvent entity
+    """
+
+    event: QueueEvent = QueueEvent.PAUSE
+    reasons: Sequence[PauseReason] = Field(default_factory=list)
+    outputs: Mapping[str, object] = Field(default_factory=dict)
+    paused_nodes: Sequence[str] = Field(default_factory=list)

api/core/app/entities/task_entities.py

@@ -7,7 +7,9 @@ from pydantic import BaseModel, ConfigDict, Field
 from core.model_runtime.entities.llm_entities import LLMResult, LLMUsage
 from core.rag.entities.citation_metadata import RetrievalSourceMetadata
 from core.workflow.entities import AgentNodeStrategyInit
+from core.workflow.entities.workflow_start_reason import WorkflowStartReason
 from core.workflow.enums import WorkflowExecutionStatus, WorkflowNodeExecutionMetadataKey, WorkflowNodeExecutionStatus
+from core.workflow.nodes.human_input.entities import FormInput, UserAction
 
 
 class AnnotationReplyAccount(BaseModel):
@@ -69,6 +71,7 @@ class StreamEvent(StrEnum):
     AGENT_THOUGHT = "agent_thought"
     AGENT_MESSAGE = "agent_message"
     WORKFLOW_STARTED = "workflow_started"
+    WORKFLOW_PAUSED = "workflow_paused"
     WORKFLOW_FINISHED = "workflow_finished"
     NODE_STARTED = "node_started"
     NODE_FINISHED = "node_finished"
@@ -82,6 +85,9 @@ class StreamEvent(StrEnum):
     TEXT_CHUNK = "text_chunk"
     TEXT_REPLACE = "text_replace"
     AGENT_LOG = "agent_log"
+    HUMAN_INPUT_REQUIRED = "human_input_required"
+    HUMAN_INPUT_FORM_FILLED = "human_input_form_filled"
+    HUMAN_INPUT_FORM_TIMEOUT = "human_input_form_timeout"
 
 
 class StreamResponse(BaseModel):
@@ -205,6 +211,8 @@ class WorkflowStartStreamResponse(StreamResponse):
         workflow_id: str
         inputs: Mapping[str, Any]
         created_at: int
+        # Always present; mirrors QueueWorkflowStartedEvent.reason for SSE clients.
+        reason: WorkflowStartReason = WorkflowStartReason.INITIAL
 
     event: StreamEvent = StreamEvent.WORKFLOW_STARTED
     workflow_run_id: str
@@ -231,7 +239,7 @@ class WorkflowFinishStreamResponse(StreamResponse):
         total_steps: int
         created_by: Mapping[str, object] = Field(default_factory=dict)
         created_at: int
-        finished_at: int
+        finished_at: int | None
         exceptions_count: int | None = 0
         files: Sequence[Mapping[str, Any]] | None = []
 
@@ -240,6 +248,85 @@ class WorkflowFinishStreamResponse(StreamResponse):
     data: Data
 
 
+class WorkflowPauseStreamResponse(StreamResponse):
+    """
+    WorkflowPauseStreamResponse entity
+    """
+
+    class Data(BaseModel):
+        """
+        Data entity
+        """
+
+        workflow_run_id: str
+        paused_nodes: Sequence[str] = Field(default_factory=list)
+        outputs: Mapping[str, Any] = Field(default_factory=dict)
+        reasons: Sequence[Mapping[str, Any]] = Field(default_factory=list)
+        status: WorkflowExecutionStatus
+        created_at: int
+        elapsed_time: float
+        total_tokens: int
+        total_steps: int
+
+    event: StreamEvent = StreamEvent.WORKFLOW_PAUSED
+    workflow_run_id: str
+    data: Data
+
+
+class HumanInputRequiredResponse(StreamResponse):
+    class Data(BaseModel):
+        """
+        Data entity
+        """
+
+        form_id: str
+        node_id: str
+        node_title: str
+        form_content: str
+        inputs: Sequence[FormInput] = Field(default_factory=list)
+        actions: Sequence[UserAction] = Field(default_factory=list)
+        display_in_ui: bool = False
+        form_token: str | None = None
+        resolved_default_values: Mapping[str, Any] = Field(default_factory=dict)
+        expiration_time: int = Field(..., description="Unix timestamp in seconds")
+
+    event: StreamEvent = StreamEvent.HUMAN_INPUT_REQUIRED
+    workflow_run_id: str
+    data: Data
+
+
+class HumanInputFormFilledResponse(StreamResponse):
+    class Data(BaseModel):
+        """
+        Data entity
+        """
+
+        node_id: str
+        node_title: str
+        rendered_content: str
+        action_id: str
+        action_text: str
+
+    event: StreamEvent = StreamEvent.HUMAN_INPUT_FORM_FILLED
+    workflow_run_id: str
+    data: Data
+
+
+class HumanInputFormTimeoutResponse(StreamResponse):
+    class Data(BaseModel):
+        """
+        Data entity
+        """
+
+        node_id: str
+        node_title: str
+        expiration_time: int
+
+    event: StreamEvent = StreamEvent.HUMAN_INPUT_FORM_TIMEOUT
+    workflow_run_id: str
+    data: Data
+
+
 class NodeStartStreamResponse(StreamResponse):
     """
     NodeStartStreamResponse entity
@@ -726,7 +813,7 @@ class WorkflowAppBlockingResponse(AppBlockingResponse):
         total_tokens: int
         total_steps: int
         created_at: int
-        finished_at: int
+        finished_at: int | None
 
     workflow_run_id: str
     data: Data

api/core/app/features/rate_limiting/rate_limit.py

@@ -1,3 +1,4 @@
+import contextlib
 import logging
 import time
 import uuid
@@ -103,6 +104,14 @@ class RateLimit:
             )
 
 
+@contextlib.contextmanager
+def rate_limit_context(rate_limit: RateLimit, request_id: str | None):
+    request_id = rate_limit.enter(request_id)
+    yield
+    if request_id is not None:
+        rate_limit.exit(request_id)
+
+
 class RateLimitGenerator:
     def __init__(self, rate_limit: RateLimit, generator: Generator[str, None, None], request_id: str):
         self.rate_limit = rate_limit

api/core/app/layers/pause_state_persist_layer.py

@@ -1,3 +1,4 @@
+from dataclasses import dataclass
 from typing import Annotated, Literal, Self, TypeAlias
 
 from pydantic import BaseModel, Field
@@ -52,6 +53,14 @@ class WorkflowResumptionContext(BaseModel):
         return self.generate_entity.entity
 
 
+@dataclass(frozen=True)
+class PauseStateLayerConfig:
+    """Configuration container for instantiating pause persistence layers."""
+
+    session_factory: Engine | sessionmaker[Session]
+    state_owner_user_id: str
+
+
 class PauseStatePersistenceLayer(GraphEngineLayer):
     def __init__(
         self,

api/core/app/task_pipeline/message_cycle_manager.py

@@ -82,10 +82,11 @@ class MessageCycleManager:
         if isinstance(self._application_generate_entity, CompletionAppGenerateEntity):
             return None
 
-        is_first_message = self._application_generate_entity.conversation_id is None
+        is_first_message = self._application_generate_entity.is_new_conversation
         extras = self._application_generate_entity.extras
         auto_generate_conversation_name = extras.get("auto_generate_conversation_name", True)
 
+        thread: Thread | None = None
         if auto_generate_conversation_name and is_first_message:
             # start generate thread
             # time.sleep not block other logic
@@ -101,9 +102,10 @@ class MessageCycleManager:
             thread.daemon = True
             thread.start()
 
-            return thread
+        if is_first_message:
+            self._application_generate_entity.is_new_conversation = False
 
-        return None
+        return thread
 
     def _generate_conversation_name_worker(self, flask_app: Flask, conversation_id: str, query: str):
         with flask_app.app_context():

api/core/app/workflow/node_factory.py

@@ -8,6 +8,7 @@ from core.file.file_manager import file_manager
 from core.helper.code_executor.code_executor import CodeExecutor
 from core.helper.code_executor.code_node_provider import CodeNodeProvider
 from core.helper.ssrf_proxy import ssrf_proxy
+from core.rag.retrieval.dataset_retrieval import DatasetRetrieval
 from core.tools.tool_file_manager import ToolFileManager
 from core.workflow.entities.graph_config import NodeConfigDict
 from core.workflow.enums import NodeType
@@ -16,6 +17,7 @@ from core.workflow.nodes.base.node import Node
 from core.workflow.nodes.code.code_node import CodeNode
 from core.workflow.nodes.code.limits import CodeNodeLimits
 from core.workflow.nodes.http_request.node import HttpRequestNode
+from core.workflow.nodes.knowledge_retrieval.knowledge_retrieval_node import KnowledgeRetrievalNode
 from core.workflow.nodes.node_mapping import LATEST_VERSION, NODE_TYPE_CLASSES_MAPPING
 from core.workflow.nodes.protocols import FileManagerProtocol, HttpClientProtocol
 from core.workflow.nodes.template_transform.template_renderer import (
@@ -47,6 +49,7 @@ class DifyNodeFactory(NodeFactory):
         code_providers: Sequence[type[CodeNodeProvider]] | None = None,
         code_limits: CodeNodeLimits | None = None,
         template_renderer: Jinja2TemplateRenderer | None = None,
+        template_transform_max_output_length: int | None = None,
         http_request_http_client: HttpClientProtocol | None = None,
         http_request_tool_file_manager_factory: Callable[[], ToolFileManager] = ToolFileManager,
         http_request_file_manager: FileManagerProtocol | None = None,
@@ -68,9 +71,13 @@ class DifyNodeFactory(NodeFactory):
             max_object_array_length=dify_config.CODE_MAX_OBJECT_ARRAY_LENGTH,
         )
         self._template_renderer = template_renderer or CodeExecutorJinja2TemplateRenderer()
+        self._template_transform_max_output_length = (
+            template_transform_max_output_length or dify_config.TEMPLATE_TRANSFORM_MAX_LENGTH
+        )
         self._http_request_http_client = http_request_http_client or ssrf_proxy
         self._http_request_tool_file_manager_factory = http_request_tool_file_manager_factory
         self._http_request_file_manager = http_request_file_manager or file_manager
+        self._rag_retrieval = DatasetRetrieval()
 
     @override
     def create_node(self, node_config: NodeConfigDict) -> Node:
@@ -122,6 +129,7 @@ class DifyNodeFactory(NodeFactory):
                 graph_init_params=self.graph_init_params,
                 graph_runtime_state=self.graph_runtime_state,
                 template_renderer=self._template_renderer,
+                max_output_length=self._template_transform_max_output_length,
             )
 
         if node_type == NodeType.HTTP_REQUEST:
@@ -135,6 +143,15 @@ class DifyNodeFactory(NodeFactory):
                 file_manager=self._http_request_file_manager,
             )
 
+        if node_type == NodeType.KNOWLEDGE_RETRIEVAL:
+            return KnowledgeRetrievalNode(
+                id=node_id,
+                config=node_config,
+                graph_init_params=self.graph_init_params,
+                graph_runtime_state=self.graph_runtime_state,
+                rag_retrieval=self._rag_retrieval,
+            )
+
         return node_class(
             id=node_id,
             config=node_config,

api/core/entities/execution_extra_content.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from typing import Any, TypeAlias
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from core.workflow.nodes.human_input.entities import FormInput, UserAction
+from models.execution_extra_content import ExecutionContentType
+
+
+class HumanInputFormDefinition(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
+    form_id: str
+    node_id: str
+    node_title: str
+    form_content: str
+    inputs: Sequence[FormInput] = Field(default_factory=list)
+    actions: Sequence[UserAction] = Field(default_factory=list)
+    display_in_ui: bool = False
+    form_token: str | None = None
+    resolved_default_values: Mapping[str, Any] = Field(default_factory=dict)
+    expiration_time: int
+
+
+class HumanInputFormSubmissionData(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
+    node_id: str
+    node_title: str
+    rendered_content: str
+    action_id: str
+    action_text: str
+
+
+class HumanInputContent(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
+    workflow_run_id: str
+    submitted: bool
+    form_definition: HumanInputFormDefinition | None = None
+    form_submission_data: HumanInputFormSubmissionData | None = None
+    type: ExecutionContentType = Field(default=ExecutionContentType.HUMAN_INPUT)
+
+
+ExecutionExtraContentDomainModel: TypeAlias = HumanInputContent
+
+__all__ = [
+    "ExecutionExtraContentDomainModel",
+    "HumanInputContent",
+    "HumanInputFormDefinition",
+    "HumanInputFormSubmissionData",
+]

api/core/entities/provider_configuration.py

@@ -28,8 +28,8 @@ from core.model_runtime.entities.provider_entities import (
 )
 from core.model_runtime.model_providers.__base.ai_model import AIModel
 from core.model_runtime.model_providers.model_provider_factory import ModelProviderFactory
-from extensions.ext_database import db
 from libs.datetime_utils import naive_utc_now
+from models.engine import db
 from models.provider import (
     LoadBalancingModelConfig,
     Provider,

api/core/helper/marketplace.py

@@ -6,7 +6,8 @@ from yarl import URL
 
 from configs import dify_config
 from core.helper.download import download_with_size_limit
-from core.plugin.entities.marketplace import MarketplacePluginDeclaration
+from core.plugin.entities.marketplace import MarketplacePluginDeclaration, MarketplacePluginSnapshot
+from extensions.ext_redis import redis_client
 
 marketplace_api_url = URL(str(dify_config.MARKETPLACE_API_URL))
 logger = logging.getLogger(__name__)
@@ -43,28 +44,37 @@ def batch_fetch_plugin_by_ids(plugin_ids: list[str]) -> list[dict]:
     return data.get("data", {}).get("plugins", [])
 
 
-def batch_fetch_plugin_manifests_ignore_deserialization_error(
-    plugin_ids: list[str],
-) -> Sequence[MarketplacePluginDeclaration]:
-    if len(plugin_ids) == 0:
-        return []
-
-    url = str(marketplace_api_url / "api/v1/plugins/batch")
-    response = httpx.post(url, json={"plugin_ids": plugin_ids}, headers={"X-Dify-Version": dify_config.project.version})
-    response.raise_for_status()
-    result: list[MarketplacePluginDeclaration] = []
-    for plugin in response.json()["data"]["plugins"]:
-        try:
-            result.append(MarketplacePluginDeclaration.model_validate(plugin))
-        except Exception:
-            logger.exception(
-                "Failed to deserialize marketplace plugin manifest for %s", plugin.get("plugin_id", "unknown")
-            )
-
-    return result
-
-
 def record_install_plugin_event(plugin_unique_identifier: str):
     url = str(marketplace_api_url / "api/v1/stats/plugins/install_count")
     response = httpx.post(url, json={"unique_identifier": plugin_unique_identifier})
     response.raise_for_status()
+
+
+def fetch_global_plugin_manifest(cache_key_prefix: str, cache_ttl: int) -> None:
+    """
+    Fetch all plugin manifests from marketplace and cache them in Redis.
+    This should be called once per check cycle to populate the instance-level cache.
+
+    Args:
+        cache_key_prefix: Redis key prefix for caching plugin manifests
+        cache_ttl: Cache TTL in seconds
+
+    Raises:
+        httpx.HTTPError: If the HTTP request fails
+        Exception: If any other error occurs during fetching or caching
+    """
+    url = str(marketplace_api_url / "api/v1/dist/plugins/manifest.json")
+    response = httpx.get(url, headers={"X-Dify-Version": dify_config.project.version}, timeout=30)
+    response.raise_for_status()
+
+    raw_json = response.json()
+    plugins_data = raw_json.get("plugins", [])
+
+    # Parse and cache all plugin snapshots
+    for plugin_data in plugins_data:
+        plugin_snapshot = MarketplacePluginSnapshot.model_validate(plugin_data)
+        redis_client.setex(
+            name=f"{cache_key_prefix}{plugin_snapshot.plugin_id}",
+            time=cache_ttl,
+            value=plugin_snapshot.model_dump_json(),
+        )

api/core/helper/ssrf_proxy.py

@@ -171,10 +171,9 @@ 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
-
-            request = client.build_request(method, url, headers=headers, **kwargs)
-            response = client.send(request, follow_redirects=follow_redirects)
+                headers["host"] = user_provided_host
+            kwargs["headers"] = headers
+            response = client.request(method=method, url=url, **kwargs)
 
             # Check for SSRF protection by Squid proxy
             if response.status_code in (401, 403):

api/core/llm_generator/llm_generator.py

@@ -1,5 +1,6 @@
 import json
 import logging
+import re
 from collections.abc import Sequence
 from typing import Protocol, cast
 
@@ -13,6 +14,8 @@ 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,
@@ -29,7 +32,6 @@ 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.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
@@ -283,35 +285,6 @@ class LLMGenerator:
 
         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,

api/core/llm_generator/prompts.py

@@ -143,50 +143,6 @@ 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/ops/ops_trace_manager.py

@@ -15,10 +15,7 @@ from sqlalchemy import select
 from sqlalchemy.orm import Session, sessionmaker
 
 from core.helper.encrypter import batch_decrypt_token, encrypt_token, obfuscated_token
-from core.ops.entities.config_entity import (
-    OPS_FILE_PATH,
-    TracingProviderEnum,
-)
+from core.ops.entities.config_entity import OPS_FILE_PATH, TracingProviderEnum
 from core.ops.entities.trace_entity import (
     DatasetRetrievalTraceInfo,
     GenerateNameTraceInfo,
@@ -31,8 +28,8 @@ from core.ops.entities.trace_entity import (
     WorkflowTraceInfo,
 )
 from core.ops.utils import get_message_data
-from extensions.ext_database import db
 from extensions.ext_storage import storage
+from models.engine import db
 from models.model import App, AppModelConfig, Conversation, Message, MessageFile, TraceAppConfig
 from models.workflow import WorkflowAppLog
 from tasks.ops_trace_task import process_trace_tasks
@@ -469,6 +466,8 @@ class TraceTask:
 
     @classmethod
     def _get_workflow_run_repo(cls):
+        from repositories.factory import DifyAPIRepositoryFactory
+
         if cls._workflow_run_repo is None:
             with cls._repo_lock:
                 if cls._workflow_run_repo is None:

api/core/ops/utils.py

@@ -5,7 +5,7 @@ from urllib.parse import urlparse
 
 from sqlalchemy import select
 
-from extensions.ext_database import db
+from models.engine import db
 from models.model import Message
 
 

api/core/plugin/backwards_invocation/app.py

@@ -1,3 +1,4 @@
+import uuid
 from collections.abc import Generator, Mapping
 from typing import Union
 
@@ -11,6 +12,7 @@ from core.app.apps.chat.app_generator import ChatAppGenerator
 from core.app.apps.completion.app_generator import CompletionAppGenerator
 from core.app.apps.workflow.app_generator import WorkflowAppGenerator
 from core.app.entities.app_invoke_entities import InvokeFrom
+from core.app.layers.pause_state_persist_layer import PauseStateLayerConfig
 from core.plugin.backwards_invocation.base import BaseBackwardsInvocation
 from extensions.ext_database import db
 from models import Account
@@ -101,6 +103,11 @@ class PluginAppBackwardsInvocation(BaseBackwardsInvocation):
             if not workflow:
                 raise ValueError("unexpected app type")
 
+            pause_config = PauseStateLayerConfig(
+                session_factory=db.engine,
+                state_owner_user_id=workflow.created_by,
+            )
+
             return AdvancedChatAppGenerator().generate(
                 app_model=app,
                 workflow=workflow,
@@ -112,7 +119,9 @@ class PluginAppBackwardsInvocation(BaseBackwardsInvocation):
                     "conversation_id": conversation_id,
                 },
                 invoke_from=InvokeFrom.SERVICE_API,
+                workflow_run_id=str(uuid.uuid4()),
                 streaming=stream,
+                pause_state_config=pause_config,
             )
         elif app.mode == AppMode.AGENT_CHAT:
             return AgentChatAppGenerator().generate(
@@ -159,6 +168,11 @@ class PluginAppBackwardsInvocation(BaseBackwardsInvocation):
         if not workflow:
             raise ValueError("unexpected app type")
 
+        pause_config = PauseStateLayerConfig(
+            session_factory=db.engine,
+            state_owner_user_id=workflow.created_by,
+        )
+
         return WorkflowAppGenerator().generate(
             app_model=app,
             workflow=workflow,
@@ -167,6 +181,7 @@ class PluginAppBackwardsInvocation(BaseBackwardsInvocation):
             invoke_from=InvokeFrom.SERVICE_API,
             streaming=stream,
             call_depth=1,
+            pause_state_config=pause_config,
         )
 
     @classmethod

api/core/plugin/entities/marketplace.py

@@ -1,4 +1,4 @@
-from pydantic import BaseModel, Field, model_validator
+from pydantic import BaseModel, Field, computed_field, model_validator
 
 from core.model_runtime.entities.provider_entities import ProviderEntity
 from core.plugin.entities.endpoint import EndpointProviderDeclaration
@@ -48,3 +48,15 @@ class MarketplacePluginDeclaration(BaseModel):
         if "tool" in data and not data["tool"]:
             del data["tool"]
         return data
+
+
+class MarketplacePluginSnapshot(BaseModel):
+    org: str
+    name: str
+    latest_version: str
+    latest_package_identifier: str
+    latest_package_url: str
+
+    @computed_field
+    def plugin_id(self) -> str:
+        return f"{self.org}/{self.name}"

api/core/rag/retrieval/dataset_retrieval.py

@@ -1,13 +1,15 @@
 import json
+import logging
 import math
 import re
 import threading
+import time
 from collections import Counter, defaultdict
 from collections.abc import Generator, Mapping
 from typing import Any, Union, cast
 
 from flask import Flask, current_app
-from sqlalchemy import and_, literal, or_, select
+from sqlalchemy import and_, func, literal, or_, select
 from sqlalchemy.orm import Session
 
 from core.app.app_config.entities import (
@@ -18,6 +20,7 @@ from core.app.app_config.entities import (
 )
 from core.app.entities.app_invoke_entities import InvokeFrom, ModelConfigWithCredentialsEntity
 from core.callback_handler.index_tool_callback_handler import DatasetIndexToolCallbackHandler
+from core.db.session_factory import session_factory
 from core.entities.agent_entities import PlanningStrategy
 from core.entities.model_entities import ModelStatus
 from core.file import File, FileTransferMethod, FileType
@@ -58,12 +61,30 @@ from core.rag.retrieval.template_prompts import (
 )
 from core.tools.signature import sign_upload_file
 from core.tools.utils.dataset_retriever.dataset_retriever_base_tool import DatasetRetrieverBaseTool
+from core.workflow.nodes.knowledge_retrieval import exc
+from core.workflow.repositories.rag_retrieval_protocol import (
+    KnowledgeRetrievalRequest,
+    Source,
+    SourceChildChunk,
+    SourceMetadata,
+)
 from extensions.ext_database import db
+from extensions.ext_redis import redis_client
 from libs.json_in_md_parser import parse_and_check_json_markdown
 from models import UploadFile
-from models.dataset import ChildChunk, Dataset, DatasetMetadata, DatasetQuery, DocumentSegment, SegmentAttachmentBinding
+from models.dataset import (
+    ChildChunk,
+    Dataset,
+    DatasetMetadata,
+    DatasetQuery,
+    DocumentSegment,
+    RateLimitLog,
+    SegmentAttachmentBinding,
+)
 from models.dataset import Document as DatasetDocument
+from models.dataset import Document as DocumentModel
 from services.external_knowledge_service import ExternalDatasetService
+from services.feature_service import FeatureService
 
 default_retrieval_model: dict[str, Any] = {
     "search_method": RetrievalMethod.SEMANTIC_SEARCH,
@@ -73,6 +94,8 @@ default_retrieval_model: dict[str, Any] = {
     "score_threshold_enabled": False,
 }
 
+logger = logging.getLogger(__name__)
+
 
 class DatasetRetrieval:
     def __init__(self, application_generate_entity=None):
@@ -91,6 +114,233 @@ class DatasetRetrieval:
         else:
             self._llm_usage = self._llm_usage.plus(usage)
 
+    def knowledge_retrieval(self, request: KnowledgeRetrievalRequest) -> list[Source]:
+        self._check_knowledge_rate_limit(request.tenant_id)
+        available_datasets = self._get_available_datasets(request.tenant_id, request.dataset_ids)
+        available_datasets_ids = [i.id for i in available_datasets]
+        if not available_datasets_ids:
+            return []
+
+        if not request.query:
+            return []
+
+        metadata_filter_document_ids, metadata_condition = None, None
+
+        if request.metadata_filtering_mode != "disabled":
+            # Convert workflow layer types to app_config layer types
+            if not request.metadata_model_config:
+                raise ValueError("metadata_model_config is required for this method")
+
+            app_metadata_model_config = ModelConfig.model_validate(request.metadata_model_config.model_dump())
+
+            app_metadata_filtering_conditions = None
+            if request.metadata_filtering_conditions is not None:
+                app_metadata_filtering_conditions = MetadataFilteringCondition.model_validate(
+                    request.metadata_filtering_conditions.model_dump()
+                )
+
+            query = request.query if request.query is not None else ""
+
+            metadata_filter_document_ids, metadata_condition = self.get_metadata_filter_condition(
+                dataset_ids=available_datasets_ids,
+                query=query,
+                tenant_id=request.tenant_id,
+                user_id=request.user_id,
+                metadata_filtering_mode=request.metadata_filtering_mode,
+                metadata_model_config=app_metadata_model_config,
+                metadata_filtering_conditions=app_metadata_filtering_conditions,
+                inputs={},
+            )
+
+        if request.retrieval_mode == DatasetRetrieveConfigEntity.RetrieveStrategy.SINGLE:
+            planning_strategy = PlanningStrategy.REACT_ROUTER
+            # Ensure required fields are not None for single retrieval mode
+            if request.model_provider is None or request.model_name is None or request.query is None:
+                raise ValueError("model_provider, model_name, and query are required for single retrieval mode")
+
+            model_manager = ModelManager()
+            model_instance = model_manager.get_model_instance(
+                tenant_id=request.tenant_id,
+                model_type=ModelType.LLM,
+                provider=request.model_provider,
+                model=request.model_name,
+            )
+
+            provider_model_bundle = model_instance.provider_model_bundle
+            model_type_instance = model_instance.model_type_instance
+            model_type_instance = cast(LargeLanguageModel, model_type_instance)
+
+            model_credentials = model_instance.credentials
+
+            # check model
+            provider_model = provider_model_bundle.configuration.get_provider_model(
+                model=request.model_name, model_type=ModelType.LLM
+            )
+
+            if provider_model is None:
+                raise exc.ModelNotExistError(f"Model {request.model_name} not exist.")
+
+            if provider_model.status == ModelStatus.NO_CONFIGURE:
+                raise exc.ModelCredentialsNotInitializedError(
+                    f"Model {request.model_name} credentials is not initialized."
+                )
+            elif provider_model.status == ModelStatus.NO_PERMISSION:
+                raise exc.ModelNotSupportedError(f"Dify Hosted OpenAI {request.model_name} currently not support.")
+            elif provider_model.status == ModelStatus.QUOTA_EXCEEDED:
+                raise exc.ModelQuotaExceededError(f"Model provider {request.model_provider} quota exceeded.")
+
+            stop = []
+            completion_params = (request.completion_params or {}).copy()
+            if "stop" in completion_params:
+                stop = completion_params["stop"]
+                del completion_params["stop"]
+
+            model_schema = model_type_instance.get_model_schema(request.model_name, model_credentials)
+
+            if not model_schema:
+                raise exc.ModelNotExistError(f"Model {request.model_name} not exist.")
+
+            model_config = ModelConfigWithCredentialsEntity(
+                provider=request.model_provider,
+                model=request.model_name,
+                model_schema=model_schema,
+                mode=request.model_mode or "chat",
+                provider_model_bundle=provider_model_bundle,
+                credentials=model_credentials,
+                parameters=completion_params,
+                stop=stop,
+            )
+            all_documents = self.single_retrieve(
+                request.app_id,
+                request.tenant_id,
+                request.user_id,
+                request.user_from,
+                request.query,
+                available_datasets,
+                model_instance,
+                model_config,
+                planning_strategy,
+                None,  # message_id
+                metadata_filter_document_ids,
+                metadata_condition,
+            )
+        else:
+            all_documents = self.multiple_retrieve(
+                app_id=request.app_id,
+                tenant_id=request.tenant_id,
+                user_id=request.user_id,
+                user_from=request.user_from,
+                available_datasets=available_datasets,
+                query=request.query,
+                top_k=request.top_k,
+                score_threshold=request.score_threshold,
+                reranking_mode=request.reranking_mode,
+                reranking_model=request.reranking_model,
+                weights=request.weights,
+                reranking_enable=request.reranking_enable,
+                metadata_filter_document_ids=metadata_filter_document_ids,
+                metadata_condition=metadata_condition,
+                attachment_ids=request.attachment_ids,
+            )
+
+        dify_documents = [item for item in all_documents if item.provider == "dify"]
+        external_documents = [item for item in all_documents if item.provider == "external"]
+        retrieval_resource_list = []
+        # deal with external documents
+        for item in external_documents:
+            source = Source(
+                metadata=SourceMetadata(
+                    source="knowledge",
+                    dataset_id=item.metadata.get("dataset_id"),
+                    dataset_name=item.metadata.get("dataset_name"),
+                    document_id=item.metadata.get("document_id"),
+                    document_name=item.metadata.get("title"),
+                    data_source_type="external",
+                    retriever_from="workflow",
+                    score=item.metadata.get("score"),
+                    doc_metadata=item.metadata,
+                ),
+                title=item.metadata.get("title"),
+                content=item.page_content,
+            )
+            retrieval_resource_list.append(source)
+        # deal with dify documents
+        if dify_documents:
+            records = RetrievalService.format_retrieval_documents(dify_documents)
+            dataset_ids = [i.segment.dataset_id for i in records]
+            document_ids = [i.segment.document_id for i in records]
+
+            with session_factory.create_session() as session:
+                datasets = session.query(Dataset).where(Dataset.id.in_(dataset_ids)).all()
+                documents = session.query(DatasetDocument).where(DatasetDocument.id.in_(document_ids)).all()
+
+            dataset_map = {i.id: i for i in datasets}
+            document_map = {i.id: i for i in documents}
+
+            if records:
+                for record in records:
+                    segment = record.segment
+                    dataset = dataset_map.get(segment.dataset_id)
+                    document = document_map.get(segment.document_id)
+
+                    if dataset and document:
+                        source = Source(
+                            metadata=SourceMetadata(
+                                source="knowledge",
+                                dataset_id=dataset.id,
+                                dataset_name=dataset.name,
+                                document_id=document.id,
+                                document_name=document.name,
+                                data_source_type=document.data_source_type,
+                                segment_id=segment.id,
+                                retriever_from="workflow",
+                                score=record.score or 0.0,
+                                segment_hit_count=segment.hit_count,
+                                segment_word_count=segment.word_count,
+                                segment_position=segment.position,
+                                segment_index_node_hash=segment.index_node_hash,
+                                doc_metadata=document.doc_metadata,
+                                child_chunks=[
+                                    SourceChildChunk(
+                                        id=str(getattr(chunk, "id", "")),
+                                        content=str(getattr(chunk, "content", "")),
+                                        position=int(getattr(chunk, "position", 0)),
+                                        score=float(getattr(chunk, "score", 0.0)),
+                                    )
+                                    for chunk in (record.child_chunks or [])
+                                ],
+                                position=None,
+                            ),
+                            title=document.name,
+                            files=list(record.files) if record.files else None,
+                            content=segment.get_sign_content(),
+                        )
+                        if segment.answer:
+                            source.content = f"question:{segment.get_sign_content()} \nanswer:{segment.answer}"
+
+                        if record.summary:
+                            source.summary = record.summary
+
+                        retrieval_resource_list.append(source)
+
+        if retrieval_resource_list:
+
+            def _score(item: Source) -> float:
+                meta = item.metadata
+                score = meta.score
+                if isinstance(score, (int, float)):
+                    return float(score)
+                return 0.0
+
+            retrieval_resource_list = sorted(
+                retrieval_resource_list,
+                key=_score,  # type: ignore[arg-type, return-value]
+                reverse=True,
+            )
+            for position, item in enumerate(retrieval_resource_list, start=1):
+                item.metadata.position = position  # type: ignore[index]
+        return retrieval_resource_list
+
     def retrieve(
         self,
         app_id: str,
@@ -150,14 +400,7 @@ class DatasetRetrieval:
         if features:
             if ModelFeature.TOOL_CALL in features or ModelFeature.MULTI_TOOL_CALL in features:
                 planning_strategy = PlanningStrategy.ROUTER
-        available_datasets = []
-
-        dataset_stmt = select(Dataset).where(Dataset.tenant_id == tenant_id, Dataset.id.in_(dataset_ids))
-        datasets: list[Dataset] = db.session.execute(dataset_stmt).scalars().all()  # type: ignore
-        for dataset in datasets:
-            if dataset.available_document_count == 0 and dataset.provider != "external":
-                continue
-            available_datasets.append(dataset)
+        available_datasets = self._get_available_datasets(tenant_id, dataset_ids)
 
         if inputs:
             inputs = {key: str(value) for key, value in inputs.items()}
@@ -1161,7 +1404,6 @@ class DatasetRetrieval:
             query=query or "",
         )
 
-        result_text = ""
         try:
             # handle invoke result
             invoke_result = cast(
@@ -1192,7 +1434,8 @@ class DatasetRetrieval:
                                 "condition": item.get("comparison_operator"),
                             }
                         )
-        except Exception:
+        except Exception as e:
+            logger.warning(e, exc_info=True)
             return None
         return automatic_metadata_filters
 
@@ -1406,7 +1649,12 @@ class DatasetRetrieval:
         usage = None
         for result in invoke_result:
             text = result.delta.message.content
-            full_text += text
+            if isinstance(text, str):
+                full_text += text
+            elif isinstance(text, list):
+                for i in text:
+                    if i.data:
+                        full_text += i.data
 
             if not model:
                 model = result.model
@@ -1524,3 +1772,53 @@ class DatasetRetrieval:
                 cancel_event.set()
             if thread_exceptions is not None:
                 thread_exceptions.append(e)
+
+    def _get_available_datasets(self, tenant_id: str, dataset_ids: list[str]) -> list[Dataset]:
+        with session_factory.create_session() as session:
+            subquery = (
+                session.query(DocumentModel.dataset_id, func.count(DocumentModel.id).label("available_document_count"))
+                .where(
+                    DocumentModel.indexing_status == "completed",
+                    DocumentModel.enabled == True,
+                    DocumentModel.archived == False,
+                    DocumentModel.dataset_id.in_(dataset_ids),
+                )
+                .group_by(DocumentModel.dataset_id)
+                .having(func.count(DocumentModel.id) > 0)
+                .subquery()
+            )
+
+            results = (
+                session.query(Dataset)
+                .outerjoin(subquery, Dataset.id == subquery.c.dataset_id)
+                .where(Dataset.tenant_id == tenant_id, Dataset.id.in_(dataset_ids))
+                .where((subquery.c.available_document_count > 0) | (Dataset.provider == "external"))
+                .all()
+            )
+
+        available_datasets = []
+        for dataset in results:
+            if not dataset:
+                continue
+            available_datasets.append(dataset)
+        return available_datasets
+
+    def _check_knowledge_rate_limit(self, tenant_id: str):
+        knowledge_rate_limit = FeatureService.get_knowledge_rate_limit(tenant_id)
+        if knowledge_rate_limit.enabled:
+            current_time = int(time.time() * 1000)
+            key = f"rate_limit_{tenant_id}"
+            redis_client.zadd(key, {current_time: current_time})
+            redis_client.zremrangebyscore(key, 0, current_time - 60000)
+            request_count = redis_client.zcard(key)
+            if request_count > knowledge_rate_limit.limit:
+                with session_factory.create_session() as session:
+                    rate_limit_log = RateLimitLog(
+                        tenant_id=tenant_id,
+                        subscription_plan=knowledge_rate_limit.subscription_plan,
+                        operation="knowledge",
+                    )
+                    session.add(rate_limit_log)
+                raise exc.RateLimitExceededError(
+                    "you have reached the knowledge base request rate limit of your subscription."
+                )

api/core/repositories/__init__.py

@@ -1,19 +1,18 @@
-"""
-Repository implementations for data access.
+"""Repository implementations for data access."""
 
-This package contains concrete implementations of the repository interfaces
-defined in the core.workflow.repository package.
-"""
+from __future__ import annotations
 
-from core.repositories.celery_workflow_execution_repository import CeleryWorkflowExecutionRepository
-from core.repositories.celery_workflow_node_execution_repository import CeleryWorkflowNodeExecutionRepository
-from core.repositories.factory import DifyCoreRepositoryFactory, RepositoryImportError
-from core.repositories.sqlalchemy_workflow_node_execution_repository import SQLAlchemyWorkflowNodeExecutionRepository
+from .celery_workflow_execution_repository import CeleryWorkflowExecutionRepository
+from .celery_workflow_node_execution_repository import CeleryWorkflowNodeExecutionRepository
+from .factory import DifyCoreRepositoryFactory, RepositoryImportError
+from .sqlalchemy_workflow_execution_repository import SQLAlchemyWorkflowExecutionRepository
+from .sqlalchemy_workflow_node_execution_repository import SQLAlchemyWorkflowNodeExecutionRepository
 
 __all__ = [
     "CeleryWorkflowExecutionRepository",
     "CeleryWorkflowNodeExecutionRepository",
     "DifyCoreRepositoryFactory",
     "RepositoryImportError",
+    "SQLAlchemyWorkflowExecutionRepository",
     "SQLAlchemyWorkflowNodeExecutionRepository",
 ]

api/core/repositories/human_input_repository.py

@@ -0,0 +1,553 @@
+import dataclasses
+import json
+from collections.abc import Mapping, Sequence
+from datetime import datetime
+from typing import Any
+
+from sqlalchemy import Engine, select
+from sqlalchemy.orm import Session, selectinload, sessionmaker
+
+from core.workflow.nodes.human_input.entities import (
+    DeliveryChannelConfig,
+    EmailDeliveryMethod,
+    EmailRecipients,
+    ExternalRecipient,
+    FormDefinition,
+    HumanInputNodeData,
+    MemberRecipient,
+    WebAppDeliveryMethod,
+)
+from core.workflow.nodes.human_input.enums import (
+    DeliveryMethodType,
+    HumanInputFormKind,
+    HumanInputFormStatus,
+)
+from core.workflow.repositories.human_input_form_repository import (
+    FormCreateParams,
+    FormNotFoundError,
+    HumanInputFormEntity,
+    HumanInputFormRecipientEntity,
+)
+from libs.datetime_utils import naive_utc_now
+from libs.uuid_utils import uuidv7
+from models.account import Account, TenantAccountJoin
+from models.human_input import (
+    BackstageRecipientPayload,
+    ConsoleDeliveryPayload,
+    ConsoleRecipientPayload,
+    EmailExternalRecipientPayload,
+    EmailMemberRecipientPayload,
+    HumanInputDelivery,
+    HumanInputForm,
+    HumanInputFormRecipient,
+    RecipientType,
+    StandaloneWebAppRecipientPayload,
+)
+
+
+@dataclasses.dataclass(frozen=True)
+class _DeliveryAndRecipients:
+    delivery: HumanInputDelivery
+    recipients: Sequence[HumanInputFormRecipient]
+
+
+@dataclasses.dataclass(frozen=True)
+class _WorkspaceMemberInfo:
+    user_id: str
+    email: str
+
+
+class _HumanInputFormRecipientEntityImpl(HumanInputFormRecipientEntity):
+    def __init__(self, recipient_model: HumanInputFormRecipient):
+        self._recipient_model = recipient_model
+
+    @property
+    def id(self) -> str:
+        return self._recipient_model.id
+
+    @property
+    def token(self) -> str:
+        if self._recipient_model.access_token is None:
+            raise AssertionError(f"access_token should not be None for recipient {self._recipient_model.id}")
+        return self._recipient_model.access_token
+
+
+class _HumanInputFormEntityImpl(HumanInputFormEntity):
+    def __init__(self, form_model: HumanInputForm, recipient_models: Sequence[HumanInputFormRecipient]):
+        self._form_model = form_model
+        self._recipients = [_HumanInputFormRecipientEntityImpl(recipient) for recipient in recipient_models]
+        self._web_app_recipient = next(
+            (
+                recipient
+                for recipient in recipient_models
+                if recipient.recipient_type == RecipientType.STANDALONE_WEB_APP
+            ),
+            None,
+        )
+        self._console_recipient = next(
+            (recipient for recipient in recipient_models if recipient.recipient_type == RecipientType.CONSOLE),
+            None,
+        )
+        self._submitted_data: Mapping[str, Any] | None = (
+            json.loads(form_model.submitted_data) if form_model.submitted_data is not None else None
+        )
+
+    @property
+    def id(self) -> str:
+        return self._form_model.id
+
+    @property
+    def web_app_token(self):
+        if self._console_recipient is not None:
+            return self._console_recipient.access_token
+        if self._web_app_recipient is None:
+            return None
+        return self._web_app_recipient.access_token
+
+    @property
+    def recipients(self) -> list[HumanInputFormRecipientEntity]:
+        return list(self._recipients)
+
+    @property
+    def rendered_content(self) -> str:
+        return self._form_model.rendered_content
+
+    @property
+    def selected_action_id(self) -> str | None:
+        return self._form_model.selected_action_id
+
+    @property
+    def submitted_data(self) -> Mapping[str, Any] | None:
+        return self._submitted_data
+
+    @property
+    def submitted(self) -> bool:
+        return self._form_model.submitted_at is not None
+
+    @property
+    def status(self) -> HumanInputFormStatus:
+        return self._form_model.status
+
+    @property
+    def expiration_time(self) -> datetime:
+        return self._form_model.expiration_time
+
+
+@dataclasses.dataclass(frozen=True)
+class HumanInputFormRecord:
+    form_id: str
+    workflow_run_id: str | None
+    node_id: str
+    tenant_id: str
+    app_id: str
+    form_kind: HumanInputFormKind
+    definition: FormDefinition
+    rendered_content: str
+    created_at: datetime
+    expiration_time: datetime
+    status: HumanInputFormStatus
+    selected_action_id: str | None
+    submitted_data: Mapping[str, Any] | None
+    submitted_at: datetime | None
+    submission_user_id: str | None
+    submission_end_user_id: str | None
+    completed_by_recipient_id: str | None
+    recipient_id: str | None
+    recipient_type: RecipientType | None
+    access_token: str | None
+
+    @property
+    def submitted(self) -> bool:
+        return self.submitted_at is not None
+
+    @classmethod
+    def from_models(
+        cls, form_model: HumanInputForm, recipient_model: HumanInputFormRecipient | None
+    ) -> "HumanInputFormRecord":
+        definition_payload = json.loads(form_model.form_definition)
+        if "expiration_time" not in definition_payload:
+            definition_payload["expiration_time"] = form_model.expiration_time
+        return cls(
+            form_id=form_model.id,
+            workflow_run_id=form_model.workflow_run_id,
+            node_id=form_model.node_id,
+            tenant_id=form_model.tenant_id,
+            app_id=form_model.app_id,
+            form_kind=form_model.form_kind,
+            definition=FormDefinition.model_validate(definition_payload),
+            rendered_content=form_model.rendered_content,
+            created_at=form_model.created_at,
+            expiration_time=form_model.expiration_time,
+            status=form_model.status,
+            selected_action_id=form_model.selected_action_id,
+            submitted_data=json.loads(form_model.submitted_data) if form_model.submitted_data else None,
+            submitted_at=form_model.submitted_at,
+            submission_user_id=form_model.submission_user_id,
+            submission_end_user_id=form_model.submission_end_user_id,
+            completed_by_recipient_id=form_model.completed_by_recipient_id,
+            recipient_id=recipient_model.id if recipient_model else None,
+            recipient_type=recipient_model.recipient_type if recipient_model else None,
+            access_token=recipient_model.access_token if recipient_model else None,
+        )
+
+
+class _InvalidTimeoutStatusError(ValueError):
+    pass
+
+
+class HumanInputFormRepositoryImpl:
+    def __init__(
+        self,
+        session_factory: sessionmaker | Engine,
+        tenant_id: str,
+    ):
+        if isinstance(session_factory, Engine):
+            session_factory = sessionmaker(bind=session_factory)
+        self._session_factory = session_factory
+        self._tenant_id = tenant_id
+
+    def _delivery_method_to_model(
+        self,
+        session: Session,
+        form_id: str,
+        delivery_method: DeliveryChannelConfig,
+    ) -> _DeliveryAndRecipients:
+        delivery_id = str(uuidv7())
+        delivery_model = HumanInputDelivery(
+            id=delivery_id,
+            form_id=form_id,
+            delivery_method_type=delivery_method.type,
+            delivery_config_id=delivery_method.id,
+            channel_payload=delivery_method.model_dump_json(),
+        )
+        recipients: list[HumanInputFormRecipient] = []
+        if isinstance(delivery_method, WebAppDeliveryMethod):
+            recipient_model = HumanInputFormRecipient(
+                form_id=form_id,
+                delivery_id=delivery_id,
+                recipient_type=RecipientType.STANDALONE_WEB_APP,
+                recipient_payload=StandaloneWebAppRecipientPayload().model_dump_json(),
+            )
+            recipients.append(recipient_model)
+        elif isinstance(delivery_method, EmailDeliveryMethod):
+            email_recipients_config = delivery_method.config.recipients
+            recipients.extend(
+                self._build_email_recipients(
+                    session=session,
+                    form_id=form_id,
+                    delivery_id=delivery_id,
+                    recipients_config=email_recipients_config,
+                )
+            )
+
+        return _DeliveryAndRecipients(delivery=delivery_model, recipients=recipients)
+
+    def _build_email_recipients(
+        self,
+        session: Session,
+        form_id: str,
+        delivery_id: str,
+        recipients_config: EmailRecipients,
+    ) -> list[HumanInputFormRecipient]:
+        member_user_ids = [
+            recipient.user_id for recipient in recipients_config.items if isinstance(recipient, MemberRecipient)
+        ]
+        external_emails = [
+            recipient.email for recipient in recipients_config.items if isinstance(recipient, ExternalRecipient)
+        ]
+        if recipients_config.whole_workspace:
+            members = self._query_all_workspace_members(session=session)
+        else:
+            members = self._query_workspace_members_by_ids(session=session, restrict_to_user_ids=member_user_ids)
+
+        return self._create_email_recipients_from_resolved(
+            form_id=form_id,
+            delivery_id=delivery_id,
+            members=members,
+            external_emails=external_emails,
+        )
+
+    @staticmethod
+    def _create_email_recipients_from_resolved(
+        *,
+        form_id: str,
+        delivery_id: str,
+        members: Sequence[_WorkspaceMemberInfo],
+        external_emails: Sequence[str],
+    ) -> list[HumanInputFormRecipient]:
+        recipient_models: list[HumanInputFormRecipient] = []
+        seen_emails: set[str] = set()
+
+        for member in members:
+            if not member.email:
+                continue
+            if member.email in seen_emails:
+                continue
+            seen_emails.add(member.email)
+            payload = EmailMemberRecipientPayload(user_id=member.user_id, email=member.email)
+            recipient_models.append(
+                HumanInputFormRecipient.new(
+                    form_id=form_id,
+                    delivery_id=delivery_id,
+                    payload=payload,
+                )
+            )
+
+        for email in external_emails:
+            if not email:
+                continue
+            if email in seen_emails:
+                continue
+            seen_emails.add(email)
+            recipient_models.append(
+                HumanInputFormRecipient.new(
+                    form_id=form_id,
+                    delivery_id=delivery_id,
+                    payload=EmailExternalRecipientPayload(email=email),
+                )
+            )
+
+        return recipient_models
+
+    def _query_all_workspace_members(
+        self,
+        session: Session,
+    ) -> list[_WorkspaceMemberInfo]:
+        stmt = (
+            select(Account.id, Account.email)
+            .join(TenantAccountJoin, TenantAccountJoin.account_id == Account.id)
+            .where(TenantAccountJoin.tenant_id == self._tenant_id)
+        )
+        rows = session.execute(stmt).all()
+        return [_WorkspaceMemberInfo(user_id=account_id, email=email) for account_id, email in rows]
+
+    def _query_workspace_members_by_ids(
+        self,
+        session: Session,
+        restrict_to_user_ids: Sequence[str],
+    ) -> list[_WorkspaceMemberInfo]:
+        unique_ids = {user_id for user_id in restrict_to_user_ids if user_id}
+        if not unique_ids:
+            return []
+
+        stmt = (
+            select(Account.id, Account.email)
+            .join(TenantAccountJoin, TenantAccountJoin.account_id == Account.id)
+            .where(TenantAccountJoin.tenant_id == self._tenant_id)
+        )
+        stmt = stmt.where(Account.id.in_(unique_ids))
+
+        rows = session.execute(stmt).all()
+        return [_WorkspaceMemberInfo(user_id=account_id, email=email) for account_id, email in rows]
+
+    def create_form(self, params: FormCreateParams) -> HumanInputFormEntity:
+        form_config: HumanInputNodeData = params.form_config
+
+        with self._session_factory(expire_on_commit=False) as session, session.begin():
+            # Generate unique form ID
+            form_id = str(uuidv7())
+            start_time = naive_utc_now()
+            node_expiration = form_config.expiration_time(start_time)
+            form_definition = FormDefinition(
+                form_content=form_config.form_content,
+                inputs=form_config.inputs,
+                user_actions=form_config.user_actions,
+                rendered_content=params.rendered_content,
+                expiration_time=node_expiration,
+                default_values=dict(params.resolved_default_values),
+                display_in_ui=params.display_in_ui,
+                node_title=form_config.title,
+            )
+            form_model = HumanInputForm(
+                id=form_id,
+                tenant_id=self._tenant_id,
+                app_id=params.app_id,
+                workflow_run_id=params.workflow_execution_id,
+                form_kind=params.form_kind,
+                node_id=params.node_id,
+                form_definition=form_definition.model_dump_json(),
+                rendered_content=params.rendered_content,
+                expiration_time=node_expiration,
+                created_at=start_time,
+            )
+            session.add(form_model)
+            recipient_models: list[HumanInputFormRecipient] = []
+            for delivery in params.delivery_methods:
+                delivery_and_recipients = self._delivery_method_to_model(
+                    session=session,
+                    form_id=form_id,
+                    delivery_method=delivery,
+                )
+                session.add(delivery_and_recipients.delivery)
+                session.add_all(delivery_and_recipients.recipients)
+                recipient_models.extend(delivery_and_recipients.recipients)
+            if params.console_recipient_required and not any(
+                recipient.recipient_type == RecipientType.CONSOLE for recipient in recipient_models
+            ):
+                console_delivery_id = str(uuidv7())
+                console_delivery = HumanInputDelivery(
+                    id=console_delivery_id,
+                    form_id=form_id,
+                    delivery_method_type=DeliveryMethodType.WEBAPP,
+                    delivery_config_id=None,
+                    channel_payload=ConsoleDeliveryPayload().model_dump_json(),
+                )
+                console_recipient = HumanInputFormRecipient(
+                    form_id=form_id,
+                    delivery_id=console_delivery_id,
+                    recipient_type=RecipientType.CONSOLE,
+                    recipient_payload=ConsoleRecipientPayload(
+                        account_id=params.console_creator_account_id,
+                    ).model_dump_json(),
+                )
+                session.add(console_delivery)
+                session.add(console_recipient)
+                recipient_models.append(console_recipient)
+            if params.backstage_recipient_required and not any(
+                recipient.recipient_type == RecipientType.BACKSTAGE for recipient in recipient_models
+            ):
+                backstage_delivery_id = str(uuidv7())
+                backstage_delivery = HumanInputDelivery(
+                    id=backstage_delivery_id,
+                    form_id=form_id,
+                    delivery_method_type=DeliveryMethodType.WEBAPP,
+                    delivery_config_id=None,
+                    channel_payload=ConsoleDeliveryPayload().model_dump_json(),
+                )
+                backstage_recipient = HumanInputFormRecipient(
+                    form_id=form_id,
+                    delivery_id=backstage_delivery_id,
+                    recipient_type=RecipientType.BACKSTAGE,
+                    recipient_payload=BackstageRecipientPayload(
+                        account_id=params.console_creator_account_id,
+                    ).model_dump_json(),
+                )
+                session.add(backstage_delivery)
+                session.add(backstage_recipient)
+                recipient_models.append(backstage_recipient)
+            session.flush()
+
+        return _HumanInputFormEntityImpl(form_model=form_model, recipient_models=recipient_models)
+
+    def get_form(self, workflow_execution_id: str, node_id: str) -> HumanInputFormEntity | None:
+        form_query = select(HumanInputForm).where(
+            HumanInputForm.workflow_run_id == workflow_execution_id,
+            HumanInputForm.node_id == node_id,
+            HumanInputForm.tenant_id == self._tenant_id,
+        )
+        with self._session_factory(expire_on_commit=False) as session:
+            form_model: HumanInputForm | None = session.scalars(form_query).first()
+            if form_model is None:
+                return None
+
+            recipient_query = select(HumanInputFormRecipient).where(HumanInputFormRecipient.form_id == form_model.id)
+            recipient_models = session.scalars(recipient_query).all()
+        return _HumanInputFormEntityImpl(form_model=form_model, recipient_models=recipient_models)
+
+
+class HumanInputFormSubmissionRepository:
+    """Repository for fetching and submitting human input forms."""
+
+    def __init__(self, session_factory: sessionmaker | Engine):
+        if isinstance(session_factory, Engine):
+            session_factory = sessionmaker(bind=session_factory)
+        self._session_factory = session_factory
+
+    def get_by_token(self, form_token: str) -> HumanInputFormRecord | None:
+        query = (
+            select(HumanInputFormRecipient)
+            .options(selectinload(HumanInputFormRecipient.form))
+            .where(HumanInputFormRecipient.access_token == form_token)
+        )
+        with self._session_factory(expire_on_commit=False) as session:
+            recipient_model = session.scalars(query).first()
+            if recipient_model is None or recipient_model.form is None:
+                return None
+            return HumanInputFormRecord.from_models(recipient_model.form, recipient_model)
+
+    def get_by_form_id_and_recipient_type(
+        self,
+        form_id: str,
+        recipient_type: RecipientType,
+    ) -> HumanInputFormRecord | None:
+        query = (
+            select(HumanInputFormRecipient)
+            .options(selectinload(HumanInputFormRecipient.form))
+            .where(
+                HumanInputFormRecipient.form_id == form_id,
+                HumanInputFormRecipient.recipient_type == recipient_type,
+            )
+        )
+        with self._session_factory(expire_on_commit=False) as session:
+            recipient_model = session.scalars(query).first()
+            if recipient_model is None or recipient_model.form is None:
+                return None
+            return HumanInputFormRecord.from_models(recipient_model.form, recipient_model)
+
+    def mark_submitted(
+        self,
+        *,
+        form_id: str,
+        recipient_id: str | None,
+        selected_action_id: str,
+        form_data: Mapping[str, Any],
+        submission_user_id: str | None,
+        submission_end_user_id: str | None,
+    ) -> HumanInputFormRecord:
+        with self._session_factory(expire_on_commit=False) as session, session.begin():
+            form_model = session.get(HumanInputForm, form_id)
+            if form_model is None:
+                raise FormNotFoundError(f"form not found, id={form_id}")
+
+            recipient_model = session.get(HumanInputFormRecipient, recipient_id) if recipient_id else None
+
+            form_model.selected_action_id = selected_action_id
+            form_model.submitted_data = json.dumps(form_data)
+            form_model.submitted_at = naive_utc_now()
+            form_model.status = HumanInputFormStatus.SUBMITTED
+            form_model.submission_user_id = submission_user_id
+            form_model.submission_end_user_id = submission_end_user_id
+            form_model.completed_by_recipient_id = recipient_id
+
+            session.add(form_model)
+            session.flush()
+            session.refresh(form_model)
+            if recipient_model is not None:
+                session.refresh(recipient_model)
+
+            return HumanInputFormRecord.from_models(form_model, recipient_model)
+
+    def mark_timeout(
+        self,
+        *,
+        form_id: str,
+        timeout_status: HumanInputFormStatus,
+        reason: str | None = None,
+    ) -> HumanInputFormRecord:
+        with self._session_factory(expire_on_commit=False) as session, session.begin():
+            form_model = session.get(HumanInputForm, form_id)
+            if form_model is None:
+                raise FormNotFoundError(f"form not found, id={form_id}")
+
+            if timeout_status not in {HumanInputFormStatus.TIMEOUT, HumanInputFormStatus.EXPIRED}:
+                raise _InvalidTimeoutStatusError(f"invalid timeout status: {timeout_status}")
+
+            # already handled or submitted
+            if form_model.status in {HumanInputFormStatus.TIMEOUT, HumanInputFormStatus.EXPIRED}:
+                return HumanInputFormRecord.from_models(form_model, None)
+
+            if form_model.submitted_at is not None or form_model.status == HumanInputFormStatus.SUBMITTED:
+                raise FormNotFoundError(f"form already submitted, id={form_id}")
+
+            form_model.status = timeout_status
+            form_model.selected_action_id = None
+            form_model.submitted_data = None
+            form_model.submission_user_id = None
+            form_model.submission_end_user_id = None
+            form_model.completed_by_recipient_id = None
+            # Reason is recorded in status/error downstream; not stored on form.
+            session.add(form_model)
+            session.flush()
+            session.refresh(form_model)
+
+            return HumanInputFormRecord.from_models(form_model, None)

api/core/repositories/sqlalchemy_workflow_node_execution_repository.py

@@ -488,6 +488,7 @@ class SQLAlchemyWorkflowNodeExecutionRepository(WorkflowNodeExecutionRepository)
                 WorkflowNodeExecutionModel.workflow_run_id == workflow_run_id,
                 WorkflowNodeExecutionModel.tenant_id == self._tenant_id,
                 WorkflowNodeExecutionModel.triggered_from == triggered_from,
+                WorkflowNodeExecutionModel.status != WorkflowNodeExecutionStatus.PAUSED,
             )
 
             if self._app_id:

api/core/tools/errors.py

@@ -1,4 +1,5 @@
 from core.tools.entities.tool_entities import ToolInvokeMeta
+from libs.exception import BaseHTTPException
 
 
 class ToolProviderNotFoundError(ValueError):
@@ -37,6 +38,12 @@ class ToolCredentialPolicyViolationError(ValueError):
     pass
 
 
+class WorkflowToolHumanInputNotSupportedError(BaseHTTPException):
+    error_code = "workflow_tool_human_input_not_supported"
+    description = "Workflow with Human Input nodes cannot be published as a workflow tool."
+    code = 400
+
+
 class ToolEngineInvokeError(Exception):
     meta: ToolInvokeMeta
 

api/core/tools/mcp_tool/tool.py

@@ -3,8 +3,8 @@ from __future__ import annotations
 import base64
 import json
 import logging
-from collections.abc import Generator
-from typing import Any
+from collections.abc import Generator, Mapping
+from typing import Any, cast
 
 from core.mcp.auth_client import MCPClientWithAuthRetry
 from core.mcp.error import MCPConnectionError
@@ -17,6 +17,7 @@ from core.mcp.types import (
     TextContent,
     TextResourceContents,
 )
+from core.model_runtime.entities.llm_entities import LLMUsage, LLMUsageMetadata
 from core.tools.__base.tool import Tool
 from core.tools.__base.tool_runtime import ToolRuntime
 from core.tools.entities.tool_entities import ToolEntity, ToolInvokeMessage, ToolProviderType
@@ -46,6 +47,7 @@ class MCPTool(Tool):
         self.headers = headers or {}
         self.timeout = timeout
         self.sse_read_timeout = sse_read_timeout
+        self._latest_usage = LLMUsage.empty_usage()
 
     def tool_provider_type(self) -> ToolProviderType:
         return ToolProviderType.MCP
@@ -59,6 +61,10 @@ class MCPTool(Tool):
         message_id: str | None = None,
     ) -> Generator[ToolInvokeMessage, None, None]:
         result = self.invoke_remote_mcp_tool(tool_parameters)
+
+        # Extract usage metadata from MCP protocol's _meta field
+        self._latest_usage = self._derive_usage_from_result(result)
+
         # handle dify tool output
         for content in result.content:
             if isinstance(content, TextContent):
@@ -120,6 +126,99 @@ class MCPTool(Tool):
         for item in json_list:
             yield self.create_json_message(item)
 
+    @property
+    def latest_usage(self) -> LLMUsage:
+        return self._latest_usage
+
+    @classmethod
+    def _derive_usage_from_result(cls, result: CallToolResult) -> LLMUsage:
+        """
+        Extract usage metadata from MCP tool result's _meta field.
+
+        The MCP protocol's _meta field (aliased as 'meta' in Python) can contain
+        usage information such as token counts, costs, and other metadata.
+
+        Args:
+            result: The CallToolResult from MCP tool invocation
+
+        Returns:
+            LLMUsage instance with values from meta or empty_usage if not found
+        """
+        # Extract usage from the meta field if present
+        if result.meta:
+            usage_dict = cls._extract_usage_dict(result.meta)
+            if usage_dict is not None:
+                return LLMUsage.from_metadata(cast(LLMUsageMetadata, cast(object, dict(usage_dict))))
+
+        return LLMUsage.empty_usage()
+
+    @classmethod
+    def _extract_usage_dict(cls, payload: Mapping[str, Any]) -> Mapping[str, Any] | None:
+        """
+        Recursively search for usage dictionary in the payload.
+
+        The MCP protocol's _meta field can contain usage data in various formats:
+        - Direct usage field: {"usage": {...}}
+        - Nested in metadata: {"metadata": {"usage": {...}}}
+        - Or nested within other fields
+
+        Args:
+            payload: The payload to search for usage data
+
+        Returns:
+            The usage dictionary if found, None otherwise
+        """
+        # Check for direct usage field
+        usage_candidate = payload.get("usage")
+        if isinstance(usage_candidate, Mapping):
+            return usage_candidate
+
+        # Check for metadata nested usage
+        metadata_candidate = payload.get("metadata")
+        if isinstance(metadata_candidate, Mapping):
+            usage_candidate = metadata_candidate.get("usage")
+            if isinstance(usage_candidate, Mapping):
+                return usage_candidate
+
+        # Check for common token counting fields directly in payload
+        # Some MCP servers may include token counts directly
+        if "total_tokens" in payload or "prompt_tokens" in payload or "completion_tokens" in payload:
+            usage_dict: dict[str, Any] = {}
+            for key in (
+                "prompt_tokens",
+                "completion_tokens",
+                "total_tokens",
+                "prompt_unit_price",
+                "completion_unit_price",
+                "total_price",
+                "currency",
+                "prompt_price_unit",
+                "completion_price_unit",
+                "prompt_price",
+                "completion_price",
+                "latency",
+                "time_to_first_token",
+                "time_to_generate",
+            ):
+                if key in payload:
+                    usage_dict[key] = payload[key]
+            if usage_dict:
+                return usage_dict
+
+        # Recursively search through nested structures
+        for value in payload.values():
+            if isinstance(value, Mapping):
+                found = cls._extract_usage_dict(value)
+                if found is not None:
+                    return found
+            elif isinstance(value, list) and not isinstance(value, (str, bytes, bytearray)):
+                for item in value:
+                    if isinstance(item, Mapping):
+                        found = cls._extract_usage_dict(item)
+                        if found is not None:
+                            return found
+        return None
+
     def fork_tool_runtime(self, runtime: ToolRuntime) -> MCPTool:
         return MCPTool(
             entity=self.entity,

api/core/tools/utils/workflow_configuration_sync.py

@@ -3,6 +3,8 @@ from typing import Any
 
 from core.app.app_config.entities import VariableEntity
 from core.tools.entities.tool_entities import WorkflowToolParameterConfiguration
+from core.tools.errors import WorkflowToolHumanInputNotSupportedError
+from core.workflow.enums import NodeType
 from core.workflow.nodes.base.entities import OutputVariableEntity
 
 
@@ -45,6 +47,13 @@ class WorkflowToolConfigurationUtils:
 
         return [outputs_by_variable[variable] for variable in variable_order]
 
+    @classmethod
+    def ensure_no_human_input_nodes(cls, graph: Mapping[str, Any]) -> None:
+        nodes = graph.get("nodes", [])
+        for node in nodes:
+            if node.get("data", {}).get("type") == NodeType.HUMAN_INPUT:
+                raise WorkflowToolHumanInputNotSupportedError()
+
     @classmethod
     def check_is_synced(
         cls, variables: list[VariableEntity], tool_configurations: list[WorkflowToolParameterConfiguration]

api/core/tools/workflow_as_tool/tool.py

@@ -98,6 +98,10 @@ class WorkflowTool(Tool):
             invoke_from=self.runtime.invoke_from,
             streaming=False,
             call_depth=self.workflow_call_depth + 1,
+            # NOTE(QuantumGhost): We explicitly set `pause_state_config` to `None`
+            # because workflow pausing mechanisms (such as HumanInput) are not
+            # supported within WorkflowTool execution context.
+            pause_state_config=None,
         )
         assert isinstance(result, dict)
         data = result.get("data", {})

api/core/variables/variables.py

@@ -112,7 +112,7 @@ class ArrayBooleanVariable(ArrayBooleanSegment, ArrayVariable):
 
 class RAGPipelineVariable(BaseModel):
     belong_to_node_id: str = Field(description="belong to which node id, shared means public")
-    type: str = Field(description="variable type, text-input, paragraph, select, number,  file, file-list")
+    type: str = Field(description="variable type, text-input, paragraph, select, number, file, file-list")
     label: str = Field(description="label")
     description: str | None = Field(description="description", default="")
     variable: str = Field(description="variable key", default="")

api/core/workflow/entities/__init__.py

@@ -2,10 +2,12 @@ from .agent import AgentNodeStrategyInit
 from .graph_init_params import GraphInitParams
 from .workflow_execution import WorkflowExecution
 from .workflow_node_execution import WorkflowNodeExecution
+from .workflow_start_reason import WorkflowStartReason
 
 __all__ = [
     "AgentNodeStrategyInit",
     "GraphInitParams",
     "WorkflowExecution",
     "WorkflowNodeExecution",
+    "WorkflowStartReason",
 ]

api/core/workflow/entities/graph_init_params.py

@@ -5,6 +5,16 @@ from pydantic import BaseModel, Field
 
 
 class GraphInitParams(BaseModel):
+    """GraphInitParams encapsulates the configurations and contextual information
+    that remain constant throughout a single execution of the graph engine.
+
+    A single execution is defined as follows: as long as the execution has not reached
+    its conclusion, it is considered one execution. For instance, if a workflow is suspended
+    and later resumed, it is still regarded as a single execution, not two.
+
+    For the state diagram of workflow execution, refer to `WorkflowExecutionStatus`.
+    """
+
     # init params
     tenant_id: str = Field(..., description="tenant / workspace id")
     app_id: str = Field(..., description="app id")

api/core/workflow/entities/pause_reason.py

@@ -1,8 +1,11 @@
+from collections.abc import Mapping
 from enum import StrEnum, auto
-from typing import Annotated, Literal, TypeAlias
+from typing import Annotated, Any, Literal, TypeAlias
 
 from pydantic import BaseModel, Field
 
+from core.workflow.nodes.human_input.entities import FormInput, UserAction
+
 
 class PauseReasonType(StrEnum):
     HUMAN_INPUT_REQUIRED = auto()
@@ -11,10 +14,31 @@ class PauseReasonType(StrEnum):
 
 class HumanInputRequired(BaseModel):
     TYPE: Literal[PauseReasonType.HUMAN_INPUT_REQUIRED] = PauseReasonType.HUMAN_INPUT_REQUIRED
-
     form_id: str
-    # The identifier of the human input node causing the pause.
+    form_content: str
+    inputs: list[FormInput] = Field(default_factory=list)
+    actions: list[UserAction] = Field(default_factory=list)
+    display_in_ui: bool = False
     node_id: str
+    node_title: str
+
+    # The `resolved_default_values` stores the resolved values of variable defaults. It's a mapping from
+    # `output_variable_name` to their resolved values.
+    #
+    # For example, The form contains a input with output variable name `name` and placeholder type `VARIABLE`, its
+    # selector is ["start", "name"]. While the HumanInputNode is executed, the correspond value of variable
+    # `start.name` in variable pool is `John`. Thus, the resolved value of the output variable `name` is `John`. The
+    # `resolved_default_values` is `{"name": "John"}`.
+    #
+    # Only form inputs with default value type `VARIABLE` will be resolved and stored in `resolved_default_values`.
+    resolved_default_values: Mapping[str, Any] = Field(default_factory=dict)
+
+    # The `form_token` is the token used to submit the form via UI surfaces. It corresponds to
+    # `HumanInputFormRecipient.access_token`.
+    #
+    # This field is `None` if webapp delivery is not set and not
+    # in orchestrating mode.
+    form_token: str | None = None
 
 
 class SchedulingPause(BaseModel):

api/core/workflow/entities/workflow_start_reason.py

@@ -0,0 +1,8 @@
+from enum import StrEnum
+
+
+class WorkflowStartReason(StrEnum):
+    """Reason for workflow start events across graph/queue/SSE layers."""
+
+    INITIAL = "initial"  # First start of a workflow run.
+    RESUMPTION = "resumption"  # Start triggered after resuming a paused run.

api/core/workflow/generator/__init__.py

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

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

@@ -1,29 +0,0 @@
-"""
-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

@@ -1,501 +0,0 @@
-"""
-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

@@ -1,72 +0,0 @@
-"""
-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

@@ -1,733 +0,0 @@
-# =============================================================================
-# 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

@@ -1,75 +0,0 @@
-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

@@ -1,349 +0,0 @@
-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

@@ -1,217 +0,0 @@
-"""
-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

@@ -1,384 +0,0 @@
-"""
-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

@@ -1,615 +0,0 @@
-"""
-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

@@ -1,280 +0,0 @@
-"""
-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),
-            },
-        )