chore: auto-dify init commit

Signed-off-by: -LAN- <laipz8200@outlook.com>
Co-authored-by: -LAN- <laipz8200@outlook.com>

api/controllers/console/app/generator.py

@@ -1,4 +1,5 @@
 import os
+from typing import cast
 
 from flask_login import current_user  # type: ignore
 from flask_restful import Resource, reqparse  # type: ignore
@@ -11,8 +12,11 @@ from controllers.console.app.error import (
     ProviderQuotaExceededError,
 )
 from controllers.console.wraps import account_initialization_required, setup_required
+from core.auto.workflow_generator.workflow_generator import WorkflowGenerator
 from core.errors.error import ModelCurrentlyNotSupportError, ProviderTokenNotInitError, QuotaExceededError
 from core.llm_generator.llm_generator import LLMGenerator
+from core.model_manager import ModelManager
+from core.model_runtime.entities.model_entities import ModelType
 from core.model_runtime.errors.invoke import InvokeError
 from libs.login import login_required
 
@@ -85,5 +89,45 @@ class RuleCodeGenerateApi(Resource):
         return code_result
 
 
+class AutoGenerateWorkflowApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    def post(self):
+        """
+        Auto generate workflow
+        """
+
+        parser = reqparse.RequestParser()
+        parser.add_argument("instruction", type=str, required=True, location="json")
+        parser.add_argument("model_config", type=dict, required=True, location="json")
+        tenant_id = cast(str, current_user.current_tenant_id)
+        args = parser.parse_args()
+        instruction = args.get("instruction")
+        if not instruction:
+            raise ValueError("Instruction is required")
+        if not args.get("model_config"):
+            raise ValueError("Model config is required")
+        model_config = cast(dict, args.get("model_config"))
+        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", ""),
+        )
+        workflow_generator = WorkflowGenerator(
+            model_instance=model_instance,
+        )
+        workflow_yaml = workflow_generator.generate_workflow(
+            user_requirement=instruction,
+        )
+        return workflow_yaml
+
+
 api.add_resource(RuleGenerateApi, "/rule-generate")
 api.add_resource(RuleCodeGenerateApi, "/rule-code-generate")
+api.add_resource(
+    AutoGenerateWorkflowApi,
+    "/auto-generate",
+)

api/controllers/console/app/workflow.py

@@ -1,8 +1,10 @@
 import json
 import logging
+from typing import cast
 
 from flask import abort, request
 from flask_restful import Resource, inputs, marshal_with, reqparse  # type: ignore
+from sqlalchemy.orm import Session
 from werkzeug.exceptions import Forbidden, InternalServerError, NotFound
 
 import services
@@ -13,6 +15,7 @@ from controllers.console.app.wraps import get_app_model
 from controllers.console.wraps import account_initialization_required, setup_required
 from core.app.apps.base_app_queue_manager import AppQueueManager
 from core.app.entities.app_invoke_entities import InvokeFrom
+from extensions.ext_database import db
 from factories import variable_factory
 from fields.workflow_fields import workflow_fields, workflow_pagination_fields
 from fields.workflow_run_fields import workflow_run_node_execution_fields
@@ -24,7 +27,7 @@ from models.account import Account
 from models.model import AppMode
 from services.app_generate_service import AppGenerateService
 from services.errors.app import WorkflowHashNotEqualError
-from services.workflow_service import WorkflowService
+from services.workflow_service import DraftWorkflowDeletionError, WorkflowInUseError, WorkflowService
 
 logger = logging.getLogger(__name__)
 
@@ -439,10 +442,38 @@ class PublishedWorkflowApi(Resource):
         if not isinstance(current_user, Account):
             raise Forbidden()
 
-        workflow_service = WorkflowService()
-        workflow = workflow_service.publish_workflow(app_model=app_model, account=current_user)
+        parser = reqparse.RequestParser()
+        parser.add_argument("marked_name", type=str, required=False, default="", location="json")
+        parser.add_argument("marked_comment", type=str, required=False, default="", location="json")
+        args = parser.parse_args()
 
-        return {"result": "success", "created_at": TimestampField().format(workflow.created_at)}
+        # Validate name and comment length
+        if args.marked_name and len(args.marked_name) > 20:
+            raise ValueError("Marked name cannot exceed 20 characters")
+        if args.marked_comment and len(args.marked_comment) > 100:
+            raise ValueError("Marked comment cannot exceed 100 characters")
+
+        workflow_service = WorkflowService()
+        with Session(db.engine) as session:
+            workflow = workflow_service.publish_workflow(
+                session=session,
+                app_model=app_model,
+                account=current_user,
+                marked_name=args.marked_name or "",
+                marked_comment=args.marked_comment or "",
+            )
+
+            app_model.workflow_id = workflow.id
+            db.session.commit()
+
+            workflow_created_at = TimestampField().format(workflow.created_at)
+
+            session.commit()
+
+        return {
+            "result": "success",
+            "created_at": workflow_created_at,
+        }
 
 
 class DefaultBlockConfigsApi(Resource):
@@ -564,37 +595,193 @@ class PublishedAllWorkflowApi(Resource):
         parser = reqparse.RequestParser()
         parser.add_argument("page", type=inputs.int_range(1, 99999), required=False, default=1, location="args")
         parser.add_argument("limit", type=inputs.int_range(1, 100), required=False, default=20, location="args")
+        parser.add_argument("user_id", type=str, required=False, location="args")
+        parser.add_argument("named_only", type=inputs.boolean, required=False, default=False, location="args")
         args = parser.parse_args()
-        page = args.get("page")
-        limit = args.get("limit")
+        page = int(args.get("page", 1))
+        limit = int(args.get("limit", 10))
+        user_id = args.get("user_id")
+        named_only = args.get("named_only", False)
+
+        if user_id:
+            if user_id != current_user.id:
+                raise Forbidden()
+            user_id = cast(str, user_id)
+
         workflow_service = WorkflowService()
-        workflows, has_more = workflow_service.get_all_published_workflow(app_model=app_model, page=page, limit=limit)
+        with Session(db.engine) as session:
+            workflows, has_more = workflow_service.get_all_published_workflow(
+                session=session,
+                app_model=app_model,
+                page=page,
+                limit=limit,
+                user_id=user_id,
+                named_only=named_only,
+            )
 
-        return {"items": workflows, "page": page, "limit": limit, "has_more": has_more}
+            return {
+                "items": workflows,
+                "page": page,
+                "limit": limit,
+                "has_more": has_more,
+            }
 
 
-api.add_resource(DraftWorkflowApi, "/apps/<uuid:app_id>/workflows/draft")
-api.add_resource(WorkflowConfigApi, "/apps/<uuid:app_id>/workflows/draft/config")
-api.add_resource(AdvancedChatDraftWorkflowRunApi, "/apps/<uuid:app_id>/advanced-chat/workflows/draft/run")
-api.add_resource(DraftWorkflowRunApi, "/apps/<uuid:app_id>/workflows/draft/run")
-api.add_resource(WorkflowTaskStopApi, "/apps/<uuid:app_id>/workflow-runs/tasks/<string:task_id>/stop")
-api.add_resource(DraftWorkflowNodeRunApi, "/apps/<uuid:app_id>/workflows/draft/nodes/<string:node_id>/run")
+class WorkflowByIdApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_app_model(mode=[AppMode.ADVANCED_CHAT, AppMode.WORKFLOW])
+    @marshal_with(workflow_fields)
+    def patch(self, app_model: App, workflow_id: str):
+        """
+        Update workflow attributes
+        """
+        # Check permission
+        if not current_user.is_editor:
+            raise Forbidden()
+
+        if not isinstance(current_user, Account):
+            raise Forbidden()
+
+        parser = reqparse.RequestParser()
+        parser.add_argument("marked_name", type=str, required=False, location="json")
+        parser.add_argument("marked_comment", type=str, required=False, location="json")
+        args = parser.parse_args()
+
+        # Validate name and comment length
+        if args.marked_name and len(args.marked_name) > 20:
+            raise ValueError("Marked name cannot exceed 20 characters")
+        if args.marked_comment and len(args.marked_comment) > 100:
+            raise ValueError("Marked comment cannot exceed 100 characters")
+        args = parser.parse_args()
+
+        # Prepare update data
+        update_data = {}
+        if args.get("marked_name") is not None:
+            update_data["marked_name"] = args["marked_name"]
+        if args.get("marked_comment") is not None:
+            update_data["marked_comment"] = args["marked_comment"]
+
+        if not update_data:
+            return {"message": "No valid fields to update"}, 400
+
+        workflow_service = WorkflowService()
+
+        # Create a session and manage the transaction
+        with Session(db.engine, expire_on_commit=False) as session:
+            workflow = workflow_service.update_workflow(
+                session=session,
+                workflow_id=workflow_id,
+                tenant_id=app_model.tenant_id,
+                account_id=current_user.id,
+                data=update_data,
+            )
+
+            if not workflow:
+                raise NotFound("Workflow not found")
+
+            # Commit the transaction in the controller
+            session.commit()
+
+        return workflow
+
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_app_model(mode=[AppMode.ADVANCED_CHAT, AppMode.WORKFLOW])
+    def delete(self, app_model: App, workflow_id: str):
+        """
+        Delete workflow
+        """
+        # Check permission
+        if not current_user.is_editor:
+            raise Forbidden()
+
+        if not isinstance(current_user, Account):
+            raise Forbidden()
+
+        workflow_service = WorkflowService()
+
+        # Create a session and manage the transaction
+        with Session(db.engine) as session:
+            try:
+                workflow_service.delete_workflow(
+                    session=session, workflow_id=workflow_id, tenant_id=app_model.tenant_id
+                )
+                # Commit the transaction in the controller
+                session.commit()
+            except WorkflowInUseError as e:
+                abort(400, description=str(e))
+            except DraftWorkflowDeletionError as e:
+                abort(400, description=str(e))
+            except ValueError as e:
+                raise NotFound(str(e))
+
+        return None, 204
+
+
+api.add_resource(
+    DraftWorkflowApi,
+    "/apps/<uuid:app_id>/workflows/draft",
+)
+api.add_resource(
+    WorkflowConfigApi,
+    "/apps/<uuid:app_id>/workflows/draft/config",
+)
+api.add_resource(
+    AdvancedChatDraftWorkflowRunApi,
+    "/apps/<uuid:app_id>/advanced-chat/workflows/draft/run",
+)
+api.add_resource(
+    DraftWorkflowRunApi,
+    "/apps/<uuid:app_id>/workflows/draft/run",
+)
+api.add_resource(
+    WorkflowTaskStopApi,
+    "/apps/<uuid:app_id>/workflow-runs/tasks/<string:task_id>/stop",
+)
+api.add_resource(
+    DraftWorkflowNodeRunApi,
+    "/apps/<uuid:app_id>/workflows/draft/nodes/<string:node_id>/run",
+)
 api.add_resource(
     AdvancedChatDraftRunIterationNodeApi,
     "/apps/<uuid:app_id>/advanced-chat/workflows/draft/iteration/nodes/<string:node_id>/run",
 )
 api.add_resource(
-    WorkflowDraftRunIterationNodeApi, "/apps/<uuid:app_id>/workflows/draft/iteration/nodes/<string:node_id>/run"
+    WorkflowDraftRunIterationNodeApi,
+    "/apps/<uuid:app_id>/workflows/draft/iteration/nodes/<string:node_id>/run",
 )
 api.add_resource(
     AdvancedChatDraftRunLoopNodeApi,
     "/apps/<uuid:app_id>/advanced-chat/workflows/draft/loop/nodes/<string:node_id>/run",
 )
-api.add_resource(WorkflowDraftRunLoopNodeApi, "/apps/<uuid:app_id>/workflows/draft/loop/nodes/<string:node_id>/run")
-api.add_resource(PublishedWorkflowApi, "/apps/<uuid:app_id>/workflows/publish")
-api.add_resource(PublishedAllWorkflowApi, "/apps/<uuid:app_id>/workflows")
-api.add_resource(DefaultBlockConfigsApi, "/apps/<uuid:app_id>/workflows/default-workflow-block-configs")
 api.add_resource(
-    DefaultBlockConfigApi, "/apps/<uuid:app_id>/workflows/default-workflow-block-configs/<string:block_type>"
+    WorkflowDraftRunLoopNodeApi,
+    "/apps/<uuid:app_id>/workflows/draft/loop/nodes/<string:node_id>/run",
+)
+api.add_resource(
+    PublishedWorkflowApi,
+    "/apps/<uuid:app_id>/workflows/publish",
+)
+api.add_resource(
+    PublishedAllWorkflowApi,
+    "/apps/<uuid:app_id>/workflows",
+)
+api.add_resource(
+    DefaultBlockConfigsApi,
+    "/apps/<uuid:app_id>/workflows/default-workflow-block-configs",
+)
+api.add_resource(
+    DefaultBlockConfigApi,
+    "/apps/<uuid:app_id>/workflows/default-workflow-block-configs/<string:block_type>",
+)
+api.add_resource(
+    ConvertToWorkflowApi,
+    "/apps/<uuid:app_id>/convert-to-workflow",
+)
+api.add_resource(
+    WorkflowByIdApi,
+    "/apps/<uuid:app_id>/workflows/<string:workflow_id>",
 )
-api.add_resource(ConvertToWorkflowApi, "/apps/<uuid:app_id>/convert-to-workflow")

api/controllers/console/app/workflow_app_log.py

@@ -1,13 +1,18 @@
+from datetime import datetime
+
 from flask_restful import Resource, marshal_with, reqparse  # type: ignore
 from flask_restful.inputs import int_range  # type: ignore
+from sqlalchemy.orm import Session
 
 from controllers.console import api
 from controllers.console.app.wraps import get_app_model
 from controllers.console.wraps import account_initialization_required, setup_required
+from extensions.ext_database import db
 from fields.workflow_app_log_fields import workflow_app_log_pagination_fields
 from libs.login import login_required
 from models import App
 from models.model import AppMode
+from models.workflow import WorkflowRunStatus
 from services.workflow_app_service import WorkflowAppService
 
 
@@ -24,17 +29,38 @@ class WorkflowAppLogApi(Resource):
         parser = reqparse.RequestParser()
         parser.add_argument("keyword", type=str, location="args")
         parser.add_argument("status", type=str, choices=["succeeded", "failed", "stopped"], location="args")
+        parser.add_argument(
+            "created_at__before", type=str, location="args", help="Filter logs created before this timestamp"
+        )
+        parser.add_argument(
+            "created_at__after", type=str, location="args", help="Filter logs created after this timestamp"
+        )
         parser.add_argument("page", type=int_range(1, 99999), default=1, location="args")
         parser.add_argument("limit", type=int_range(1, 100), default=20, location="args")
         args = parser.parse_args()
 
+        args.status = WorkflowRunStatus(args.status) if args.status else None
+        if args.created_at__before:
+            args.created_at__before = datetime.fromisoformat(args.created_at__before.replace("Z", "+00:00"))
+
+        if args.created_at__after:
+            args.created_at__after = datetime.fromisoformat(args.created_at__after.replace("Z", "+00:00"))
+
         # get paginate workflow app logs
         workflow_app_service = WorkflowAppService()
-        workflow_app_log_pagination = workflow_app_service.get_paginate_workflow_app_logs(
-            app_model=app_model, args=args
-        )
+        with Session(db.engine) as session:
+            workflow_app_log_pagination = workflow_app_service.get_paginate_workflow_app_logs(
+                session=session,
+                app_model=app_model,
+                keyword=args.keyword,
+                status=args.status,
+                created_at_before=args.created_at__before,
+                created_at_after=args.created_at__after,
+                page=args.page,
+                limit=args.limit,
+            )
 
-        return workflow_app_log_pagination
+            return workflow_app_log_pagination
 
 
 api.add_resource(WorkflowAppLogApi, "/apps/<uuid:app_id>/workflow-app-logs")

api/controllers/service_api/app/workflow.py

@@ -1,7 +1,9 @@
 import logging
+from datetime import datetime
 
 from flask_restful import Resource, fields, marshal_with, reqparse  # type: ignore
 from flask_restful.inputs import int_range  # type: ignore
+from sqlalchemy.orm import Session
 from werkzeug.exceptions import InternalServerError
 
 from controllers.service_api import api
@@ -25,7 +27,7 @@ from extensions.ext_database import db
 from fields.workflow_app_log_fields import workflow_app_log_pagination_fields
 from libs import helper
 from models.model import App, AppMode, EndUser
-from models.workflow import WorkflowRun
+from models.workflow import WorkflowRun, WorkflowRunStatus
 from services.app_generate_service import AppGenerateService
 from services.workflow_app_service import WorkflowAppService
 
@@ -125,17 +127,34 @@ class WorkflowAppLogApi(Resource):
         parser = reqparse.RequestParser()
         parser.add_argument("keyword", type=str, location="args")
         parser.add_argument("status", type=str, choices=["succeeded", "failed", "stopped"], location="args")
+        parser.add_argument("created_at__before", type=str, location="args")
+        parser.add_argument("created_at__after", type=str, location="args")
         parser.add_argument("page", type=int_range(1, 99999), default=1, location="args")
         parser.add_argument("limit", type=int_range(1, 100), default=20, location="args")
         args = parser.parse_args()
 
+        args.status = WorkflowRunStatus(args.status) if args.status else None
+        if args.created_at__before:
+            args.created_at__before = datetime.fromisoformat(args.created_at__before.replace("Z", "+00:00"))
+
+        if args.created_at__after:
+            args.created_at__after = datetime.fromisoformat(args.created_at__after.replace("Z", "+00:00"))
+
         # get paginate workflow app logs
         workflow_app_service = WorkflowAppService()
-        workflow_app_log_pagination = workflow_app_service.get_paginate_workflow_app_logs(
-            app_model=app_model, args=args
-        )
+        with Session(db.engine) as session:
+            workflow_app_log_pagination = workflow_app_service.get_paginate_workflow_app_logs(
+                session=session,
+                app_model=app_model,
+                keyword=args.keyword,
+                status=args.status,
+                created_at_before=args.created_at__before,
+                created_at_after=args.created_at__after,
+                page=args.page,
+                limit=args.limit,
+            )
 
-        return workflow_app_log_pagination
+            return workflow_app_log_pagination
 
 
 api.add_resource(WorkflowRunApi, "/workflows/run")

api/core/auto/config/custom.yaml

@@ -0,0 +1,27 @@
+# 自定义配置文件
+workflow_generator:
+  # 用于生成工作流的模型配置
+  models:
+    default: my-gpt-4o-mini  # 默认使用的模型
+    available:  # 可用的模型列表
+      my-gpt-4o-mini:
+        model_name: gpt-4o-mini
+        base_url: https://api.pandalla.ai/v1
+        key_path: ./openai_key
+        max_tokens: 4096
+      my-gpt-4o:
+        model_name: gpt-4o
+        base_url: https://api.pandalla.ai/v1
+        key_path: ./openai_key
+        max_tokens: 4096
+
+# 调试配置
+debug:
+  enabled: false  # 默认不启用调试模式，可通过命令行参数 --debug 启用
+  dir: debug/     # 调试信息保存目录
+  save_options:   # 调试信息保存选项
+    prompt: true  # 保存提示词
+    response: true  # 保存大模型响应
+    json: true  # 保存JSON解析过程
+    workflow: true  # 保存工作流生成过程
+  case_id_format: "%Y%m%d_%H%M%S_%f"  # 运行ID格式，使用datetime.strftime格式

api/core/auto/config/default.yaml

@@ -0,0 +1,33 @@
+# 默认配置文件
+
+# 工作流生成器配置
+workflow_generator:
+  # 用于生成工作流的模型配置
+  models:
+    default: gpt-4  # 默认使用的模型
+    available:  # 可用的模型列表
+      gpt-4:
+        model_name: gpt-4
+        base_url: https://api.openai.com/v1
+        key_path: ./openai_key
+        max_tokens: 8192
+      gpt-4-turbo:
+        model_name: gpt-4-1106-preview
+        base_url: https://api.openai.com/v1
+        key_path: ./openai_key
+        max_tokens: 4096
+
+# 工作流节点配置
+workflow_nodes:
+  # LLM节点默认配置（使用 Dify 平台配置的模型）
+  llm:
+    provider: zhipuai
+    model: glm-4-flash
+    max_tokens: 16384
+    temperature: 0.7
+    mode: chat
+
+# 输出配置
+output:
+  dir: output/
+  filename: generated_workflow.yml 

api/core/auto/node_types/__init__.py

@@ -0,0 +1,78 @@
+from .agent import AgentNodeType
+from .answer import AnswerNodeType
+from .assigner import AssignerNodeType
+from .code import CodeLanguage, CodeNodeType, OutputVar
+from .common import (
+    BlockEnum,
+    CommonEdgeType,
+    CommonNodeType,
+    CompleteEdge,
+    CompleteNode,
+    Context,
+    InputVar,
+    InputVarType,
+    Memory,
+    ModelConfig,
+    PromptItem,
+    PromptRole,
+    ValueSelector,
+    Variable,
+    VarType,
+    VisionSetting,
+)
+from .end import EndNodeType
+from .http import HttpNodeType
+from .if_else import IfElseNodeType
+from .iteration import IterationNodeType
+from .iteration_start import IterationStartNodeType
+from .knowledge_retrieval import KnowledgeRetrievalNodeType
+from .list_operator import ListFilterNodeType
+from .llm import LLMNodeType, VisionConfig
+from .note_node import NoteNodeType
+from .parameter_extractor import ParameterExtractorNodeType
+from .question_classifier import QuestionClassifierNodeType
+from .start import StartNodeType
+from .template_transform import TemplateTransformNodeType
+from .tool import ToolNodeType
+from .variable_assigner import VariableAssignerNodeType
+
+__all__ = [
+    "AgentNodeType",
+    "AnswerNodeType",
+    "AssignerNodeType",
+    "BlockEnum",
+    "CodeLanguage",
+    "CodeNodeType",
+    "CommonEdgeType",
+    "CommonNodeType",
+    "CompleteEdge",
+    "CompleteNode",
+    "Context",
+    "EndNodeType",
+    "HttpNodeType",
+    "IfElseNodeType",
+    "InputVar",
+    "InputVarType",
+    "IterationNodeType",
+    "IterationStartNodeType",
+    "KnowledgeRetrievalNodeType",
+    "LLMNodeType",
+    "ListFilterNodeType",
+    "Memory",
+    "ModelConfig",
+    "NoteNodeType",
+    "OutputVar",
+    "ParameterExtractorNodeType",
+    "PromptItem",
+    "PromptRole",
+    "QuestionClassifierNodeType",
+    "StartNodeType",
+    "TemplateTransformNodeType",
+    "ToolNodeType",
+    "ValueSelector",
+    "VarType",
+    "Variable",
+    "VariableAssignerNodeType",
+    "VisionConfig",
+    "VisionSetting",
+]

api/core/auto/node_types/agent.py

@@ -0,0 +1,34 @@
+from typing import Any, Optional
+
+from pydantic import BaseModel
+
+from .common import BlockEnum, CommonNodeType
+
+# Introduce previously defined CommonNodeType and ToolVarInputs
+# Assume they are defined in the same module
+
+
+class ToolVarInputs(BaseModel):
+    variable_name: Optional[str] = None
+    default_value: Optional[Any] = None
+
+
+class AgentNodeType(CommonNodeType):
+    agent_strategy_provider_name: Optional[str] = None
+    agent_strategy_name: Optional[str] = None
+    agent_strategy_label: Optional[str] = None
+    agent_parameters: Optional[ToolVarInputs] = None
+    output_schema: dict[str, Any]
+    plugin_unique_identifier: Optional[str] = None
+
+
+# 示例用法
+if __name__ == "__main__":
+    example_node = AgentNodeType(
+        title="Example Agent",
+        desc="An agent node example",
+        type=BlockEnum.agent,
+        output_schema={"key": "value"},
+        agent_parameters=ToolVarInputs(variable_name="example_var", default_value="default"),
+    )
+    print(example_node)

api/core/auto/node_types/answer.py

@@ -0,0 +1,21 @@
+from .common import BlockEnum, CommonNodeType, Variable
+
+
+class AnswerNodeType(CommonNodeType):
+    variables: list[Variable]
+    answer: str
+
+
+# Example usage
+if __name__ == "__main__":
+    example_node = AnswerNodeType(
+        title="Example Answer Node",
+        desc="An answer node example",
+        type=BlockEnum.answer,
+        answer="This is the answer",
+        variables=[
+            Variable(variable="var1", value_selector=["node1", "key1"]),
+            Variable(variable="var2", value_selector=["node2", "key2"]),
+        ],
+    )
+    print(example_node)

api/core/auto/node_types/assigner.py

@@ -0,0 +1,62 @@
+from enum import Enum
+from typing import Any, Optional
+
+from pydantic import BaseModel, Field
+
+from .common import BlockEnum, CommonNodeType
+
+# Import previously defined CommonNodeType and ValueSelector
+# Assume they are defined in the same module
+
+
+class WriteMode(str, Enum):
+    overwrite = "over-write"
+    clear = "clear"
+    append = "append"
+    extend = "extend"
+    set = "set"
+    increment = "+="
+    decrement = "-="
+    multiply = "*="
+    divide = "/="
+
+
+class AssignerNodeInputType(str, Enum):
+    variable = "variable"
+    constant = "constant"
+
+
+class AssignerNodeOperation(BaseModel):
+    variable_selector: Any  # Placeholder for ValueSelector type
+    input_type: AssignerNodeInputType
+    operation: WriteMode
+    value: Any
+
+
+class AssignerNodeType(CommonNodeType):
+    version: Optional[str] = Field(None, pattern="^[12]$")  # Version is '1' or '2'
+    items: list[AssignerNodeOperation]
+
+
+# Example usage
+if __name__ == "__main__":
+    example_node = AssignerNodeType(
+        title="Example Assigner Node",
+        desc="An assigner node example",
+        type=BlockEnum.variable_assigner,
+        items=[
+            AssignerNodeOperation(
+                variable_selector={"nodeId": "node1", "key": "value"},  # Example ValueSelector
+                input_type=AssignerNodeInputType.variable,
+                operation=WriteMode.set,
+                value="newValue",
+            ),
+            AssignerNodeOperation(
+                variable_selector={"nodeId": "node2", "key": "value"},
+                input_type=AssignerNodeInputType.constant,
+                operation=WriteMode.increment,
+                value=1,
+            ),
+        ],
+    )
+    print(example_node)

api/core/auto/node_types/code.py

@@ -0,0 +1,56 @@
+from enum import Enum
+from typing import Optional
+
+from pydantic import BaseModel
+
+from core.auto.node_types.common import BlockEnum, CommonNodeType, Variable, VarType
+
+# 引入之前定义的 CommonNodeType、VarType 和 Variable
+# 假设它们在同一模块中定义
+
+
+class CodeLanguage(str, Enum):
+    python3 = "python3"
+    javascript = "javascript"
+    json = "json"
+
+
+class OutputVar(BaseModel):
+    type: VarType
+    children: Optional[None] = None  # 未来支持嵌套
+
+    def dict(self, *args, **kwargs):
+        """自定义序列化方法，确保正确序列化"""
+        result = {"type": self.type.value if isinstance(self.type, Enum) else self.type}
+
+        if self.children is not None:
+            result["children"] = self.children
+
+        return result
+
+
+class CodeNodeType(CommonNodeType):
+    variables: list[Variable]
+    code_language: CodeLanguage
+    code: str
+    outputs: dict[str, OutputVar]
+
+
+# 示例用法
+if __name__ == "__main__":
+    # 创建示例节点
+    example_node = CodeNodeType(
+        title="Example Code Node",
+        desc="A code node example",
+        type=BlockEnum.code,
+        code_language=CodeLanguage.python3,
+        code="print('Hello, World!')",
+        outputs={
+            "output1": OutputVar(type=VarType.string),
+            "output2": OutputVar(type=VarType.number),
+        },
+        variables=[
+            Variable(variable="var1", value_selector=["node1", "key1"]),
+        ],
+    )
+    print(example_node.get_all_required_fields())

api/core/auto/node_types/common.py

@@ -0,0 +1,690 @@
+from enum import Enum
+from typing import Any, Optional, Union
+
+import yaml
+from pydantic import BaseModel, Field
+
+
+# BlockEnum 枚举
+class BlockEnum(str, Enum):
+    start = "start"
+    end = "end"
+    answer = "answer"
+    llm = "llm"
+    knowledge_retrieval = "knowledge-retrieval"
+    question_classifier = "question-classifier"
+    if_else = "if-else"
+    code = "code"
+    template_transform = "template-transform"
+    http_request = "http-request"
+    variable_assigner = "variable-assigner"
+    variable_aggregator = "variable-aggregator"
+    tool = "tool"
+    parameter_extractor = "parameter-extractor"
+    iteration = "iteration"
+    document_extractor = "document-extractor"
+    list_operator = "list-operator"
+    iteration_start = "iteration-start"
+    assigner = "assigner"  # is now named as VariableAssigner
+    agent = "agent"
+
+
+# Error枚举
+class ErrorHandleMode(str, Enum):
+    terminated = "terminated"
+    continue_on_error = "continue-on-error"
+    remove_abnormal_output = "remove-abnormal-output"
+
+
+class ErrorHandleTypeEnum(str, Enum):
+    none = ("none",)
+    failBranch = ("fail-branch",)
+    defaultValue = ("default-value",)
+
+
+# Branch 类型
+class Branch(BaseModel):
+    id: str
+    name: str
+
+
+# NodeRunningStatus 枚举
+class NodeRunningStatus(str, Enum):
+    not_start = "not-start"
+    waiting = "waiting"
+    running = "running"
+    succeeded = "succeeded"
+    failed = "failed"
+    exception = "exception"
+    retry = "retry"
+
+
+# 创建一个基类来统一CommonNodeType和CommonEdgeType的序列化逻辑
+class BaseType(BaseModel):
+    """基类，用于统一CommonNodeType和CommonEdgeType的序列化逻辑"""
+
+    def to_json(self) -> dict[str, Any]:
+        """
+        将对象转换为JSON格式的字典,通过循环模型字段来构建JSON数据
+        """
+        json_data = {}
+
+        # 获取模型的所有字段
+        for field_name, field_value in self.__dict__.items():
+            if field_value is not None:
+                # 特殊处理Branch类型的列表
+                if field_name == "_targetBranches" and field_value is not None:
+                    json_data[field_name] = [branch.dict(exclude_none=True) for branch in field_value]
+                # 处理枚举类型
+                elif isinstance(field_value, Enum):
+                    json_data[field_name] = field_value.value
+                # 处理嵌套的Pydantic模型
+                elif hasattr(field_value, "dict") and callable(field_value.dict):
+                    json_data[field_name] = field_value.dict(exclude_none=True)
+                # 处理列表中的Pydantic模型
+                elif isinstance(field_value, list):
+                    processed_list = []
+                    for item in field_value:
+                        if hasattr(item, "dict") and callable(item.dict):
+                            processed_list.append(item.dict(exclude_none=True))
+                        else:
+                            processed_list.append(item)
+                    json_data[field_name] = processed_list
+                # 处理字典中的Pydantic模型
+                elif isinstance(field_value, dict):
+                    processed_dict = {}
+                    for key, value in field_value.items():
+                        if hasattr(value, "dict") and callable(value.dict):
+                            processed_dict[key] = value.dict(exclude_none=True)
+                        else:
+                            processed_dict[key] = value
+                    json_data[field_name] = processed_dict
+                # 其他字段直接添加
+                else:
+                    json_data[field_name] = field_value
+
+        return json_data
+
+
+# CommonNodeType 类型
+class CommonNodeType(BaseType):
+    _connectedSourceHandleIds: Optional[list[str]] = None
+    _connectedTargetHandleIds: Optional[list[str]] = None
+    _targetBranches: Optional[list[Branch]] = None
+    _isSingleRun: Optional[bool] = None
+    _runningStatus: Optional[NodeRunningStatus] = None
+    _singleRunningStatus: Optional[NodeRunningStatus] = None
+    _isCandidate: Optional[bool] = None
+    _isBundled: Optional[bool] = None
+    _children: Optional[list[str]] = None
+    _isEntering: Optional[bool] = None
+    _showAddVariablePopup: Optional[bool] = None
+    _holdAddVariablePopup: Optional[bool] = None
+    _iterationLength: Optional[int] = None
+    _iterationIndex: Optional[int] = None
+    _inParallelHovering: Optional[bool] = None
+    isInIteration: Optional[bool] = None
+    iteration_id: Optional[str] = None
+    selected: Optional[bool] = None
+    title: str
+    desc: str
+    type: BlockEnum
+    width: Optional[float] = None
+    height: Optional[float] = None
+
+    @classmethod
+    def get_all_required_fields(cls) -> dict[str, str]:
+        """
+        获取所有必选字段，包括从父类继承的字段
+        这是一个类方法，可以通过类直接调用
+        """
+        all_required_fields = {}
+
+        # 获取所有父类（除了 object 和 BaseModel）
+        mro = [c for c in cls.__mro__ if c not in (object, BaseModel, BaseType)]
+
+        # 从父类到子类的顺序处理，这样子类的字段会覆盖父类的同名字段
+        for class_type in reversed(mro):
+            if hasattr(class_type, "__annotations__"):
+                for field_name, field_info in class_type.__annotations__.items():
+                    # 检查字段是否有默认值
+                    has_default = hasattr(class_type, field_name)
+                    # 检查字段是否为可选类型
+                    is_optional = "Optional" in str(field_info)
+
+                    # 如果字段没有默认值且不是Optional类型，则为必选字段
+                    if not has_default and not is_optional:
+                        all_required_fields[field_name] = str(field_info)
+
+        return all_required_fields
+
+
+# CommonEdgeType 类型
+class CommonEdgeType(BaseType):
+    _hovering: Optional[bool] = None
+    _connectedNodeIsHovering: Optional[bool] = None
+    _connectedNodeIsSelected: Optional[bool] = None
+    _run: Optional[bool] = None
+    _isBundled: Optional[bool] = None
+    isInIteration: Optional[bool] = None
+    iteration_id: Optional[str] = None
+    sourceType: BlockEnum
+    targetType: BlockEnum
+
+
+class ValueSelector(BaseModel):
+    """Value selector for selecting values from other nodes."""
+
+    value: list[str] = Field(default_factory=list)
+
+    def dict(self, *args, **kwargs):
+        """自定义序列化方法，直接返回 value 列表"""
+        return self.value
+
+
+# Add Context class for LLM node
+class Context(BaseModel):
+    """Context configuration for LLM node."""
+
+    enabled: bool = False
+    variable_selector: Optional[ValueSelector] = None
+
+    def dict(self, *args, **kwargs):
+        """自定义序列化方法，确保 variable_selector 字段正确序列化"""
+        result = {"enabled": self.enabled}
+
+        if self.variable_selector:
+            result["variable_selector"] = self.variable_selector.dict()
+        else:
+            result["variable_selector"] = []
+
+        return result
+
+
+# Variable 类型
+class Variable(BaseModel):
+    """
+    变量类型，用于定义节点的输入/输出变量
+    与Dify中的Variable类型保持一致
+    """
+
+    variable: str  # 变量名
+    label: Optional[Union[str, dict[str, str]]] = None  # 变量标签，可以是字符串或对象
+    value_selector: list[str]  # 变量值选择器，格式为[nodeId, key]
+    variable_type: Optional[str] = None  # 变量类型，对应Dify中的VarType枚举
+    value: Optional[str] = None  # 变量值（常量值）
+    options: Optional[list[str]] = None  # 选项列表（用于select类型）
+    required: Optional[bool] = None  # 是否必填
+    isParagraph: Optional[bool] = None  # 是否为段落
+    max_length: Optional[int] = None  # 最大长度
+
+    def dict(self, *args, **kwargs):
+        """自定义序列化方法，确保正确序列化"""
+        result = {"variable": self.variable}
+
+        if self.label is not None:
+            result["label"] = self.label
+
+        if self.value_selector:
+            result["value_selector"] = self.value_selector
+
+        if self.variable_type is not None:
+            result["type"] = self.variable_type  # 使用type而不是variable_type，与Dify保持一致
+
+        if self.value is not None:
+            result["value"] = self.value
+
+        if self.options is not None:
+            result["options"] = self.options
+
+        if self.required is not None:
+            result["required"] = self.required
+
+        if self.isParagraph is not None:
+            result["isParagraph"] = self.isParagraph
+
+        if self.max_length is not None:
+            result["max_length"] = self.max_length
+
+        return result
+
+
+# EnvironmentVariable 类型
+class EnvironmentVariable(BaseModel):
+    id: str
+    name: str
+    value: Any
+    value_type: str  # Expecting to be either 'string', 'number', or 'secret'
+
+
+# ConversationVariable 类型
+class ConversationVariable(BaseModel):
+    id: str
+    name: str
+    value_type: str
+    value: Any
+    description: str
+
+
+# GlobalVariable 类型
+class GlobalVariable(BaseModel):
+    name: str
+    value_type: str  # Expecting to be either 'string' or 'number'
+    description: str
+
+
+# VariableWithValue 类型
+class VariableWithValue(BaseModel):
+    key: str
+    value: str
+
+
+# InputVarType 枚举
+class InputVarType(str, Enum):
+    text_input = "text-input"
+    paragraph = "paragraph"
+    select = "select"
+    number = "number"
+    url = "url"
+    files = "files"
+    json = "json"
+    contexts = "contexts"
+    iterator = "iterator"
+    file = "file"
+    file_list = "file-list"
+
+
+# InputVar 类型
+class InputVar(BaseModel):
+    type: InputVarType
+    label: Union[str, dict[str, Any]]  # 可以是字符串或对象
+    variable: str
+    max_length: Optional[int] = None
+    default: Optional[str] = None
+    required: bool
+    hint: Optional[str] = None
+    options: Optional[list[str]] = None
+    value_selector: Optional[list[str]] = None
+
+    def dict(self, *args, **kwargs):
+        """自定义序列化方法，确保正确序列化"""
+        result = {
+            "type": self.type.value if isinstance(self.type, Enum) else self.type,
+            "label": self.label,
+            "variable": self.variable,
+            "required": self.required,
+        }
+
+        if self.max_length is not None:
+            result["max_length"] = self.max_length
+
+        if self.default is not None:
+            result["default"] = self.default
+
+        if self.hint is not None:
+            result["hint"] = self.hint
+
+        if self.options is not None:
+            result["options"] = self.options
+
+        if self.value_selector is not None:
+            result["value_selector"] = self.value_selector
+
+        return result
+
+
+# ModelConfig 类型
+class ModelConfig(BaseModel):
+    provider: str
+    name: str
+    mode: str
+    completion_params: dict[str, Any]
+
+
+# PromptRole 枚举
+class PromptRole(str, Enum):
+    system = "system"
+    user = "user"
+    assistant = "assistant"
+
+
+# EditionType 枚举
+class EditionType(str, Enum):
+    basic = "basic"
+    jinja2 = "jinja2"
+
+
+# PromptItem 类型
+class PromptItem(BaseModel):
+    id: Optional[str] = None
+    role: Optional[PromptRole] = None
+    text: str
+    edition_type: Optional[EditionType] = None
+    jinja2_text: Optional[str] = None
+
+    def dict(self, *args, **kwargs):
+        """自定义序列化方法，确保 role 字段正确序列化"""
+        result = {"id": self.id, "text": self.text}
+
+        if self.role:
+            result["role"] = self.role.value
+
+        if self.edition_type:
+            result["edition_type"] = self.edition_type.value
+
+        if self.jinja2_text:
+            result["jinja2_text"] = self.jinja2_text
+
+        return result
+
+
+# MemoryRole 枚举
+class MemoryRole(str, Enum):
+    user = "user"
+    assistant = "assistant"
+
+
+# RolePrefix 类型
+class RolePrefix(BaseModel):
+    user: str
+    assistant: str
+
+
+# Memory 类型
+class Memory(BaseModel):
+    role_prefix: Optional[RolePrefix] = None
+    window: dict[str, Any]  # Expecting to have 'enabled' and 'size'
+    query_prompt_template: str
+
+
+# VarType 枚举
+class VarType(str, Enum):
+    string = "string"
+    number = "number"
+    secret = "secret"
+    boolean = "boolean"
+    object = "object"
+    file = "file"
+    array = "array"
+    arrayString = "array[string]"
+    arrayNumber = "array[number]"
+    arrayObject = "array[object]"
+    arrayFile = "array[file]"
+    any = "any"
+
+
+# Var 类型
+class Var(BaseModel):
+    variable: str
+    type: VarType
+    children: Optional[list["Var"]] = None  # Self-reference
+    isParagraph: Optional[bool] = None
+    isSelect: Optional[bool] = None
+    options: Optional[list[str]] = None
+    required: Optional[bool] = None
+    des: Optional[str] = None
+    isException: Optional[bool] = None
+
+    def dict(self, *args, **kwargs):
+        """自定义序列化方法，确保type字段正确序列化"""
+        result = {"variable": self.variable, "type": self.type.value if isinstance(self.type, Enum) else self.type}
+
+        if self.children is not None:
+            result["children"] = [child.dict() for child in self.children]
+
+        if self.isParagraph is not None:
+            result["isParagraph"] = self.isParagraph
+
+        if self.isSelect is not None:
+            result["isSelect"] = self.isSelect
+
+        if self.options is not None:
+            result["options"] = self.options
+
+        if self.required is not None:
+            result["required"] = self.required
+
+        if self.des is not None:
+            result["des"] = self.des
+
+        if self.isException is not None:
+            result["isException"] = self.isException
+
+        return result
+
+
+# NodeOutPutVar 类型
+class NodeOutPutVar(BaseModel):
+    nodeId: str
+    title: str
+    vars: list[Var]
+    isStartNode: Optional[bool] = None
+
+
+# Block 类型
+class Block(BaseModel):
+    classification: Optional[str] = None
+    type: BlockEnum
+    title: str
+    description: Optional[str] = None
+
+
+# NodeDefault 类型
+class NodeDefault(BaseModel):
+    defaultValue: dict[str, Any]
+    getAvailablePrevNodes: Any  # Placeholder for function reference
+    getAvailableNextNodes: Any  # Placeholder for function reference
+    checkValid: Any  # Placeholder for function reference
+
+
+# OnSelectBlock 类型
+class OnSelectBlock(BaseModel):
+    nodeType: BlockEnum
+    additional_data: Optional[dict[str, Any]] = None
+
+
+# WorkflowRunningStatus 枚举
+class WorkflowRunningStatus(str, Enum):
+    waiting = "waiting"
+    running = "running"
+    succeeded = "succeeded"
+    failed = "failed"
+    stopped = "stopped"
+
+
+# WorkflowVersion 枚举
+class WorkflowVersion(str, Enum):
+    draft = "draft"
+    latest = "latest"
+
+
+# OnNodeAdd 类型
+class OnNodeAdd(BaseModel):
+    nodeType: BlockEnum
+    sourceHandle: Optional[str] = None
+    targetHandle: Optional[str] = None
+    toolDefaultValue: Optional[dict[str, Any]] = None
+
+
+# CheckValidRes 类型
+class CheckValidRes(BaseModel):
+    isValid: bool
+    errorMessage: Optional[str] = None
+
+
+# RunFile 类型
+class RunFile(BaseModel):
+    type: str
+    transfer_method: list[str]
+    url: Optional[str] = None
+    upload_file_id: Optional[str] = None
+
+
+# WorkflowRunningData 类型
+class WorkflowRunningData(BaseModel):
+    task_id: Optional[str] = None
+    message_id: Optional[str] = None
+    conversation_id: Optional[str] = None
+    result: dict[str, Any]  # Expecting a structured object
+    tracing: Optional[list[dict[str, Any]]] = None  # Placeholder for NodeTracing
+
+
+# HistoryWorkflowData 类型
+class HistoryWorkflowData(BaseModel):
+    id: str
+    sequence_number: int
+    status: str
+    conversation_id: Optional[str] = None
+
+
+# ChangeType 枚举
+class ChangeType(str, Enum):
+    changeVarName = "changeVarName"
+    remove = "remove"
+
+
+# MoreInfo 类型
+class MoreInfo(BaseModel):
+    type: ChangeType
+    payload: Optional[dict[str, Any]] = None
+
+
+# ToolWithProvider 类型
+class ToolWithProvider(BaseModel):
+    tools: list[dict[str, Any]]  # Placeholder for Tool type
+
+
+# SupportUploadFileTypes 枚举
+class SupportUploadFileTypes(str, Enum):
+    image = "image"
+    document = "document"
+    audio = "audio"
+    video = "video"
+    custom = "custom"
+
+
+# UploadFileSetting 类型
+class UploadFileSetting(BaseModel):
+    allowed_file_upload_methods: list[str]
+    allowed_file_types: list[SupportUploadFileTypes]
+    allowed_file_extensions: Optional[list[str]] = None
+    max_length: int
+    number_limits: Optional[int] = None
+
+
+# VisionSetting 类型
+class VisionSetting(BaseModel):
+    variable_selector: list[str]
+    detail: dict[str, Any]  # Placeholder for Resolution type
+
+
+# 创建一个基类来统一序列化逻辑
+class CompleteBase(BaseModel):
+    """基类，用于统一CompleteNode和CompleteEdge的序列化逻辑"""
+
+    def to_json(self):
+        """将对象转换为JSON格式的字典"""
+        json_data = {}
+
+        # 获取模型的所有字段
+        for field_name, field_value in self.__dict__.items():
+            if field_value is not None:
+                # 处理嵌套的数据对象
+                if field_name == "data" and hasattr(field_value, "to_json"):
+                    json_data[field_name] = field_value.to_json()
+                # 处理枚举类型
+                elif isinstance(field_value, Enum):
+                    json_data[field_name] = field_value.value
+                # 处理嵌套的Pydantic模型
+                elif hasattr(field_value, "dict") and callable(field_value.dict):
+                    json_data[field_name] = field_value.dict(exclude_none=True)
+                # 处理列表中的Pydantic模型
+                elif isinstance(field_value, list):
+                    processed_list = []
+                    for item in field_value:
+                        if hasattr(item, "dict") and callable(item.dict):
+                            processed_list.append(item.dict(exclude_none=True))
+                        else:
+                            processed_list.append(item)
+                    json_data[field_name] = processed_list
+                # 处理字典中的Pydantic模型
+                elif isinstance(field_value, dict):
+                    processed_dict = {}
+                    for key, value in field_value.items():
+                        if hasattr(value, "dict") and callable(value.dict):
+                            processed_dict[key] = value.dict(exclude_none=True)
+                        else:
+                            processed_dict[key] = value
+                    json_data[field_name] = processed_dict
+                # 其他字段直接添加
+                else:
+                    json_data[field_name] = field_value
+
+        return json_data
+
+    def to_yaml(self):
+        """将对象转换为YAML格式的字符串"""
+        return yaml.dump(self.to_json(), allow_unicode=True)
+
+
+class CompleteNode(CompleteBase):
+    id: str
+    position: dict
+    height: int
+    width: float
+    positionAbsolute: dict
+    selected: bool
+    sourcePosition: Union[dict, str]
+    targetPosition: Union[dict, str]
+    type: str
+    data: Optional[Union[CommonNodeType, None]] = None  # Flexible field to store CommonNodeType or None
+
+    def add_data(self, data: Union[CommonNodeType, None]):
+        self.data = data
+
+    def to_json(self):
+        json_data = super().to_json()
+
+        # 特殊处理sourcePosition和targetPosition
+        json_data["sourcePosition"] = "right"  # 直接输出为字符串"right"
+        json_data["targetPosition"] = "left"  # 直接输出为字符串"left"
+
+        # 确保 width 是整数而不是浮点数
+        if isinstance(json_data["width"], float):
+            json_data["width"] = int(json_data["width"])
+
+        return json_data
+
+
+class CompleteEdge(CompleteBase):
+    id: str
+    source: str
+    sourceHandle: str
+    target: str
+    targetHandle: str
+    type: str
+    zIndex: int
+    data: Optional[Union[CommonEdgeType, None]] = None  # Flexible field to store CommonEdgeType or None
+
+    def add_data(self, data: Union[CommonEdgeType, None]):
+        self.data = data
+
+
+# 示例用法
+if __name__ == "__main__":
+    # 这里可以添加示例数据进行验证
+    common_node = CompleteNode(
+        id="1740019130520",
+        position={"x": 80, "y": 282},
+        height=100,
+        width=100,
+        positionAbsolute={"x": 80, "y": 282},
+        selected=True,
+        sourcePosition={"x": 80, "y": 282},
+        targetPosition={"x": 80, "y": 282},
+        type="custom",
+    )
+    common_data = CommonNodeType(title="示例节点", desc="这是一个示例节点", type="")
+    print(CommonNodeType.get_all_required_fields())
+    common_node.add_data(common_data)
+    # print(common_node)

api/core/auto/node_types/end.py

@@ -0,0 +1,22 @@
+from .common import BlockEnum, CommonNodeType, Variable
+
+# Import previously defined CommonNodeType and Variable
+# Assume they are defined in the same module
+
+
+class EndNodeType(CommonNodeType):
+    outputs: list[Variable]
+
+
+# Example usage
+if __name__ == "__main__":
+    example_node = EndNodeType(
+        title="Example End Node",
+        desc="An end node example",
+        type=BlockEnum.end,
+        outputs=[
+            Variable(variable="outputVar1", value_selector=["node1", "key1"]),
+            Variable(variable="outputVar2", value_selector=["node2", "key2"]),
+        ],
+    )
+    print(example_node)

api/core/auto/node_types/http.py

@@ -0,0 +1,127 @@
+from enum import Enum
+from typing import Optional, Union
+
+from pydantic import BaseModel
+
+from .common import BlockEnum, CommonNodeType, ValueSelector, Variable
+
+# Import previously defined CommonNodeType, ValueSelector, and Variable
+# Assume they are defined in the same module
+
+
+class Method(str, Enum):
+    """HTTP request methods."""
+
+    get = "get"
+    post = "post"
+    head = "head"
+    patch = "patch"
+    put = "put"
+    delete = "delete"
+
+
+class BodyType(str, Enum):
+    """HTTP request body types."""
+
+    none = "none"
+    formData = "form-data"
+    xWwwFormUrlencoded = "x-www-form-urlencoded"
+    rawText = "raw-text"
+    json = "json"
+    binary = "binary"
+
+
+class BodyPayloadValueType(str, Enum):
+    """Types of values in body payload."""
+
+    text = "text"
+    file = "file"
+
+
+class BodyPayload(BaseModel):
+    """Body payload item for HTTP requests."""
+
+    id: Optional[str] = None
+    key: Optional[str] = None
+    type: BodyPayloadValueType
+    file: Optional[ValueSelector] = None  # Used when type is file
+    value: Optional[str] = None  # Used when type is text
+
+
+class Body(BaseModel):
+    """HTTP request body configuration."""
+
+    type: BodyType
+    data: Union[str, list[BodyPayload]]  # string is deprecated, will convert to BodyPayload
+
+
+class AuthorizationType(str, Enum):
+    """HTTP authorization types."""
+
+    none = "no-auth"
+    apiKey = "api-key"
+
+
+class APIType(str, Enum):
+    """API key types."""
+
+    basic = "basic"
+    bearer = "bearer"
+    custom = "custom"
+
+
+class AuthConfig(BaseModel):
+    """Authorization configuration."""
+
+    type: APIType
+    api_key: str
+    header: Optional[str] = None
+
+
+class Authorization(BaseModel):
+    """HTTP authorization settings."""
+
+    type: AuthorizationType
+    config: Optional[AuthConfig] = None
+
+
+class Timeout(BaseModel):
+    """HTTP request timeout settings."""
+
+    connect: Optional[int] = None
+    read: Optional[int] = None
+    write: Optional[int] = None
+    max_connect_timeout: Optional[int] = None
+    max_read_timeout: Optional[int] = None
+    max_write_timeout: Optional[int] = None
+
+
+class HttpNodeType(CommonNodeType):
+    """HTTP request node type implementation."""
+
+    variables: list[Variable]
+    method: Method
+    url: str
+    headers: str
+    params: str
+    body: Body
+    authorization: Authorization
+    timeout: Timeout
+
+
+# Example usage
+if __name__ == "__main__":
+    example_node = HttpNodeType(
+        title="Example HTTP Node",
+        desc="An HTTP request node example",
+        type=BlockEnum.http_request,
+        variables=[Variable(variable="var1", value_selector=["node1", "key1"])],
+        method=Method.get,
+        url="https://api.example.com/data",
+        headers="{}",
+        params="{}",
+        body=Body(type=BodyType.none, data=[]),
+        authorization=Authorization(type=AuthorizationType.none),
+        timeout=Timeout(connect=30, read=30, write=30),
+    )
+    print(example_node)

api/core/auto/node_types/if_else.py

@@ -0,0 +1,99 @@
+from enum import Enum
+from typing import Optional, Union
+
+from pydantic import BaseModel
+
+from .common import BlockEnum, CommonNodeType, ValueSelector, VarType
+from .tool import VarType as NumberVarType
+
+# Import previously defined CommonNodeType, ValueSelector, Var, and VarType
+# Assume they are defined in the same module
+
+
+class LogicalOperator(str, Enum):
+    and_ = "and"
+    or_ = "or"
+
+
+class ComparisonOperator(str, Enum):
+    contains = "contains"
+    notContains = "not contains"
+    startWith = "start with"
+    endWith = "end with"
+    is_ = "is"
+    isNot = "is not"
+    empty = "empty"
+    notEmpty = "not empty"
+    equal = "="
+    notEqual = "≠"
+    largerThan = ">"
+    lessThan = "<"
+    largerThanOrEqual = "≥"
+    lessThanOrEqual = "≤"
+    isNull = "is null"
+    isNotNull = "is not null"
+    in_ = "in"
+    notIn = "not in"
+    allOf = "all of"
+    exists = "exists"
+    notExists = "not exists"
+    equals = "="  # Alias for equal for compatibility
+
+
+class Condition(BaseModel):
+    id: str
+    varType: VarType
+    variable_selector: Optional[ValueSelector]
+    key: Optional[str] = None  # Sub variable key
+    comparison_operator: Optional[ComparisonOperator] = None
+    value: Union[str, list[str]]
+    numberVarType: Optional[NumberVarType]
+    sub_variable_condition: Optional["CaseItem"] = None  # Recursive reference
+
+
+class CaseItem(BaseModel):
+    case_id: str
+    logical_operator: LogicalOperator
+    conditions: list[Condition]
+
+
+class IfElseNodeType(CommonNodeType):
+    logical_operator: Optional[LogicalOperator] = None
+    conditions: Optional[list[Condition]] = None
+    cases: list[CaseItem]
+    isInIteration: bool
+
+
+# Example usage
+if __name__ == "__main__":
+    example_node = IfElseNodeType(
+        title="Example IfElse Node",
+        desc="An if-else node example",
+        type=BlockEnum.if_else,
+        logical_operator=LogicalOperator.and_,
+        conditions=[
+            Condition(
+                id="condition1",
+                varType=VarType.string,
+                variable_selector={"nodeId": "varNode", "key": "value"},
+                comparison_operator=ComparisonOperator.is_,
+                value="exampleValue",
+            )
+        ],
+        cases=[
+            CaseItem(
+                case_id="case1",
+                logical_operator=LogicalOperator.or_,
+                conditions=[
+                    Condition(
+                        id="condition2",
+                        varType=VarType.number,
+                        value="10",
+                        comparison_operator=ComparisonOperator.largerThan,
+                    )
+                ],
+            )
+        ],
+        isInIteration=True,
+    )
+    print(example_node)

api/core/auto/node_types/iteration.py

@@ -0,0 +1,45 @@
+from enum import Enum
+from typing import Optional
+
+from .common import BlockEnum, CommonNodeType, ValueSelector, VarType
+
+
+class ErrorHandleMode(str, Enum):
+    """Error handling modes for iteration."""
+
+    terminated = "terminated"
+    continue_on_error = "continue-on-error"
+    remove_abnormal_output = "remove-abnormal-output"
+
+
+class IterationNodeType(CommonNodeType):
+    """Iteration node type implementation."""
+
+    startNodeType: Optional[BlockEnum] = None
+    start_node_id: str  # Start node ID in the iteration
+    iteration_id: Optional[str] = None
+    iterator_selector: ValueSelector
+    output_selector: ValueSelector
+    output_type: VarType  # Output type
+    is_parallel: bool  # Open the parallel mode or not
+    parallel_nums: int  # The numbers of parallel
+    error_handle_mode: ErrorHandleMode  # How to handle error in the iteration
+    _isShowTips: bool  # Show tips when answer node in parallel mode iteration
+
+
+# 示例用法
+if __name__ == "__main__":
+    example_node = IterationNodeType(
+        title="Example Iteration Node",
+        desc="An iteration node example",
+        type=BlockEnum.iteration,
+        start_node_id="startNode1",
+        iterator_selector=ValueSelector(value=["iteratorNode", "value"]),
+        output_selector=ValueSelector(value=["outputNode", "value"]),
+        output_type=VarType.string,
+        is_parallel=True,
+        parallel_nums=5,
+        error_handle_mode=ErrorHandleMode.continue_on_error,
+        _isShowTips=True,
+    )
+    print(example_node)

api/core/auto/node_types/iteration_start.py

@@ -0,0 +1,25 @@
+from .common import BlockEnum, CommonNodeType
+
+# 引入之前定义的 CommonNodeType
+# 假设它们在同一模块中定义
+
+
+class IterationStartNodeType(CommonNodeType):
+    """
+    Iteration Start node type implementation.
+
+    This node type is used as the starting point within an iteration block.
+    It inherits all properties from CommonNodeType without adding any additional fields.
+    """
+
+    pass  # 仅仅继承 CommonNodeType，无其他字段
+
+
+# 示例用法
+if __name__ == "__main__":
+    example_node = IterationStartNodeType(
+        title="Example Iteration Start Node",
+        desc="An iteration start node example",
+        type=BlockEnum.iteration_start,
+    )
+    print(example_node)

api/core/auto/node_types/knowledge_retrieval.py

@@ -0,0 +1,115 @@
+from enum import Enum
+from typing import Optional
+
+from pydantic import BaseModel
+
+from .common import BlockEnum, CommonNodeType, ModelConfig, ValueSelector
+
+
+class RetrieveType(str, Enum):
+    """Retrieval mode types."""
+
+    single = "single"
+    multiple = "multiple"
+
+
+class RerankingModeEnum(str, Enum):
+    """Reranking mode types."""
+
+    simple = "simple"
+    advanced = "advanced"
+
+
+class VectorSetting(BaseModel):
+    """Vector weight settings."""
+
+    vector_weight: float
+    embedding_provider_name: str
+    embedding_model_name: str
+
+
+class KeywordSetting(BaseModel):
+    """Keyword weight settings."""
+
+    keyword_weight: float
+
+
+class Weights(BaseModel):
+    """Weight configuration for retrieval."""
+
+    vector_setting: VectorSetting
+    keyword_setting: KeywordSetting
+
+
+class RerankingModel(BaseModel):
+    """Reranking model configuration."""
+
+    provider: str
+    model: str
+
+
+class MultipleRetrievalConfig(BaseModel):
+    """Configuration for multiple retrieval mode."""
+
+    top_k: int
+    score_threshold: Optional[float] = None
+    reranking_model: Optional[RerankingModel] = None
+    reranking_mode: Optional[RerankingModeEnum] = None
+    weights: Optional[Weights] = None
+    reranking_enable: Optional[bool] = None
+
+
+class SingleRetrievalConfig(BaseModel):
+    """Configuration for single retrieval mode."""
+
+    model: ModelConfig
+
+
+class DataSet(BaseModel):
+    """Dataset information."""
+
+    id: str
+    name: str
+    description: Optional[str] = None
+
+
+class KnowledgeRetrievalNodeType(CommonNodeType):
+    """Knowledge retrieval node type implementation."""
+
+    query_variable_selector: ValueSelector
+    dataset_ids: list[str]
+    retrieval_mode: RetrieveType
+    multiple_retrieval_config: Optional[MultipleRetrievalConfig] = None
+    single_retrieval_config: Optional[SingleRetrievalConfig] = None
+    _datasets: Optional[list[DataSet]] = None
+
+
+# Example usage
+if __name__ == "__main__":
+    example_node = KnowledgeRetrievalNodeType(
+        title="Example Knowledge Retrieval Node",
+        desc="A knowledge retrieval node example",
+        type=BlockEnum.knowledge_retrieval,
+        query_variable_selector=ValueSelector(value=["queryNode", "query"]),
+        dataset_ids=["dataset1", "dataset2"],
+        retrieval_mode=RetrieveType.multiple,
+        multiple_retrieval_config=MultipleRetrievalConfig(
+            top_k=10,
+            score_threshold=0.5,
+            reranking_model=RerankingModel(provider="example_provider", model="example_model"),
+            reranking_mode=RerankingModeEnum.simple,
+            weights=Weights(
+                vector_setting=VectorSetting(
+                    vector_weight=0.7, embedding_provider_name="provider1", embedding_model_name="model1"
+                ),
+                keyword_setting=KeywordSetting(keyword_weight=0.3),
+            ),
+            reranking_enable=True,
+        ),
+        single_retrieval_config=SingleRetrievalConfig(
+            model=ModelConfig(
+                provider="example_provider", name="example_model", mode="chat", completion_params={"temperature": 0.7}
+            )
+        ),
+    )
+    print(example_node)

api/core/auto/node_types/list_operator.py

@@ -0,0 +1,73 @@
+from enum import Enum
+from typing import Optional, Union
+
+from pydantic import BaseModel
+
+from .common import BlockEnum, CommonNodeType, ValueSelector, VarType
+
+# Import ComparisonOperator from if_else.py
+from .if_else import ComparisonOperator
+
+
+class OrderBy(str, Enum):
+    ASC = "asc"
+    DESC = "desc"
+
+
+class Limit(BaseModel):
+    enabled: bool
+    size: Optional[int] = None
+
+
+class Condition(BaseModel):
+    key: str
+    comparison_operator: ComparisonOperator
+    value: Union[str, int, list[str]]
+
+
+class FilterBy(BaseModel):
+    enabled: bool
+    conditions: list[Condition]
+
+
+class ExtractBy(BaseModel):
+    enabled: bool
+    serial: Optional[str] = None
+
+
+class OrderByConfig(BaseModel):
+    enabled: bool
+    key: Union[ValueSelector, str]
+    value: OrderBy
+
+
+class ListFilterNodeType(CommonNodeType):
+    """List filter/operator node type implementation."""
+
+    variable: ValueSelector
+    var_type: VarType
+    item_var_type: VarType
+    filter_by: FilterBy
+    extract_by: ExtractBy
+    order_by: OrderByConfig
+    limit: Limit
+
+
+# 示例用法
+if __name__ == "__main__":
+    example_node = ListFilterNodeType(
+        title="Example List Filter Node",
+        desc="A list filter node example",
+        type=BlockEnum.list_operator,  # Fixed: use list_operator instead of list_filter
+        variable=ValueSelector(value=["varNode", "value"]),
+        var_type=VarType.string,
+        item_var_type=VarType.number,
+        filter_by=FilterBy(
+            enabled=True,
+            conditions=[Condition(key="status", comparison_operator=ComparisonOperator.equals, value="active")],
+        ),
+        extract_by=ExtractBy(enabled=True, serial="serial_1"),
+        order_by=OrderByConfig(enabled=True, key="created_at", value=OrderBy.DESC),
+        limit=Limit(enabled=True, size=100),
+    )
+    print(example_node)

api/core/auto/node_types/llm.py

@@ -0,0 +1,66 @@
+from typing import Optional, Union
+
+from pydantic import BaseModel
+
+from .common import (
+    BlockEnum,
+    CommonNodeType,
+    Context,
+    Memory,
+    ModelConfig,
+    PromptItem,
+    Variable,
+    VisionSetting,
+)
+
+
+class PromptConfig(BaseModel):
+    """Configuration for prompt template variables."""
+
+    jinja2_variables: Optional[list[Variable]] = None
+
+
+class VisionConfig(BaseModel):
+    """Configuration for vision settings."""
+
+    enabled: bool = False
+    configs: Optional[VisionSetting] = None
+
+    def dict(self, *args, **kwargs):
+        """自定义序列化方法，确保正确序列化"""
+        result = {"enabled": self.enabled}
+
+        if self.configs:
+            result["configs"] = self.configs.dict()
+
+        return result
+
+
+class LLMNodeType(CommonNodeType):
+    """LLM node type implementation."""
+
+    model: ModelConfig
+    prompt_template: Union[list[PromptItem], PromptItem]
+    prompt_config: Optional[PromptConfig] = None
+    memory: Optional[Memory] = None
+    context: Optional[Context] = Context(enabled=False, variable_selector=None)
+    vision: Optional[VisionConfig] = VisionConfig(enabled=False)
+
+
+# 示例用法
+if __name__ == "__main__":
+    example_node = LLMNodeType(
+        title="Example LLM Node",
+        desc="A LLM node example",
+        type=BlockEnum.llm,
+        model=ModelConfig(provider="zhipuai", name="glm-4-flash", mode="chat", completion_params={"temperature": 0.7}),
+        prompt_template=[
+            PromptItem(
+                id="system-id", role="system", text="你是一个代码工程师，你会根据用户的需求给出用户所需要的函数"
+            ),
+            PromptItem(id="user-id", role="user", text="给出两数相加的python 函数代码，函数名 func 不要添加其他内容"),
+        ],
+        context=Context(enabled=False, variable_selector=None),
+        vision=VisionConfig(enabled=False),
+    )
+    print(example_node)

api/core/auto/node_types/note_node.py

@@ -0,0 +1,38 @@
+from enum import Enum
+
+from .common import BlockEnum, CommonNodeType
+
+# Import previously defined CommonNodeType
+# Assume it is defined in the same module
+
+
+class NoteTheme(str, Enum):
+    blue = "blue"
+    cyan = "cyan"
+    green = "green"
+    yellow = "yellow"
+    pink = "pink"
+    violet = "violet"
+
+
+class NoteNodeType(CommonNodeType):
+    """Custom note node type implementation."""
+
+    text: str
+    theme: NoteTheme
+    author: str
+    showAuthor: bool
+
+
+# Example usage
+if __name__ == "__main__":
+    example_node = NoteNodeType(
+        title="Example Note Node",
+        desc="A note node example",
+        type=BlockEnum.custom_note,
+        text="This is a note.",
+        theme=NoteTheme.green,
+        author="John Doe",
+        showAuthor=True,
+    )
+    print(example_node)

api/core/auto/node_types/parameter_extractor.py

@@ -0,0 +1,85 @@
+from enum import Enum
+from typing import Optional
+
+from pydantic import BaseModel
+
+from .common import BlockEnum, CommonNodeType, Memory, ModelConfig, ValueSelector, VisionSetting
+
+# Import previously defined CommonNodeType, Memory, ModelConfig, ValueSelector, and VisionSetting
+# Assume they are defined in the same module
+
+
+class ParamType(str, Enum):
+    """Parameter types for extraction."""
+
+    string = "string"
+    number = "number"
+    bool = "bool"
+    select = "select"
+    arrayString = "array[string]"
+    arrayNumber = "array[number]"
+    arrayObject = "array[object]"
+
+
+class Param(BaseModel):
+    """Parameter definition for extraction."""
+
+    name: str
+    type: ParamType
+    options: Optional[list[str]] = None
+    description: str
+    required: Optional[bool] = None
+
+
+class ReasoningModeType(str, Enum):
+    """Reasoning mode types for parameter extraction."""
+
+    prompt = "prompt"
+    functionCall = "function_call"
+
+
+class VisionConfig(BaseModel):
+    """Vision configuration."""
+
+    enabled: bool
+    configs: Optional[VisionSetting] = None
+
+
+class ParameterExtractorNodeType(CommonNodeType):
+    """Parameter extractor node type implementation."""
+
+    model: ModelConfig
+    query: ValueSelector
+    reasoning_mode: ReasoningModeType
+    parameters: List[Param]
+    instruction: str
+    memory: Optional[Memory] = None
+    vision: VisionConfig
+
+
+# Example usage
+if __name__ == "__main__":
+    example_node = ParameterExtractorNodeType(
+        title="Example Parameter Extractor Node",
+        desc="A parameter extractor node example",
+        type=BlockEnum.parameter_extractor,
+        model=ModelConfig(
+            provider="example_provider", name="example_model", mode="chat", completion_params={"temperature": 0.7}
+        ),
+        query=ValueSelector(value=["queryNode", "value"]),
+        reasoning_mode=ReasoningModeType.prompt,
+        parameters=[
+            Param(name="param1", type=ParamType.string, description="This is a string parameter", required=True),
+            Param(
+                name="param2",
+                type=ParamType.number,
+                options=["1", "2", "3"],
+                description="This is a number parameter",
+                required=False,
+            ),
+        ],
+        instruction="Please extract the parameters from the input.",
+        memory=Memory(window={"enabled": True, "size": 10}, query_prompt_template="Extract parameters from: {{query}}"),
+        vision=VisionConfig(enabled=True, configs={"setting": "example_setting"}),
+    )
+    print(example_node)

api/core/auto/node_types/question_classifier.py

@@ -0,0 +1,51 @@
+from typing import Optional
+
+from pydantic import BaseModel
+
+from .common import BlockEnum, CommonNodeType, Memory, ModelConfig, ValueSelector, VisionSetting
+
+# Import previously defined CommonNodeType, Memory, ModelConfig, ValueSelector, and VisionSetting
+# Assume they are defined in the same module
+
+
+class Topic(BaseModel):
+    """Topic for classification."""
+
+    id: str
+    name: str
+
+
+class VisionConfig(BaseModel):
+    """Vision configuration."""
+
+    enabled: bool
+    configs: Optional[VisionSetting] = None
+
+
+class QuestionClassifierNodeType(CommonNodeType):
+    """Question classifier node type implementation."""
+
+    query_variable_selector: ValueSelector
+    model: ModelConfig
+    classes: list[Topic]
+    instruction: str
+    memory: Optional[Memory] = None
+    vision: VisionConfig
+
+
+# Example usage
+if __name__ == "__main__":
+    example_node = QuestionClassifierNodeType(
+        title="Example Question Classifier Node",
+        desc="A question classifier node example",
+        type=BlockEnum.question_classifier,
+        query_variable_selector=ValueSelector(value=["queryNode", "value"]),
+        model=ModelConfig(
+            provider="example_provider", name="example_model", mode="chat", completion_params={"temperature": 0.7}
+        ),
+        classes=[Topic(id="1", name="Science"), Topic(id="2", name="Mathematics"), Topic(id="3", name="Literature")],
+        instruction="Classify the given question into the appropriate topic.",
+        memory=Memory(window={"enabled": True, "size": 10}, query_prompt_template="Classify this question: {{query}}"),
+        vision=VisionConfig(enabled=True, configs={"setting": "example_setting"}),
+    )
+    print(example_node)

api/core/auto/node_types/start.py

@@ -0,0 +1,22 @@
+from .common import BlockEnum, CommonNodeType, InputVar
+
+# Import previously defined CommonNodeType and InputVar
+# Assume they are defined in the same module
+
+
+class StartNodeType(CommonNodeType):
+    variables: list[InputVar]
+
+
+# Example usage
+if __name__ == "__main__":
+    example_node = StartNodeType(
+        title="Example Start Node",
+        desc="A start node example",
+        type=BlockEnum.start,
+        variables=[
+            InputVar(type="text-input", label="Input 1", variable="input1", required=True),
+            InputVar(type="number", label="Input 2", variable="input2", required=True),
+        ],
+    )
+    print(example_node)

api/core/auto/node_types/template_transform.py

@@ -0,0 +1,26 @@
+from .common import BlockEnum, CommonNodeType, Variable
+
+# 引入之前定义的 CommonNodeType 和 Variable
+# 假设它们在同一模块中定义
+
+
+class TemplateTransformNodeType(CommonNodeType):
+    """Template transform node type implementation."""
+
+    variables: list[Variable]
+    template: str
+
+
+# 示例用法
+if __name__ == "__main__":
+    example_node = TemplateTransformNodeType(
+        title="Example Template Transform Node",
+        desc="A template transform node example",
+        type=BlockEnum.template_transform,
+        variables=[
+            Variable(variable="var1", value_selector=["node1", "key1"]),
+            Variable(variable="var2", value_selector=["node2", "key2"]),
+        ],
+        template="Hello, {{ var1 }}! You have {{ var2 }} new messages.",
+    )
+    print(example_node)

api/core/auto/node_types/tool.py

@@ -0,0 +1,54 @@
+from enum import Enum
+from typing import Any, Optional, Union
+
+from pydantic import BaseModel
+
+from .common import BlockEnum, CommonNodeType, ValueSelector
+
+# Import previously defined CommonNodeType and ValueSelector
+# Assume they are defined in the same module
+
+
+class VarType(str, Enum):
+    variable = "variable"
+    constant = "constant"
+    mixed = "mixed"
+
+
+class ToolVarInputs(BaseModel):
+    type: VarType
+    value: Optional[Union[str, ValueSelector, Any]] = None
+
+
+class ToolNodeType(CommonNodeType):
+    """Tool node type implementation."""
+
+    provider_id: str
+    provider_type: Any  # Placeholder for CollectionType
+    provider_name: str
+    tool_name: str
+    tool_label: str
+    tool_parameters: dict[str, ToolVarInputs]
+    tool_configurations: dict[str, Any]
+    output_schema: dict[str, Any]
+
+
+# Example usage
+if __name__ == "__main__":
+    example_node = ToolNodeType(
+        title="Example Tool Node",
+        desc="A tool node example",
+        type=BlockEnum.tool,
+        provider_id="12345",
+        provider_type="some_collection_type",  # Placeholder for CollectionType
+        provider_name="Example Provider",
+        tool_name="Example Tool",
+        tool_label="Example Tool Label",
+        tool_parameters={
+            "input1": ToolVarInputs(type=VarType.variable, value="some_value"),
+            "input2": ToolVarInputs(type=VarType.constant, value="constant_value"),
+        },
+        tool_configurations={"config1": "value1", "config2": {"nested": "value2"}},
+        output_schema={"output1": "string", "output2": "number"},
+    )
+    print(example_node.json(indent=2))  # Print as JSON format for viewing

api/core/auto/node_types/variable_assigner.py

@@ -0,0 +1,56 @@
+from pydantic import BaseModel
+
+from .common import BlockEnum, CommonNodeType, ValueSelector, VarType
+
+
+class VarGroupItem(BaseModel):
+    """Variable group item configuration."""
+
+    output_type: VarType
+    variables: list[ValueSelector]
+
+
+class GroupConfig(VarGroupItem):
+    """Group configuration for advanced settings."""
+
+    group_name: str
+    groupId: str
+
+
+class AdvancedSettings(BaseModel):
+    """Advanced settings for variable assigner."""
+
+    group_enabled: bool
+    groups: list[GroupConfig]
+
+
+class VariableAssignerNodeType(CommonNodeType, VarGroupItem):
+    """Variable assigner node type implementation."""
+
+    advanced_settings: AdvancedSettings
+
+    class Config:
+        arbitrary_types_allowed = True
+
+
+# Example usage
+if __name__ == "__main__":
+    example_node = VariableAssignerNodeType(
+        title="Example Variable Assigner Node",
+        desc="A variable assigner node example",
+        type=BlockEnum.variable_assigner,
+        output_type=VarType.string,
+        variables=[ValueSelector(value=["varNode1", "value1"]), ValueSelector(value=["varNode2", "value2"])],
+        advanced_settings=AdvancedSettings(
+            group_enabled=True,
+            groups=[
+                GroupConfig(
+                    group_name="Group 1",
+                    groupId="group1",
+                    output_type=VarType.number,
+                    variables=[ValueSelector(value=["varNode3", "value3"])],
+                )
+            ],
+        ),
+    )
+    print(example_node.json(indent=2))  # Print as JSON format for viewing

api/core/auto/output/emotion_analysis_workflow.yml

@@ -0,0 +1,239 @@
+app:
+  description: ''
+  icon: 🤖
+  icon_background: '#FFEAD5'
+  mode: workflow
+  name: 情绪分析工作流
+  use_icon_as_answer_icon: false
+kind: app
+version: 0.1.2
+workflow:
+  conversation_variables: []
+  environment_variables: []
+  features:
+    file_upload:
+      allowed_file_extensions:
+      - .JPG
+      - .JPEG
+      - .PNG
+      - .GIF
+      - .WEBP
+      - .SVG
+      allowed_file_types:
+      - image
+      allowed_file_upload_methods:
+      - local_file
+      - remote_url
+      enabled: false
+      fileUploadConfig:
+        audio_file_size_limit: 50
+        batch_count_limit: 5
+        file_size_limit: 15
+        image_file_size_limit: 10
+        video_file_size_limit: 100
+      image:
+        enabled: false
+        number_limits: 3
+        transfer_methods:
+        - local_file
+        - remote_url
+      number_limits: 3
+    opening_statement: ''
+    retriever_resource:
+      enabled: true
+    sensitive_word_avoidance:
+      enabled: false
+    speech_to_text:
+      enabled: false
+    suggested_questions: []
+    suggested_questions_after_answer:
+      enabled: false
+    text_to_speech:
+      enabled: false
+      language: ''
+      voice: ''
+  graph:
+    edges:
+    - id: 1740019130520-source-1740019130521-target
+      source: '1740019130520'
+      sourceHandle: source
+      target: '1740019130521'
+      targetHandle: target
+      type: custom
+      zIndex: 0
+      data:
+        isInIteration: false
+        sourceType: start
+        targetType: llm
+    - id: 1740019130521-source-1740019130522-target
+      source: '1740019130521'
+      sourceHandle: source
+      target: '1740019130522'
+      targetHandle: target
+      type: custom
+      zIndex: 0
+      data:
+        isInIteration: false
+        sourceType: llm
+        targetType: code
+    - id: 1740019130522-source-1740019130523-target
+      source: '1740019130522'
+      sourceHandle: source
+      target: '1740019130523'
+      targetHandle: target
+      type: custom
+      zIndex: 0
+      data:
+        isInIteration: false
+        sourceType: code
+        targetType: template-transform
+    - id: 1740019130523-source-1740019130524-target
+      source: '1740019130523'
+      sourceHandle: source
+      target: '1740019130524'
+      targetHandle: target
+      type: custom
+      zIndex: 0
+      data:
+        isInIteration: false
+        sourceType: template-transform
+        targetType: end
+    nodes:
+    - id: '1740019130520'
+      position:
+        x: 80
+        y: 282
+      height: 116
+      width: 244
+      positionAbsolute:
+        x: 80
+        y: 282
+      selected: false
+      sourcePosition: right
+      targetPosition: left
+      type: custom
+      data:
+        title: 开始节点
+        desc: 开始节点，接收用户输入的文本。
+        type: start
+        variables:
+        - type: text-input
+          label: input_text
+          variable: input_text
+          required: true
+          max_length: 48
+          options: []
+    - id: '1740019130521'
+      position:
+        x: 380
+        y: 282
+      height: 98
+      width: 244
+      positionAbsolute:
+        x: 380
+        y: 282
+      selected: false
+      sourcePosition: right
+      targetPosition: left
+      type: custom
+      data:
+        title: LLM节点
+        desc: LLM节点分析文本情绪，识别出积极、消极或中性情绪。
+        type: llm
+        model:
+          provider: zhipuai
+          name: glm-4-flash
+          mode: chat
+          completion_params:
+            temperature: 0.7
+        prompt_template:
+        - id: 1740019130521-system
+          text: 请分析以下文本的情绪，并返回情绪类型（积极、消极或中性）。
+          role: system
+        - id: 1740019130521-user
+          text: 分析此文本的情绪：{{input_text}}
+          role: user
+        context:
+          enabled: false
+          variable_selector: []
+        vision:
+          enabled: false
+    - id: '1740019130522'
+      position:
+        x: 680
+        y: 282
+      height: 54
+      width: 244
+      positionAbsolute:
+        x: 680
+        y: 282
+      selected: false
+      sourcePosition: right
+      targetPosition: left
+      type: custom
+      data:
+        title: 代码节点
+        desc: 代码节点将根据LLM分析的结果处理情绪类型。
+        type: code
+        variables:
+        - variable: emotion
+          value_selector:
+          - '1740019130521'
+          - emotion
+        code_language: python3
+        code: "def analyze_sentiment(emotion):\n    if emotion == 'positive':\n  \
+          \      return '积极'\n    elif emotion == 'negative':\n        return '消极'\n\
+          \    else:\n        return '中性'\n\nemotion = '{{emotion}}'\nresult = analyze_sentiment(emotion)\n\
+          return {'result': result}"
+        outputs:
+          sentiment_result:
+            type: string
+    - id: '1740019130523'
+      position:
+        x: 980
+        y: 282
+      height: 54
+      width: 244
+      positionAbsolute:
+        x: 980
+        y: 282
+      selected: false
+      sourcePosition: right
+      targetPosition: left
+      type: custom
+      data:
+        title: 模板节点
+        desc: 模板节点将情绪分析结果格式化输出。
+        type: template-transform
+        variables:
+        - variable: sentiment_result
+          value_selector:
+          - '1740019130522'
+          - sentiment_result
+        template: 文本的情绪分析结果为：{{sentiment_result}}
+    - id: '1740019130524'
+      position:
+        x: 1280
+        y: 282
+      height: 90
+      width: 244
+      positionAbsolute:
+        x: 1280
+        y: 282
+      selected: false
+      sourcePosition: right
+      targetPosition: left
+      type: custom
+      data:
+        title: 结束节点
+        desc: 结束节点，返回格式化后的情绪分析结果。
+        type: end
+        outputs:
+        - variable: output
+          value_selector:
+          - '1740019130523'
+          - output
+    viewport:
+      x: 92.96659905656679
+      y: 79.13437154762897
+      zoom: 0.9002006986311041

api/core/auto/output/test_workflow.yml

@@ -0,0 +1,247 @@
+app:
+  description: ''
+  icon: 🤖
+  icon_background: '#FFEAD5'
+  mode: workflow
+  name: 计算两个数字之和
+  use_icon_as_answer_icon: false
+kind: app
+version: 0.1.2
+workflow:
+  conversation_variables: []
+  environment_variables: []
+  features:
+    file_upload:
+      allowed_file_extensions:
+      - .JPG
+      - .JPEG
+      - .PNG
+      - .GIF
+      - .WEBP
+      - .SVG
+      allowed_file_types:
+      - image
+      allowed_file_upload_methods:
+      - local_file
+      - remote_url
+      enabled: false
+      fileUploadConfig:
+        audio_file_size_limit: 50
+        batch_count_limit: 5
+        file_size_limit: 15
+        image_file_size_limit: 10
+        video_file_size_limit: 100
+      image:
+        enabled: false
+        number_limits: 3
+        transfer_methods:
+        - local_file
+        - remote_url
+      number_limits: 3
+    opening_statement: ''
+    retriever_resource:
+      enabled: true
+    sensitive_word_avoidance:
+      enabled: false
+    speech_to_text:
+      enabled: false
+    suggested_questions: []
+    suggested_questions_after_answer:
+      enabled: false
+    text_to_speech:
+      enabled: false
+      language: ''
+      voice: ''
+  graph:
+    edges:
+    - id: 1740019130520-source-1740019130521-target
+      source: '1740019130520'
+      sourceHandle: source
+      target: '1740019130521'
+      targetHandle: target
+      type: custom
+      zIndex: 0
+      data:
+        isInIteration: false
+        sourceType: start
+        targetType: llm
+    - id: 1740019130521-source-1740019130522-target
+      source: '1740019130521'
+      sourceHandle: source
+      target: '1740019130522'
+      targetHandle: target
+      type: custom
+      zIndex: 0
+      data:
+        isInIteration: false
+        sourceType: llm
+        targetType: code
+    - id: 1740019130522-source-1740019130523-target
+      source: '1740019130522'
+      sourceHandle: source
+      target: '1740019130523'
+      targetHandle: target
+      type: custom
+      zIndex: 0
+      data:
+        isInIteration: false
+        sourceType: code
+        targetType: template-transform
+    - id: 1740019130523-source-1740019130524-target
+      source: '1740019130523'
+      sourceHandle: source
+      target: '1740019130524'
+      targetHandle: target
+      type: custom
+      zIndex: 0
+      data:
+        isInIteration: false
+        sourceType: template-transform
+        targetType: end
+    nodes:
+    - id: '1740019130520'
+      position:
+        x: 80
+        y: 282
+      height: 116
+      width: 244
+      positionAbsolute:
+        x: 80
+        y: 282
+      selected: false
+      sourcePosition: right
+      targetPosition: left
+      type: custom
+      data:
+        title: 开始节点
+        desc: 开始节点，接收两个数字输入参数。
+        type: start
+        variables:
+        - type: number
+          label: num1
+          variable: num1
+          required: true
+          max_length: 48
+          options: []
+        - type: number
+          label: num2
+          variable: num2
+          required: true
+          max_length: 48
+          options: []
+    - id: '1740019130521'
+      position:
+        x: 380
+        y: 282
+      height: 98
+      width: 244
+      positionAbsolute:
+        x: 380
+        y: 282
+      selected: false
+      sourcePosition: right
+      targetPosition: left
+      type: custom
+      data:
+        title: LLM节点
+        desc: LLM节点，根据输入的两个数字生成计算它们之和的Python函数。
+        type: llm
+        model:
+          provider: openai
+          name: gpt-4
+          mode: chat
+          completion_params:
+            temperature: 0.7
+        prompt_template:
+        - id: 1740019130521-system
+          text: 你是一个Python开发助手，请根据以下输入生成一个计算两数之和的Python函数。
+          role: system
+        - id: 1740019130521-user
+          text: 请为两个数字{{num1}}和{{num2}}生成一个Python函数，计算它们的和。
+          role: user
+        context:
+          enabled: false
+          variable_selector: []
+        vision:
+          enabled: false
+    - id: '1740019130522'
+      position:
+        x: 680
+        y: 282
+      height: 54
+      width: 244
+      positionAbsolute:
+        x: 680
+        y: 282
+      selected: false
+      sourcePosition: right
+      targetPosition: left
+      type: custom
+      data:
+        title: 代码节点
+        desc: 代码节点，执行LLM生成的Python函数，并计算结果。
+        type: code
+        variables:
+        - variable: num1
+          value_selector:
+          - '1740019130520'
+          - num1
+        - variable: num2
+          value_selector:
+          - '1740019130520'
+          - num2
+        code_language: python3
+        code: "def calculate_sum(num1, num2):\n    return num1 + num2\n\nresult =\
+          \ calculate_sum({{num1}}, {{num2}})\nreturn result"
+        outputs:
+          result:
+            type: number
+    - id: '1740019130523'
+      position:
+        x: 980
+        y: 282
+      height: 54
+      width: 244
+      positionAbsolute:
+        x: 980
+        y: 282
+      selected: false
+      sourcePosition: right
+      targetPosition: left
+      type: custom
+      data:
+        title: 模板节点
+        desc: 模板节点，将计算结果格式化为输出字符串。
+        type: template-transform
+        variables:
+        - variable: result
+          value_selector:
+          - '1740019130522'
+          - result
+        template: '计算结果为: {{result}}'
+    - id: '1740019130524'
+      position:
+        x: 1280
+        y: 282
+      height: 90
+      width: 244
+      positionAbsolute:
+        x: 1280
+        y: 282
+      selected: false
+      sourcePosition: right
+      targetPosition: left
+      type: custom
+      data:
+        title: 结束节点
+        desc: 结束节点，输出格式化后的结果。
+        type: end
+        outputs:
+        - variable: output
+          value_selector:
+          - '1740019130523'
+          - output
+    viewport:
+      x: 92.96659905656679
+      y: 79.13437154762897
+      zoom: 0.9002006986311041

api/core/auto/output/text_analysis_workflow.yml

@@ -0,0 +1,262 @@
+app:
+  description: ''
+  icon: 🤖
+  icon_background: '#FFEAD5'
+  mode: workflow
+  name: 文本分析工作流
+  use_icon_as_answer_icon: false
+kind: app
+version: 0.1.2
+workflow:
+  conversation_variables: []
+  environment_variables: []
+  features:
+    file_upload:
+      allowed_file_extensions:
+      - .JPG
+      - .JPEG
+      - .PNG
+      - .GIF
+      - .WEBP
+      - .SVG
+      allowed_file_types:
+      - image
+      allowed_file_upload_methods:
+      - local_file
+      - remote_url
+      enabled: false
+      fileUploadConfig:
+        audio_file_size_limit: 50
+        batch_count_limit: 5
+        file_size_limit: 15
+        image_file_size_limit: 10
+        video_file_size_limit: 100
+      image:
+        enabled: false
+        number_limits: 3
+        transfer_methods:
+        - local_file
+        - remote_url
+      number_limits: 3
+    opening_statement: ''
+    retriever_resource:
+      enabled: true
+    sensitive_word_avoidance:
+      enabled: false
+    speech_to_text:
+      enabled: false
+    suggested_questions: []
+    suggested_questions_after_answer:
+      enabled: false
+    text_to_speech:
+      enabled: false
+      language: ''
+      voice: ''
+  graph:
+    edges:
+    - id: 1740019130520-source-1740019130521-target
+      source: '1740019130520'
+      sourceHandle: source
+      target: '1740019130521'
+      targetHandle: target
+      type: custom
+      zIndex: 0
+      data:
+        isInIteration: false
+        sourceType: start
+        targetType: llm
+    - id: 1740019130520-source-1740019130522-target
+      source: '1740019130520'
+      sourceHandle: source
+      target: '1740019130522'
+      targetHandle: target
+      type: custom
+      zIndex: 0
+      data:
+        isInIteration: false
+        sourceType: start
+        targetType: code
+    - id: 1740019130521-source-1740019130523-target
+      source: '1740019130521'
+      sourceHandle: source
+      target: '1740019130523'
+      targetHandle: target
+      type: custom
+      zIndex: 0
+      data:
+        isInIteration: false
+        sourceType: llm
+        targetType: template-transform
+    - id: 1740019130522-source-1740019130523-target
+      source: '1740019130522'
+      sourceHandle: source
+      target: '1740019130523'
+      targetHandle: target
+      type: custom
+      zIndex: 0
+      data:
+        isInIteration: false
+        sourceType: code
+        targetType: template-transform
+    - id: 1740019130523-source-1740019130524-target
+      source: '1740019130523'
+      sourceHandle: source
+      target: '1740019130524'
+      targetHandle: target
+      type: custom
+      zIndex: 0
+      data:
+        isInIteration: false
+        sourceType: template-transform
+        targetType: end
+    nodes:
+    - id: '1740019130520'
+      position:
+        x: 80
+        y: 282
+      height: 116
+      width: 244
+      positionAbsolute:
+        x: 80
+        y: 282
+      selected: false
+      sourcePosition: right
+      targetPosition: left
+      type: custom
+      data:
+        title: 开始节点
+        desc: 接收用户输入的文本参数
+        type: start
+        variables:
+        - type: text-input
+          label: user_text
+          variable: user_text
+          required: true
+          max_length: 48
+          options: []
+    - id: '1740019130521'
+      position:
+        x: 380
+        y: 282
+      height: 98
+      width: 244
+      positionAbsolute:
+        x: 380
+        y: 282
+      selected: false
+      sourcePosition: right
+      targetPosition: left
+      type: custom
+      data:
+        title: LLM节点
+        desc: 使用大语言模型进行情感分析，返回文本的情感结果
+        type: llm
+        model:
+          provider: zhipuai
+          name: glm-4-flash
+          mode: chat
+          completion_params:
+            temperature: 0.7
+        prompt_template:
+        - id: 1740019130521-system
+          text: 请分析以下文本的情感，返回积极、消极或中性
+          role: system
+        - id: 1740019130521-user
+          text: '{{user_text}}'
+          role: user
+        context:
+          enabled: false
+          variable_selector: []
+        vision:
+          enabled: false
+    - id: '1740019130522'
+      position:
+        x: 680
+        y: 282
+      height: 54
+      width: 244
+      positionAbsolute:
+        x: 680
+        y: 282
+      selected: false
+      sourcePosition: right
+      targetPosition: left
+      type: custom
+      data:
+        title: 代码节点
+        desc: 计算文本的统计信息，包括字符数、单词数和句子数
+        type: code
+        variables:
+        - variable: text_for_analysis
+          value_selector:
+          - '1740019130520'
+          - user_text
+        code_language: python3
+        code: "import re\n\ndef main(text):\n    char_count = len(text)\n    word_count\
+          \ = len(text.split())\n    sentence_count = len(re.findall(r'[.!?]', text))\n\
+          \    return {'char_count': char_count, 'word_count': word_count, 'sentence_count':\
+          \ sentence_count}"
+        outputs:
+          text_statistics:
+            type: object
+    - id: '1740019130523'
+      position:
+        x: 980
+        y: 282
+      height: 54
+      width: 244
+      positionAbsolute:
+        x: 980
+        y: 282
+      selected: false
+      sourcePosition: right
+      targetPosition: left
+      type: custom
+      data:
+        title: 模板节点
+        desc: 将情感分析结果和统计信息组合成格式化报告
+        type: template-transform
+        variables:
+        - variable: sentiment_result
+          value_selector:
+          - '1740019130521'
+          - sentiment_result
+        - variable: text_statistics
+          value_selector:
+          - '1740019130522'
+          - text_statistics
+        template: '情感分析结果：{{sentiment_result}}
+
+          文本统计信息：
+
+          字符数：{{text_statistics.char_count}}
+
+          单词数：{{text_statistics.word_count}}
+
+          句子数：{{text_statistics.sentence_count}}'
+    - id: '1740019130524'
+      position:
+        x: 1280
+        y: 282
+      height: 90
+      width: 244
+      positionAbsolute:
+        x: 1280
+        y: 282
+      selected: false
+      sourcePosition: right
+      targetPosition: left
+      type: custom
+      data:
+        title: 结束节点
+        desc: 返回最终的分析报告
+        type: end
+        outputs:
+        - variable: final_report
+          value_selector:
+          - '1740019130523'
+          - output
+    viewport:
+      x: 92.96659905656679
+      y: 79.13437154762897
+      zoom: 0.9002006986311041

api/core/auto/workflow_generator/__init__.py

@@ -0,0 +1,8 @@
+"""
+工作流生成器包
+用于根据用户需求生成Dify工作流
+"""
+
+from .workflow_generator import WorkflowGenerator
+
+__all__ = ["WorkflowGenerator"]

api/core/auto/workflow_generator/generators/__init__.py

@@ -0,0 +1,9 @@
+"""
+节点和边生成器包
+"""
+
+from .edge_generator import EdgeGenerator
+from .layout_engine import LayoutEngine
+from .node_generator import NodeGenerator
+
+__all__ = ["EdgeGenerator", "LayoutEngine", "NodeGenerator"]

api/core/auto/workflow_generator/generators/edge_generator.py

@@ -0,0 +1,101 @@
+"""
+Edge Generator
+Used to generate edges in the workflow
+"""
+
+from core.auto.node_types.common import CommonEdgeType, CompleteEdge, CompleteNode
+from core.auto.workflow_generator.models.workflow_description import ConnectionDescription
+
+
+class EdgeGenerator:
+    """Edge generator for creating workflow edges"""
+
+    @staticmethod
+    def create_edges(nodes: list[CompleteNode], connections: list[ConnectionDescription]) -> list[CompleteEdge]:
+        """
+        Create edges based on nodes and connection information
+
+        Args:
+            nodes: list of nodes
+            connections: list of connection descriptions
+
+        Returns:
+            list of edges
+        """
+        edges = []
+
+        # If connection information is provided, create edges based on it
+        if connections:
+            for connection in connections:
+                source_id = connection.source
+                target_id = connection.target
+
+                if not source_id or not target_id:
+                    continue
+
+                # Find source and target nodes
+                source_node = next((node for node in nodes if node.id == source_id), None)
+                target_node = next((node for node in nodes if node.id == target_id), None)
+
+                if not source_node or not target_node:
+                    continue
+
+                # Get node types
+                source_type = source_node.data.type
+                target_type = target_node.data.type
+
+                # Create edge
+                edge_id = f"{source_id}-source-{target_id}-target"
+
+                # Create edge data
+                edge_data = CommonEdgeType(isInIteration=False, sourceType=source_type, targetType=target_type)
+
+                # Create complete edge
+                edge = CompleteEdge(
+                    id=edge_id,
+                    source=source_id,
+                    sourceHandle="source",
+                    target=target_id,
+                    targetHandle="target",
+                    type="custom",
+                    zIndex=0,
+                )
+
+                # Add edge data
+                edge.add_data(edge_data)
+
+                edges.append(edge)
+        # If no connection information is provided, automatically create edges
+        else:
+            # Create edges based on node order
+            for i in range(len(nodes) - 1):
+                source_node = nodes[i]
+                target_node = nodes[i + 1]
+
+                # Get node types
+                source_type = source_node.data.type
+                target_type = target_node.data.type
+
+                # Create edge
+                edge_id = f"{source_node.id}-source-{target_node.id}-target"
+
+                # Create edge data
+                edge_data = CommonEdgeType(isInIteration=False, sourceType=source_type, targetType=target_type)
+
+                # Create complete edge
+                edge = CompleteEdge(
+                    id=edge_id,
+                    source=source_node.id,
+                    sourceHandle="source",
+                    target=target_node.id,
+                    targetHandle="target",
+                    type="custom",
+                    zIndex=0,
+                )
+
+                # Add edge data
+                edge.add_data(edge_data)
+
+                edges.append(edge)
+
+        return edges

api/core/auto/workflow_generator/generators/layout_engine.py

@@ -0,0 +1,77 @@
+"""
+Layout Engine
+Used to arrange the positions of nodes and edges
+"""
+
+from core.auto.node_types.common import CompleteEdge, CompleteNode
+
+
+class LayoutEngine:
+    """Layout engine"""
+
+    @staticmethod
+    def apply_layout(nodes: list[CompleteNode]) -> None:
+        """
+        Apply layout, arranging nodes in a row
+
+        Args:
+            nodes: list of nodes
+        """
+        # Simple linear layout, arranging nodes from left to right
+        x_position = 80
+        y_position = 282
+
+        for node in nodes:
+            node.position = {"x": x_position, "y": y_position}
+            node.positionAbsolute = {"x": x_position, "y": y_position}
+
+            # Update position for the next node
+            x_position += 300  # Horizontal spacing between nodes
+
+    @staticmethod
+    def apply_topological_layout(nodes: list[CompleteNode], edges: list[CompleteEdge]) -> None:
+        """
+        Apply topological sort layout, arranging nodes based on their dependencies
+
+        Args:
+            nodes: list of nodes
+            edges: list of edges
+        """
+        # Create mapping from node ID to node
+        node_map = {node.id: node for node in nodes}
+
+        # Create adjacency list
+        adjacency_list = {node.id: [] for node in nodes}
+        for edge in edges:
+            adjacency_list[edge.source].append(edge.target)
+
+        # Create in-degree table
+        in_degree = {node.id: 0 for node in nodes}
+        for source, targets in adjacency_list.items():
+            for target in targets:
+                in_degree[target] += 1
+
+        # Topological sort
+        queue = [node_id for node_id, degree in in_degree.items() if degree == 0]
+        sorted_nodes = []
+
+        while queue:
+            current = queue.pop(0)
+            sorted_nodes.append(current)
+
+            for neighbor in adjacency_list[current]:
+                in_degree[neighbor] -= 1
+                if in_degree[neighbor] == 0:
+                    queue.append(neighbor)
+
+        # Apply layout
+        x_position = 80
+        y_position = 282
+
+        for node_id in sorted_nodes:
+            node = node_map[node_id]
+            node.position = {"x": x_position, "y": y_position}
+            node.positionAbsolute = {"x": x_position, "y": y_position}
+
+            # Update position for the next node
+            x_position += 300  # Horizontal spacing between nodes

api/core/auto/workflow_generator/generators/node_generator.py

@@ -0,0 +1,446 @@
+"""
+Node Generator
+Generate nodes based on workflow description
+"""
+
+from core.auto.node_types.code import CodeLanguage, CodeNodeType, OutputVar
+from core.auto.node_types.common import (
+    BlockEnum,
+    CompleteNode,
+    Context,
+    InputVar,
+    ModelConfig,
+    PromptItem,
+    PromptRole,
+    ValueSelector,
+    Variable,
+)
+from core.auto.node_types.end import EndNodeType
+from core.auto.node_types.llm import LLMNodeType, VisionConfig
+from core.auto.node_types.start import StartNodeType
+from core.auto.node_types.template_transform import TemplateTransformNodeType
+from core.auto.workflow_generator.models.workflow_description import NodeDescription
+from core.auto.workflow_generator.utils.prompts import DEFAULT_MODEL_CONFIG, DEFAULT_SYSTEM_PROMPT
+from core.auto.workflow_generator.utils.type_mapper import map_string_to_var_type, map_var_type_to_input_type
+
+
+class NodeGenerator:
+    """Node generator for creating workflow nodes"""
+
+    @staticmethod
+    def create_nodes(node_descriptions: list[NodeDescription]) -> list[CompleteNode]:
+        """
+        Create nodes based on node descriptions
+
+        Args:
+            node_descriptions: list of node descriptions
+
+        Returns:
+            list of nodes
+        """
+        nodes = []
+
+        for node_desc in node_descriptions:
+            node_type = node_desc.type
+
+            if node_type == "start":
+                node = NodeGenerator._create_start_node(node_desc)
+            elif node_type == "llm":
+                node = NodeGenerator._create_llm_node(node_desc)
+            elif node_type == "code":
+                node = NodeGenerator._create_code_node(node_desc)
+            elif node_type == "template":
+                node = NodeGenerator._create_template_node(node_desc)
+            elif node_type == "end":
+                node = NodeGenerator._create_end_node(node_desc)
+            else:
+                raise ValueError(f"Unsupported node type: {node_type}")
+
+            nodes.append(node)
+
+        return nodes
+
+    @staticmethod
+    def _create_start_node(node_desc: NodeDescription) -> CompleteNode:
+        """Create start node"""
+        variables = []
+
+        for var in node_desc.variables or []:
+            input_var = InputVar(
+                type=map_var_type_to_input_type(var.type),
+                label=var.name,
+                variable=var.name,
+                required=var.required,
+                max_length=48,
+                options=[],
+            )
+            variables.append(input_var)
+
+        start_node = StartNodeType(
+            title=node_desc.title, desc=node_desc.description or "", type=BlockEnum.start, variables=variables
+        )
+
+        return CompleteNode(
+            id=node_desc.id,
+            type="custom",
+            position={"x": 0, "y": 0},  # Temporary position, will be updated later
+            height=118,  # Increase height to match reference file
+            width=244,
+            positionAbsolute={"x": 0, "y": 0},
+            selected=False,
+            sourcePosition="right",
+            targetPosition="left",
+            data=start_node,
+        )
+
+    @staticmethod
+    def _create_llm_node(node_desc: NodeDescription) -> CompleteNode:
+        """Create LLM node"""
+        # Build prompt template
+        prompt_template = []
+
+        # Add system prompt
+        system_prompt = node_desc.system_prompt or DEFAULT_SYSTEM_PROMPT
+        prompt_template.append(PromptItem(id=f"{node_desc.id}-system", role=PromptRole.system, text=system_prompt))
+
+        # Add user prompt
+        user_prompt = node_desc.user_prompt or "Please answer these questions:"
+
+        # Build variable list
+        variables = []
+        for var in node_desc.variables or []:
+            source_node = var.source_node or ""
+            source_variable = var.source_variable or ""
+
+            print(
+                f"DEBUG: Processing variable {var.name}, source_node={source_node}, source_variable={source_variable}"
+            )
+
+            # If source node is an LLM node, ensure source_variable is 'text'
+            if source_node:
+                # Check if the source node is an LLM node by checking connections
+                # This is a simple heuristic - if the source node is connected to a node with 'llm' in its ID
+                # or if the source node has 'llm' in its ID, assume it's an LLM node
+                if "llm" in source_node.lower():
+                    print(f"DEBUG: Found LLM node {source_node}")
+                    if source_variable != "text":
+                        old_var = source_variable
+                        source_variable = "text"  # LLM nodes output variable is always 'text'
+                        print(
+                            f"Auto-fixing: Changed source variable from '{old_var}' to 'text' for LLM node {source_node}"  # noqa: E501
+                        )
+
+            # Check if the user prompt already contains correctly formatted variable references
+            # Variable references in LLM nodes should be in the format {{#nodeID.variableName#}}
+            correct_format = f"{{{{#{source_node}.{source_variable}#}}}}"
+            simple_format = f"{{{{{var.name}}}}}"
+
+            # If simple format is used in the prompt, replace it with the correct format
+            if simple_format in user_prompt and source_node and source_variable:
+                user_prompt = user_prompt.replace(simple_format, correct_format)
+
+            variable = Variable(variable=var.name, value_selector=[source_node, source_variable])
+            variables.append(variable)
+
+        # Update user prompt
+        prompt_template.append(PromptItem(id=f"{node_desc.id}-user", role=PromptRole.user, text=user_prompt))
+
+        # Use default model configuration, prioritize configuration in node description
+        provider = node_desc.provider or DEFAULT_MODEL_CONFIG["provider"]
+        model = node_desc.model or DEFAULT_MODEL_CONFIG["model"]
+
+        llm_node = LLMNodeType(
+            title=node_desc.title,
+            desc=node_desc.description or "",
+            type=BlockEnum.llm,
+            model=ModelConfig(
+                provider=provider,
+                name=model,
+                mode=DEFAULT_MODEL_CONFIG["mode"],
+                completion_params=DEFAULT_MODEL_CONFIG["completion_params"],
+            ),
+            prompt_template=prompt_template,
+            variables=variables,
+            context=Context(enabled=False, variable_selector=ValueSelector(value=[])),
+            vision=VisionConfig(enabled=False),
+        )
+
+        return CompleteNode(
+            id=node_desc.id,
+            type="custom",
+            position={"x": 0, "y": 0},  # Temporary position, will be updated later
+            height=126,  # Increase height to match reference file
+            width=244,
+            positionAbsolute={"x": 0, "y": 0},
+            selected=False,
+            sourcePosition="right",
+            targetPosition="left",
+            data=llm_node,
+        )
+
+    @staticmethod
+    def _create_code_node(node_desc: NodeDescription) -> CompleteNode:
+        """Create code node"""
+        # Build variable list and function parameter names
+        variables = []
+        var_names = []
+        var_mapping = {}  # Used to store mapping from variable names to function parameter names
+
+        # First, identify all LLM nodes in the workflow
+        llm_nodes = set()
+        for connection in node_desc.workflow_description.connections:
+            for node in node_desc.workflow_description.nodes:
+                if node.id == connection.source and node.type.lower() == "llm":
+                    llm_nodes.add(node.id)
+
+        for var in node_desc.variables or []:
+            source_node = var.source_node or ""
+            source_variable = var.source_variable or ""
+
+            # Check if source node is an LLM node and warn if source_variable is not 'text'
+            if source_node in llm_nodes and source_variable != "text":
+                print(
+                    f"WARNING: LLM node {source_node} output variable should be 'text', but got '{source_variable}'. This may cause issues in Dify."  # noqa: E501
+                )
+                print("         Consider changing the source_variable to 'text' in your workflow description.")
+                # Auto-fix: Always use 'text' as the source variable for LLM nodes
+                old_var = source_variable
+                source_variable = "text"
+                print(f"Auto-fixing: Changed source variable from '{old_var}' to 'text' for LLM node {source_node}")
+            elif source_node and "llm" in source_node.lower() and source_variable != "text":
+                # Fallback heuristic check based on node ID
+                print(
+                    f"WARNING: Node {source_node} appears to be an LLM node based on its ID, but source_variable is not 'text'."  # noqa: E501
+                )
+                print("         Consider changing the source_variable to 'text' in your workflow description.")
+                # Auto-fix: Always use 'text' as the source variable for LLM nodes
+                old_var = source_variable
+                source_variable = "text"
+                print(f"Auto-fixing: Changed source variable from '{old_var}' to 'text' for LLM node {source_node}")
+
+            # Use variable name as function parameter name
+            variable_name = var.name  # Variable name defined in this node
+            param_name = variable_name  # Function parameter name must match variable name
+
+            # Validate variable name format
+            if not variable_name.replace("_", "").isalnum():
+                raise ValueError(
+                    f"Invalid variable name: {variable_name}. Variable names must only contain letters, numbers, and underscores."  # noqa: E501
+                )
+            if not variable_name[0].isalpha() and variable_name[0] != "_":
+                raise ValueError(
+                    f"Invalid variable name: {variable_name}. Variable names must start with a letter or underscore."
+                )
+
+            var_names.append(param_name)
+            var_mapping[variable_name] = param_name
+
+            variable = Variable(variable=variable_name, value_selector=[source_node, source_variable])
+            variables.append(variable)
+
+        # Build output
+        outputs = {}
+        for output in node_desc.outputs or []:
+            # Validate output variable name format
+            if not output.name.replace("_", "").isalnum():
+                raise ValueError(
+                    f"Invalid output variable name: {output.name}. Output names must only contain letters, numbers, and underscores."  # noqa: E501
+                )
+            if not output.name[0].isalpha() and output.name[0] != "_":
+                raise ValueError(
+                    f"Invalid output variable name: {output.name}. Output names must start with a letter or underscore."
+                )
+
+            outputs[output.name] = OutputVar(type=map_string_to_var_type(output.type))
+
+        # Generate code, ensure function parameters match variable names, return values match output names
+        output_names = [output.name for output in node_desc.outputs or []]
+
+        # Build function parameter list
+        params_str = ", ".join(var_names) if var_names else ""
+
+        # Build return value dictionary
+        return_dict = {}
+        for output_name in output_names:
+            # Use the first variable as the return value by default
+            return_dict[output_name] = var_names[0] if var_names else f'"{output_name}"'
+
+        return_dict_str = ", ".join([f'"{k}": {v}' for k, v in return_dict.items()])
+
+        # Default code template, ensure return dictionary type matches output variable
+        default_code = f"""def main({params_str}):
+    # Write your code here
+    # Process input variables
+    
+    # Return a dictionary, key names must match variable names defined in outputs
+    return {{{return_dict_str}}}"""
+
+        # If custom code is provided, ensure it meets the specifications
+        if node_desc.code:
+            custom_code = node_desc.code
+            # Check if it contains main function definition
+            if not custom_code.strip().startswith("def main("):
+                # Try to fix the code by adding main function with correct parameters
+                custom_code = f"def main({params_str}):\n" + custom_code.strip()
+            else:
+                # Extract function parameters from the existing main function
+                import re
+
+                func_params = re.search(r"def\s+main\s*\((.*?)\)", custom_code)
+                if func_params:
+                    existing_params = [p.strip() for p in func_params.group(1).split(",") if p.strip()]
+                    # Verify that all required parameters are present
+                    missing_params = set(var_names) - set(existing_params)
+                    if missing_params:
+                        # 尝试修复代码，将函数参数替换为正确的参数名
+                        old_params = func_params.group(1)
+                        new_params = params_str
+                        custom_code = custom_code.replace(f"def main({old_params})", f"def main({new_params})")
+                        print(
+                            f"Warning: Fixed missing parameters in code node: {', '.join(missing_params)}. Function parameters must match variable names defined in this node."  # noqa: E501
+                        )
+
+            # Check if the return value is a dictionary and keys match output variables
+            for output_name in output_names:
+                if f'"{output_name}"' not in custom_code and f"'{output_name}'" not in custom_code:
+                    # Code may not meet specifications, use default code
+                    custom_code = default_code
+                    break
+
+            # Use fixed code
+            code = custom_code
+        else:
+            code = default_code
+
+        code_node = CodeNodeType(
+            title=node_desc.title,
+            desc=node_desc.description or "",
+            type=BlockEnum.code,
+            code_language=CodeLanguage.python3,
+            code=code,
+            variables=variables,
+            outputs=outputs,
+        )
+
+        return CompleteNode(
+            id=node_desc.id,
+            type="custom",
+            position={"x": 0, "y": 0},  # Temporary position, will be updated later
+            height=82,  # Increase height to match reference file
+            width=244,
+            positionAbsolute={"x": 0, "y": 0},
+            selected=False,
+            sourcePosition="right",
+            targetPosition="left",
+            data=code_node,
+        )
+
+    @staticmethod
+    def _create_template_node(node_desc: NodeDescription) -> CompleteNode:
+        """Create template node"""
+        # Build variable list
+        variables = []
+        template_text = node_desc.template or ""
+
+        # Collect all node IDs referenced in the template
+        referenced_nodes = set()
+        for var in node_desc.variables or []:
+            source_node = var.source_node or ""
+            source_variable = var.source_variable or ""
+
+            variable = Variable(variable=var.name, value_selector=[source_node, source_variable])
+            variables.append(variable)
+
+            if source_node:
+                referenced_nodes.add(source_node)
+
+            # Modify variable reference format in the template
+            # Replace {{#node_id.variable#}} with {{ variable }}
+            if source_node and source_variable:
+                template_text = template_text.replace(f"{{{{#{source_node}.{source_variable}#}}}}", f"{{ {var.name} }}")
+
+        # Check if a reference to the start node needs to be added
+        # If the template contains a reference to the start node but the variable list does not have a corresponding variable  # noqa: E501
+        import re
+
+        start_node_refs = re.findall(r"{{#(\d+)\.([^#]+)#}}", template_text)
+
+        for node_id, var_name in start_node_refs:
+            # Check if there is already a reference to this variable
+            if not any(v.variable == var_name for v in variables):
+                # Add reference to start node variable
+                variable = Variable(variable=var_name, value_selector=[node_id, var_name])
+                variables.append(variable)
+
+                # Modify variable reference format in the template
+                template_text = template_text.replace(f"{{{{#{node_id}.{var_name}#}}}}", f"{{ {var_name} }}")
+
+        # Get all variable names
+        var_names = [var.variable for var in variables]
+
+        # Simple and crude method: directly replace all possible variable reference formats
+        for var_name in var_names:
+            # Replace {var_name} with {{ var_name }}
+            template_text = template_text.replace("{" + var_name + "}", "{{ " + var_name + " }}")
+            # Replace { var_name } with {{ var_name }}
+            template_text = template_text.replace("{ " + var_name + " }", "{{ " + var_name + " }}")
+            # Replace {var_name } with {{ var_name }}
+            template_text = template_text.replace("{" + var_name + " }", "{{ " + var_name + " }}")
+            # Replace { var_name} with {{ var_name }}
+            template_text = template_text.replace("{ " + var_name + "}", "{{ " + var_name + " }}")
+            # Replace {{{ var_name }}} with {{ var_name }}
+            template_text = template_text.replace("{{{ " + var_name + " }}}", "{{ " + var_name + " }}")
+            # Replace {{{var_name}}} with {{ var_name }}
+            template_text = template_text.replace("{{{" + var_name + "}}}", "{{ " + var_name + " }}")
+
+        # Use regular expression to replace all triple curly braces with double curly braces
+        template_text = re.sub(r"{{{([^}]+)}}}", r"{{ \1 }}", template_text)
+
+        template_node = TemplateTransformNodeType(
+            title=node_desc.title,
+            desc=node_desc.description or "",
+            type=BlockEnum.template_transform,
+            template=template_text,
+            variables=variables,
+        )
+
+        return CompleteNode(
+            id=node_desc.id,
+            type="custom",
+            position={"x": 0, "y": 0},  # Temporary position, will be updated later
+            height=82,  # Increase height to match reference file
+            width=244,
+            positionAbsolute={"x": 0, "y": 0},
+            selected=False,
+            sourcePosition="right",
+            targetPosition="left",
+            data=template_node,
+        )
+
+    @staticmethod
+    def _create_end_node(node_desc: NodeDescription) -> CompleteNode:
+        """Create end node"""
+        # Build output variable list
+        outputs = []
+        for output in node_desc.outputs or []:
+            variable = Variable(
+                variable=output.name, value_selector=[output.source_node or "", output.source_variable or ""]
+            )
+            outputs.append(variable)
+
+        end_node = EndNodeType(
+            title=node_desc.title, desc=node_desc.description or "", type=BlockEnum.end, outputs=outputs
+        )
+
+        return CompleteNode(
+            id=node_desc.id,
+            type="custom",
+            position={"x": 0, "y": 0},  # Temporary position, will be updated later
+            height=90,
+            width=244,
+            positionAbsolute={"x": 0, "y": 0},
+            selected=False,
+            sourcePosition="right",
+            targetPosition="left",
+            data=end_node,
+        )

api/core/auto/workflow_generator/models/__init__.py

@@ -0,0 +1,7 @@
+"""
+模型包
+"""
+
+from .workflow_description import ConnectionDescription, NodeDescription, WorkflowDescription
+
+__all__ = ["ConnectionDescription", "NodeDescription", "WorkflowDescription"]

api/core/auto/workflow_generator/models/workflow_description.py

@@ -0,0 +1,80 @@
+"""
+Workflow Description Model
+Used to represent the simplified workflow description generated by large language models
+"""
+
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class VariableDescription(BaseModel):
+    """Variable description"""
+
+    name: str
+    type: str
+    description: Optional[str] = None
+    required: bool = True
+    source_node: Optional[str] = None
+    source_variable: Optional[str] = None
+
+
+class OutputDescription(BaseModel):
+    """Output description"""
+
+    name: str
+    type: str = "string"
+    description: Optional[str] = None
+    source_node: Optional[str] = None
+    source_variable: Optional[str] = None
+
+
+class NodeDescription(BaseModel):
+    """Node description"""
+
+    id: str
+    type: str
+    title: str
+    description: Optional[str] = ""
+    variables: Optional[list[VariableDescription]] = Field(default_factory=list)
+    outputs: Optional[list[OutputDescription]] = Field(default_factory=list)
+
+    # LLM node specific fields
+    system_prompt: Optional[str] = None
+    user_prompt: Optional[str] = None
+    provider: Optional[str] = "zhipuai"
+    model: Optional[str] = "glm-4-flash"
+
+    # Code node specific fields
+    code: Optional[str] = None
+
+    # Template node specific fields
+    template: Optional[str] = None
+
+    # Reference to workflow description, used for node relationship analysis
+    workflow_description: Optional["WorkflowDescription"] = Field(default=None, exclude=True)
+
+    class Config:
+        exclude = {"workflow_description"}
+
+
+class ConnectionDescription(BaseModel):
+    """Connection description"""
+
+    source: str
+    target: str
+
+
+class WorkflowDescription(BaseModel):
+    """Workflow description"""
+
+    name: str
+    description: Optional[str] = ""
+    nodes: list[NodeDescription]
+    connections: list[ConnectionDescription]
+
+    def __init__(self, **data):
+        super().__init__(**data)
+        # Add workflow description reference to each node
+        for node in self.nodes:
+            node.workflow_description = self

api/core/auto/workflow_generator/utils/__init__.py

@@ -0,0 +1,16 @@
+"""
+工具函数包
+"""
+
+from .llm_client import LLMClient
+from .prompts import DEFAULT_MODEL_CONFIG, DEFAULT_SYSTEM_PROMPT, build_workflow_prompt
+from .type_mapper import map_string_to_var_type, map_var_type_to_input_type
+
+__all__ = [
+    "DEFAULT_MODEL_CONFIG",
+    "DEFAULT_SYSTEM_PROMPT",
+    "LLMClient",
+    "build_workflow_prompt",
+    "map_string_to_var_type",
+    "map_var_type_to_input_type",
+]

api/core/auto/workflow_generator/utils/config_manager.py

@@ -0,0 +1,142 @@
+"""
+Configuration Manager
+Used to manage configurations and prompts
+"""
+
+import os
+import time
+from pathlib import Path
+from typing import Any, Optional
+
+import yaml
+
+
+class ConfigManager:
+    """Configuration manager for managing configurations"""
+
+    def __init__(self, config_dir: str = "config"):
+        """
+        Initialize configuration manager
+
+        Args:
+            config_dir: Configuration directory path
+        """
+        self.config_dir = Path(config_dir)
+        self.config: dict[str, Any] = {}
+        self.last_load_time: float = 0
+        self.reload_interval: float = 60  # Check every 60 seconds
+        self._load_config()
+
+    def _should_reload(self) -> bool:
+        """Check if configuration needs to be reloaded"""
+        return time.time() - self.last_load_time > self.reload_interval
+
+    def _load_config(self) -> dict[str, Any]:
+        """Load configuration files"""
+        default_config = self._load_yaml(self.config_dir / "default.yaml")
+        custom_config = self._load_yaml(self.config_dir / "custom.yaml")
+        self.config = self._deep_merge(default_config, custom_config)
+        self.last_load_time = time.time()
+        return self.config
+
+    @staticmethod
+    def _load_yaml(path: Path) -> dict[str, Any]:
+        """Load YAML file"""
+        try:
+            with open(path, encoding="utf-8") as f:
+                return yaml.safe_load(f) or {}
+        except FileNotFoundError:
+            print(f"Warning: Config file not found at {path}")
+            return {}
+        except Exception as e:
+            print(f"Error loading config file {path}: {e}")
+            return {}
+
+    @staticmethod
+    def _deep_merge(dict1: dict, dict2: dict) -> dict:
+        """Recursively merge two dictionaries"""
+        result = dict1.copy()
+        for key, value in dict2.items():
+            if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+                result[key] = ConfigManager._deep_merge(result[key], value)
+            else:
+                result[key] = value
+        return result
+
+    def get(self, *keys: str, default: Any = None) -> Any:
+        """
+        Get configuration value
+
+        Args:
+            *keys: Configuration key path
+            default: Default value
+
+        Returns:
+            Configuration value or default value
+        """
+        if self._should_reload():
+            self._load_config()
+
+        current = self.config
+        for key in keys:
+            if isinstance(current, dict) and key in current:
+                current = current[key]
+            else:
+                return default
+        return current
+
+    @property
+    def workflow_generator(self) -> dict[str, Any]:
+        """Get workflow generator configuration"""
+        return self.get("workflow_generator", default={})
+
+    @property
+    def workflow_nodes(self) -> dict[str, Any]:
+        """Get workflow nodes configuration"""
+        return self.get("workflow_nodes", default={})
+
+    @property
+    def output(self) -> dict[str, Any]:
+        """Get output configuration"""
+        return self.get("output", default={})
+
+    def get_output_path(self, filename: Optional[str] = None) -> str:
+        """
+        Get output file path
+
+        Args:
+            filename: Optional filename, uses default filename from config if not specified
+
+        Returns:
+            Complete output file path
+        """
+        output_config = self.output
+        output_dir = output_config.get("dir", "output/")
+        output_filename = filename or output_config.get("filename", "generated_workflow.yml")
+        return os.path.join(output_dir, output_filename)
+
+    def get_workflow_model(self, model_name: Optional[str] = None) -> dict[str, Any]:
+        """
+        Get workflow generation model configuration
+
+        Args:
+            model_name: Model name, uses default model if not specified
+
+        Returns:
+            Model configuration
+        """
+        models = self.workflow_generator.get("models", {})
+
+        if not model_name:
+            model_name = models.get("default")
+
+        return models.get("available", {}).get(model_name, {})
+
+    def get_llm_node_config(self) -> dict[str, Any]:
+        """
+        Get LLM node configuration
+
+        Returns:
+            LLM node configuration
+        """
+        return self.workflow_nodes.get("llm", {})

api/core/auto/workflow_generator/utils/debug_manager.py

@@ -0,0 +1,151 @@
+"""
+Debug Manager
+Used to manage debug information saving
+"""
+
+import datetime
+import json
+import os
+import uuid
+from typing import Any, Optional, Union
+
+
+class DebugManager:
+    """Debug manager for managing debug information saving"""
+
+    _instance = None
+
+    def __new__(cls, *args, **kwargs):
+        """Singleton pattern"""
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance._initialized = False
+        return cls._instance
+
+    def __init__(self, config: dict[str, Any] = {}, debug_enabled: bool = False):
+        """
+        Initialize debug manager
+
+        Args:
+            config: Debug configuration
+            debug_enabled: Whether to enable debug mode
+        """
+        # Avoid repeated initialization
+        if self._initialized:
+            return
+
+        self._initialized = True
+        self.config = config or {}
+        self.debug_enabled = debug_enabled or self.config.get("enabled", False)
+        self.debug_dir = self.config.get("dir", "debug/")
+        self.save_options = self.config.get(
+            "save_options", {"prompt": True, "response": True, "json": True, "workflow": True}
+        )
+
+        # Generate run ID
+        self.case_id = self._generate_case_id()
+        self.case_dir = os.path.join(self.debug_dir, self.case_id)
+
+        # If debug is enabled, create debug directory
+        if self.debug_enabled:
+            os.makedirs(self.case_dir, exist_ok=True)
+            print(f"Debug mode enabled, debug information will be saved to: {self.case_dir}")
+
+    def _generate_case_id(self) -> str:
+        """
+        Generate run ID
+
+        Returns:
+            Run ID
+        """
+        # Use format from configuration to generate run ID
+        format_str = self.config.get("case_id_format", "%Y%m%d_%H%M%S_%f")
+        timestamp = datetime.datetime.now().strftime(format_str)
+
+        # Add random string
+        random_str = str(uuid.uuid4())[:8]
+
+        return f"{timestamp}_{random_str}"
+
+    def save_text(self, content: str, filename: str, subdir: Optional[str] = None) -> Optional[str]:
+        """
+        Save text content to file
+
+        Args:
+            content: Text content
+            filename: File name
+            subdir: Subdirectory name
+
+        Returns:
+            Saved file path, returns None if debug is not enabled
+        """
+        if not self.debug_enabled:
+            return None
+
+        try:
+            # Determine save path
+            save_dir = self.case_dir
+            if subdir:
+                save_dir = os.path.join(save_dir, subdir)
+                os.makedirs(save_dir, exist_ok=True)
+
+            file_path = os.path.join(save_dir, filename)
+
+            # Save content
+            with open(file_path, "w", encoding="utf-8") as f:
+                f.write(content)
+
+            print(f"Debug information saved to: {file_path}")
+            return file_path
+        except Exception as e:
+            print(f"Failed to save debug information: {e}")
+            return None
+
+    def save_json(self, data: Union[dict, list], filename: str, subdir: Optional[str] = None) -> Optional[str]:
+        """
+        Save JSON data to file
+
+        Args:
+            data: JSON data
+            filename: File name
+            subdir: Subdirectory name
+
+        Returns:
+            Saved file path, returns None if debug is not enabled
+        """
+        if not self.debug_enabled:
+            return None
+
+        try:
+            # Determine save path
+            save_dir = self.case_dir
+            if subdir:
+                save_dir = os.path.join(save_dir, subdir)
+                os.makedirs(save_dir, exist_ok=True)
+
+            file_path = os.path.join(save_dir, filename)
+
+            # Save content
+            with open(file_path, "w", encoding="utf-8") as f:
+                json.dump(data, f, ensure_ascii=False, indent=2)
+
+            print(f"Debug information saved to: {file_path}")
+            return file_path
+        except Exception as e:
+            print(f"Failed to save debug information: {e}")
+            return None
+
+    def should_save(self, option: str) -> bool:
+        """
+        Check if specified type of debug information should be saved
+
+        Args:
+            option: Debug information type
+
+        Returns:
+            Whether it should be saved
+        """
+        if not self.debug_enabled:
+            return False
+
+        return self.save_options.get(option, False)

api/core/auto/workflow_generator/utils/llm_client.py

@@ -0,0 +1,438 @@
+"""
+LLM Client
+Used to call LLM API
+"""
+
+import json
+import re
+from typing import Any
+
+from core.auto.workflow_generator.utils.debug_manager import DebugManager
+from core.auto.workflow_generator.utils.prompts import DEFAULT_SYSTEM_PROMPT
+from core.model_manager import ModelInstance
+from core.model_runtime.entities.message_entities import SystemPromptMessage, UserPromptMessage
+
+
+class LLMClient:
+    """LLM Client"""
+
+    def __init__(self, model_instance: ModelInstance, debug_manager: DebugManager):
+        """
+        Initialize LLM client
+
+        Args:
+            api_key: API key
+            model: Model name
+            api_base: API base URL
+            max_tokens: Maximum number of tokens to generate
+            debug_manager: Debug manager
+        """
+
+        self.debug_manager = debug_manager or DebugManager()
+        self.model_instance = model_instance
+
+    def generate(self, prompt: str) -> str:
+        """
+        Generate text
+
+        Args:
+            prompt: Prompt text
+
+        Returns:
+            Generated text
+        """
+
+        # Save prompt
+        if self.debug_manager.should_save("prompt"):
+            self.debug_manager.save_text(prompt, "prompt.txt", "llm")
+
+        try:
+            response = self.model_instance.invoke_llm(
+                prompt_messages=[
+                    SystemPromptMessage(content=DEFAULT_SYSTEM_PROMPT),
+                    UserPromptMessage(content=prompt),
+                ],
+                model_parameters={"temperature": 0.7, "max_tokens": 4900},
+            )
+            content = ""
+            for chunk in response:
+                content += chunk.delta.message.content
+            print(f"Generation complete, text length: {len(content)} characters")
+
+            # Save response
+            if self.debug_manager.should_save("response"):
+                self.debug_manager.save_text(content, "response.txt", "llm")
+
+            return content
+        except Exception as e:
+            print(f"Error generating text: {e}")
+            raise e
+
+    def extract_json(self, text: str) -> dict[str, Any]:
+        """
+        Extract JSON from text
+
+        Args:
+            text: Text containing JSON
+
+        Returns:
+            Extracted JSON object
+        """
+        print("Starting JSON extraction from text...")
+
+        # Save original text
+        if self.debug_manager.should_save("json"):
+            self.debug_manager.save_text(text, "original_text.txt", "json")
+
+        # Use regex to extract JSON part
+        json_match = re.search(r"```json\n(.*?)\n```", text, re.DOTALL)
+        if json_match:
+            json_str = json_match.group(1)
+            print("Successfully extracted JSON from code block")
+        else:
+            # Try to match code block without language identifier
+            json_match = re.search(r"```\n(.*?)\n```", text, re.DOTALL)
+            if json_match:
+                json_str = json_match.group(1)
+                print("Successfully extracted JSON from code block without language identifier")
+            else:
+                # Try to match JSON surrounded by curly braces
+                json_match = re.search(r"(\{.*\})", text, re.DOTALL)
+                if json_match:
+                    json_str = json_match.group(1)
+                    print("Successfully extracted JSON from curly braces")
+                else:
+                    # Try to parse entire text
+                    json_str = text
+                    print("No JSON code block found, attempting to parse entire text")
+
+        # Save extracted JSON string
+        if self.debug_manager.should_save("json"):
+            self.debug_manager.save_text(json_str, "extracted_json.txt", "json")
+
+        # Try multiple methods to parse JSON
+        try:
+            # Try direct parsing
+            result = json.loads(json_str)
+        except json.JSONDecodeError as e:
+            print(f"Direct JSON parsing failed: {e}, attempting basic cleaning")
+            try:
+                # Try basic cleaning
+                cleaned_text = self._clean_text(json_str)
+                if self.debug_manager.should_save("json"):
+                    self.debug_manager.save_text(cleaned_text, "cleaned_json_1.txt", "json")
+                result = json.loads(cleaned_text)
+            except json.JSONDecodeError as e:
+                print(f"JSON parsing after basic cleaning failed: {e}, attempting to fix common errors")
+                try:
+                    # Try fixing common errors
+                    fixed_text = self._fix_json_errors(json_str)
+                    if self.debug_manager.should_save("json"):
+                        self.debug_manager.save_text(fixed_text, "cleaned_json_2.txt", "json")
+                    result = json.loads(fixed_text)
+                except json.JSONDecodeError as e:
+                    print(f"JSON parsing after fixing common errors failed: {e}, attempting aggressive cleaning")
+                    try:
+                        # Try aggressive cleaning
+                        aggressive_cleaned = self._aggressive_clean(json_str)
+                        if self.debug_manager.should_save("json"):
+                            self.debug_manager.save_text(aggressive_cleaned, "cleaned_json_3.txt", "json")
+                        result = json.loads(aggressive_cleaned)
+                    except json.JSONDecodeError as e:
+                        print(f"JSON parsing after aggressive cleaning failed: {e}, attempting manual JSON extraction")
+                        # Try manual JSON structure extraction
+                        result = self._manual_json_extraction(json_str)
+                        if self.debug_manager.should_save("json"):
+                            self.debug_manager.save_json(result, "manual_json.json", "json")
+
+        # Check for nested workflow structure
+        if "workflow" in result and isinstance(result["workflow"], dict):
+            print("Detected nested workflow structure, extracting top-level data")
+            # Extract workflow name and description
+            name = result.get("name", "Text Analysis Workflow")
+            description = result.get("description", "")
+
+            # Extract nodes and connections
+            nodes = result["workflow"].get("nodes", [])
+            connections = []
+
+            # If there are connections, extract them
+            if "connections" in result["workflow"]:
+                connections = result["workflow"]["connections"]
+
+            # Build standard format workflow description
+            result = {"name": name, "description": description, "nodes": nodes, "connections": connections}
+
+        # Save final parsed JSON
+        if self.debug_manager.should_save("json"):
+            self.debug_manager.save_json(result, "final_json.json", "json")
+
+        print(
+            f"JSON parsing successful, contains {len(result.get('nodes', []))} nodes and {len(result.get('connections', []))} connections"  # noqa: E501
+        )
+        return result
+
+    def _clean_text(self, text: str) -> str:
+        """
+        Clean text by removing non-JSON characters
+
+        Args:
+            text: Text to clean
+
+        Returns:
+            Cleaned text
+        """
+        print("Starting text cleaning...")
+        # Remove characters that might cause JSON parsing to fail
+        lines = text.split("\n")
+        cleaned_lines = []
+
+        in_json = False
+        for line in lines:
+            if line.strip().startswith("{") or line.strip().startswith("["):
+                in_json = True
+
+            if in_json:
+                cleaned_lines.append(line)
+
+            if line.strip().endswith("}") or line.strip().endswith("]"):
+                in_json = False
+
+        cleaned_text = "\n".join(cleaned_lines)
+        print(f"Text cleaning complete, length before: {len(text)}, length after: {len(cleaned_text)}")
+        return cleaned_text
+
+    def _fix_json_errors(self, text: str) -> str:
+        """
+        Fix common JSON errors
+
+        Args:
+            text: Text to fix
+
+        Returns:
+            Fixed text
+        """
+        print("Attempting to fix JSON errors...")
+
+        # Replace single quotes with double quotes
+        text = re.sub(r"'([^']*)'", r'"\1"', text)
+
+        # Fix missing commas
+        text = re.sub(r"}\s*{", "},{", text)
+        text = re.sub(r"]\s*{", "],{", text)
+        text = re.sub(r"}\s*\[", r"},\[", text)
+        text = re.sub(r"]\s*\[", r"],\[", text)
+
+        # Fix extra commas
+        text = re.sub(r",\s*}", "}", text)
+        text = re.sub(r",\s*]", "]", text)
+
+        # Ensure property names have double quotes
+        text = re.sub(r"([{,]\s*)(\w+)(\s*:)", r'\1"\2"\3', text)
+
+        return text
+
+    def _aggressive_clean(self, text: str) -> str:
+        """
+        More aggressive text cleaning
+
+        Args:
+            text: Text to clean
+
+        Returns:
+            Cleaned text
+        """
+        print("Using aggressive cleaning method...")
+
+        # Try to find outermost curly braces
+        start_idx = text.find("{")
+        end_idx = text.rfind("}")
+
+        if start_idx != -1 and end_idx != -1 and start_idx < end_idx:
+            text = text[start_idx : end_idx + 1]
+
+        # Remove comments
+        text = re.sub(r"//.*?\n", "\n", text)
+        text = re.sub(r"/\*.*?\*/", "", text, flags=re.DOTALL)
+
+        # Fix JSON format
+        text = self._fix_json_errors(text)
+
+        # Remove escape characters
+        text = text.replace("\\n", "\n").replace("\\t", "\t").replace('\\"', '"')
+
+        # Fix potential Unicode escape issues
+        text = re.sub(r"\\u([0-9a-fA-F]{4})", lambda m: chr(int(m.group(1), 16)), text)
+
+        return text
+
+    def _manual_json_extraction(self, text: str) -> dict[str, Any]:
+        """
+        Manual JSON structure extraction
+
+        Args:
+            text: Text to extract from
+
+        Returns:
+            Extracted JSON object
+        """
+        print("Attempting manual JSON structure extraction...")
+
+        # Extract workflow name
+        name_match = re.search(r'"name"\s*:\s*"([^"]*)"', text)
+        name = name_match.group(1) if name_match else "Simple Workflow"
+
+        # Extract workflow description
+        desc_match = re.search(r'"description"\s*:\s*"([^"]*)"', text)
+        description = desc_match.group(1) if desc_match else "Automatically generated workflow"
+
+        # Extract nodes
+        nodes = []
+        node_matches = re.finditer(r'\{\s*"id"\s*:\s*"([^"]*)"\s*,\s*"type"\s*:\s*"([^"]*)"', text)
+
+        for match in node_matches:
+            node_id = match.group(1)
+            node_type = match.group(2)
+
+            # Extract node title
+            title_match = re.search(rf'"id"\s*:\s*"{node_id}".*?"title"\s*:\s*"([^"]*)"', text, re.DOTALL)
+            title = title_match.group(1) if title_match else f"{node_type.capitalize()} Node"
+
+            # Extract node description
+            desc_match = re.search(rf'"id"\s*:\s*"{node_id}".*?"description"\s*:\s*"([^"]*)"', text, re.DOTALL)
+            desc = desc_match.group(1) if desc_match else ""
+
+            # Create basic node based on node type
+            if node_type == "start":
+                # Extract variables
+                variables = []
+                var_section_match = re.search(rf'"id"\s*:\s*"{node_id}".*?"variables"\s*:\s*\[(.*?)\]', text, re.DOTALL)
+
+                if var_section_match:
+                    var_section = var_section_match.group(1)
+                    var_matches = re.finditer(r'\{\s*"name"\s*:\s*"([^"]*)"\s*,\s*"type"\s*:\s*"([^"]*)"', var_section)
+
+                    for var_match in var_matches:
+                        var_name = var_match.group(1)
+                        var_type = var_match.group(2)
+
+                        # Extract variable description
+                        var_desc_match = re.search(
+                            rf'"name"\s*:\s*"{var_name}".*?"description"\s*:\s*"([^"]*)"', var_section, re.DOTALL
+                        )
+                        var_desc = var_desc_match.group(1) if var_desc_match else ""
+
+                        # Extract required status
+                        var_required_match = re.search(
+                            rf'"name"\s*:\s*"{var_name}".*?"required"\s*:\s*(true|false)', var_section, re.DOTALL
+                        )
+                        var_required = var_required_match.group(1).lower() == "true" if var_required_match else True
+
+                        variables.append(
+                            {"name": var_name, "type": var_type, "description": var_desc, "required": var_required}
+                        )
+
+                # If no variables found but this is a greeting workflow, add default user_name variable
+                if not variables and ("greeting" in name.lower()):
+                    variables.append(
+                        {"name": "user_name", "type": "string", "description": "User's name", "required": True}
+                    )
+
+                nodes.append({"id": node_id, "type": "start", "title": title, "desc": desc, "variables": variables})
+            elif node_type == "llm":
+                # Extract system prompt
+                system_prompt_match = re.search(
+                    rf'"id"\s*:\s*"{node_id}".*?"system_prompt"\s*:\s*"([^"]*)"', text, re.DOTALL
+                )
+                system_prompt = system_prompt_match.group(1) if system_prompt_match else "You are a helpful assistant"
+
+                # Extract user prompt
+                user_prompt_match = re.search(
+                    rf'"id"\s*:\s*"{node_id}".*?"user_prompt"\s*:\s*"([^"]*)"', text, re.DOTALL
+                )
+                user_prompt = user_prompt_match.group(1) if user_prompt_match else "Please answer the user's question"
+
+                nodes.append(
+                    {
+                        "id": node_id,
+                        "type": "llm",
+                        "title": title,
+                        "desc": desc,
+                        "provider": "zhipuai",
+                        "model": "glm-4-flash",
+                        "system_prompt": system_prompt,
+                        "user_prompt": user_prompt,
+                        "variables": [],
+                    }
+                )
+            elif node_type in ("template", "template-transform"):
+                # Extract template content
+                template_match = re.search(rf'"id"\s*:\s*"{node_id}".*?"template"\s*:\s*"([^"]*)"', text, re.DOTALL)
+                template = template_match.group(1) if template_match else ""
+
+                # Fix triple curly brace issue in template, replace {{{ with {{ and }}} with }}
+                template = template.replace("{{{", "{{").replace("}}}", "}}")
+
+                nodes.append(
+                    {
+                        "id": node_id,
+                        "type": "template-transform",
+                        "title": title,
+                        "desc": desc,
+                        "template": template,
+                        "variables": [],
+                    }
+                )
+            elif node_type == "end":
+                # Extract outputs
+                outputs = []
+                output_section_match = re.search(
+                    rf'"id"\s*:\s*"{node_id}".*?"outputs"\s*:\s*\[(.*?)\]', text, re.DOTALL
+                )
+
+                if output_section_match:
+                    output_section = output_section_match.group(1)
+                    output_matches = re.finditer(
+                        r'\{\s*"name"\s*:\s*"([^"]*)"\s*,\s*"type"\s*:\s*"([^"]*)"', output_section
+                    )
+
+                    for output_match in output_matches:
+                        output_name = output_match.group(1)
+                        output_type = output_match.group(2)
+
+                        # Extract source node
+                        source_node_match = re.search(
+                            rf'"name"\s*:\s*"{output_name}".*?"source_node"\s*:\s*"([^"]*)"', output_section, re.DOTALL
+                        )
+                        source_node = source_node_match.group(1) if source_node_match else ""
+
+                        # Extract source variable
+                        source_var_match = re.search(
+                            rf'"name"\s*:\s*"{output_name}".*?"source_variable"\s*:\s*"([^"]*)"',
+                            output_section,
+                            re.DOTALL,
+                        )
+                        source_var = source_var_match.group(1) if source_var_match else ""
+
+                        outputs.append(
+                            {
+                                "name": output_name,
+                                "type": output_type,
+                                "source_node": source_node,
+                                "source_variable": source_var,
+                            }
+                        )
+
+                nodes.append({"id": node_id, "type": "end", "title": title, "desc": desc, "outputs": outputs})
+            else:
+                # Other node types
+                nodes.append({"id": node_id, "type": node_type, "title": title, "desc": desc})
+
+        # Extract connections
+        connections = []
+        conn_matches = re.finditer(r'\{\s*"source"\s*:\s*"([^"]*)"\s*,\s*"target"\s*:\s*"([^"]*)"', text)
+
+        for match in conn_matches:
+            connections.append({"source": match.group(1), "target": match.group(2)})
+
+        return {"name": name, "description": description, "nodes": nodes, "connections": connections}

api/core/auto/workflow_generator/utils/prompts.py

@@ -0,0 +1,171 @@
+"""
+Prompt Template Collection
+Contains all prompt templates used for generating workflows
+"""
+
+# Default model configuration
+DEFAULT_MODEL_CONFIG = {
+    "provider": "zhipuai",
+    "model": "glm-4-flash",
+    "mode": "chat",
+    "completion_params": {"temperature": 0.7},
+}
+
+
+# Default system prompt
+DEFAULT_SYSTEM_PROMPT = "You are a workflow design expert who can design Dify workflows based on user requirements."
+
+
+# Code node template
+CODE_NODE_TEMPLATE = """def main(input_var):
+    # Process input variable
+    result = input_var
+
+    # Return a dictionary; keys must exactly match variable names defined in outputs
+    return {"output_var_name": result}"""
+
+
+def build_workflow_prompt(user_requirement: str) -> str:
+    """
+    Build workflow generation prompt
+
+    Args:
+        user_requirement: User requirement description
+
+    Returns:
+        Prompt string
+    """
+    # String concatenation to avoid brace escaping
+    prompt_part1 = (
+        """
+    Please design a Dify workflow based on the following user requirement:
+
+    User requirement: """
+        + user_requirement
+        + """
+
+    The description's language should align consistently with the user's requirements.
+    
+    Generate a concise workflow description containing the following node types:
+    - Start: Start node, defines workflow input parameters
+    - LLM: Large Language Model node for text generation
+    - Code: Code node to execute Python code
+    - Template: Template node for formatting outputs
+    - End: End node, defines workflow output
+
+    【Important Guidelines】:
+    1. When referencing variables in LLM nodes, use the format {{#nodeID.variable_name#}}, e.g., {{#1740019130520.user_question#}}, where 1740019130520 is the source node ID. Otherwise, in most cases, the user prompt should define a template to guide the LLM’s response.
+    2. Code nodes must define a `main` function that directly receives variables from upstream nodes as parameters; do not use template syntax inside the function.
+    3. Dictionary keys returned by Code nodes must exactly match the variable names defined in outputs.
+    4. Variables in Template nodes must strictly use double curly braces format "{{ variable_name }}"; note exactly two curly braces, neither one nor three. For example, "User question is: {{ user_question }}, answer: {{ answer }}". Triple curly braces such as "{{{ variable_name }}}" are strictly forbidden.
+    5. IMPORTANT: In Code nodes, the function parameter names MUST EXACTLY MATCH the variable names defined in that Code node. For example, if a Code node defines a variable with name "input_text" that receives data from an upstream node, the function parameter must also be named "input_text" (e.g., def main(input_text): ...).
+    6. CRITICAL: LLM nodes ALWAYS output their result in a variable named "text". When a Code node receives data from an LLM node, the source_variable MUST be "text". For example, if a Code node has a variable named "llm_output" that receives data from an LLM node, the source_variable should be "text", not "input_text" or any other name.
+
+    Return the workflow description in JSON format as follows:
+    ```json
+    {
+        "name": "Workflow Name",
+        "description": "Workflow description",
+        "nodes": [
+            {
+                "id": "node1",
+                "type": "start",
+                "title": "Start Node",
+                "description": "Description of the start node",
+                "variables": [
+                    {
+                        "name": "variable_name",
+                        "type": "string|number",
+                        "description": "Variable description",
+                        "required": true|false
+                    }
+                ]
+            },
+            {
+                "id": "node2",
+                "type": "llm",
+                "title": "LLM Node",
+                "description": "Description of LLM node",
+                "system_prompt": "System prompt",
+                "user_prompt": "User prompt, variables referenced using {{#nodeID.variable_name#}}, e.g., {{#node1.variable_name#}}",
+                "provider": "zhipuai",
+                "model": "glm-4-flash",
+                "variables": [
+                    {
+                        "name": "variable_name",
+                        "type": "string|number",
+                        "source_node": "node1",
+                        "source_variable": "variable_name"
+                    }
+                ]
+            },
+            {
+                "id": "node3",
+                "type": "code",
+                "title": "Code Node",
+                "description": "Description of the code node",
+                "code": "def main(input_var):\n    import re\n    match = re.search(r'Result[:：](.*?)(?=[.]|$)', input_var)\n    result = match.group(1).strip() if match else 'Not found'\n    return {'output': result}",
+                "variables": [
+                    {
+                        "name": "input_var",
+                        "type": "string|number",
+                        "source_node": "node2",
+                        "source_variable": "text"
+                    }
+                ],
+                "outputs": [
+                    {
+                        "name": "output_var_name",
+                        "type": "string|number|object"
+                    }
+                ]
+            },
+            {
+                "id": "node4",
+                "type": "template",
+                "title": "Template Node",
+                "description": "Description of the template node",
+                "template": "Template content using double curly braces, e.g.: The result is: {{ result }}",
+                "variables": [
+                    {
+                        "name": "variable_name",
+                        "type": "string|number",
+                        "source_node": "node3",
+                        "source_variable": "output_var_name"
+                    }
+                ]
+            },
+            {
+                "id": "node5",
+                "type": "end",
+                "title": "End Node",
+                "description": "Description of the end node",
+                "outputs": [
+                    {
+                        "name": "output_variable_name",
+                        "type": "string|number",
+                        "source_node": "node4",
+                        "source_variable": "output"
+                    }
+                ]
+            }
+        ],
+        "connections": [
+            {"source": "node1", "target": "node2"},
+            {"source": "node2", "target": "node3"},
+            {"source": "node3", "target": "node4"},
+            {"source": "node4", "target": "node5"}
+        ]
+    }
+    ```
+
+    Ensure the workflow logic is coherent, node connections are correct, and variable passing is logical.
+    Generate unique numeric IDs for each node, e.g., 1740019130520.
+    Generate appropriate unique names for each variable across the workflow.
+    Ensure all LLM nodes use provider "zhipuai" and model "glm-4-flash".
+
+    Note: LLM nodes usually return a long text; Code nodes typically require regex to extract relevant information.
+    """  # noqa: E501
+    )
+
+    return prompt_part1

api/core/auto/workflow_generator/utils/type_mapper.py

@@ -0,0 +1,50 @@
+"""
+Type Mapping Utility
+Used to map string types to Dify types
+"""
+
+from core.auto.node_types.common import InputVarType, VarType
+
+
+def map_var_type_to_input_type(var_type: str) -> InputVarType:
+    """
+    Map variable type to input variable type
+
+    Args:
+        var_type: Variable type string
+
+    Returns:
+        Input variable type
+    """
+    type_map = {
+        "string": InputVarType.text_input,
+        "number": InputVarType.number,
+        "boolean": InputVarType.select,
+        "object": InputVarType.json,
+        "array": InputVarType.json,
+        "file": InputVarType.file,
+    }
+
+    return type_map.get(var_type.lower(), InputVarType.text_input)
+
+
+def map_string_to_var_type(type_str: str) -> VarType:
+    """
+    Map string to variable type
+
+    Args:
+        type_str: Type string
+
+    Returns:
+        Variable type
+    """
+    type_map = {
+        "string": VarType.string,
+        "number": VarType.number,
+        "boolean": VarType.boolean,
+        "object": VarType.object,
+        "array": VarType.array,
+        "file": VarType.file,
+    }
+
+    return type_map.get(type_str.lower(), VarType.string)

api/core/auto/workflow_generator/workflow.py

@@ -0,0 +1,134 @@
+import json
+from typing import Any
+
+import yaml
+
+from core.auto.node_types.common import CompleteEdge, CompleteNode
+
+
+class Workflow:
+    """
+    Workflow class
+    """
+
+    def __init__(self, name: str, nodes: list[CompleteNode], edges: list[CompleteEdge]):
+        """
+        Initialize workflow
+
+        Args:
+            name: Workflow name
+            nodes: List of nodes
+            edges: List of edges
+        """
+        self.name = name
+        self.nodes = nodes
+        self.edges = edges
+
+    def to_dict(self) -> dict[str, Any]:
+        """
+        Convert workflow to dictionary
+
+        Returns:
+            Workflow dictionary
+        """
+        # Apply basic information (fixed template)
+        app_info = {
+            "description": "",
+            "icon": "🤖",
+            "icon_background": "#FFEAD5",
+            "mode": "workflow",
+            "name": self.name,
+            "use_icon_as_answer_icon": False,
+        }
+
+        # Feature configuration (fixed template)
+        features = {
+            "file_upload": {
+                "allowed_file_extensions": [".JPG", ".JPEG", ".PNG", ".GIF", ".WEBP", ".SVG"],
+                "allowed_file_types": ["image"],
+                "allowed_file_upload_methods": ["local_file", "remote_url"],
+                "enabled": False,
+                "fileUploadConfig": {
+                    "audio_file_size_limit": 50,
+                    "batch_count_limit": 5,
+                    "file_size_limit": 15,
+                    "image_file_size_limit": 10,
+                    "video_file_size_limit": 100,
+                },
+                "image": {"enabled": False, "number_limits": 3, "transfer_methods": ["local_file", "remote_url"]},
+                "number_limits": 3,
+            },
+            "opening_statement": "",
+            "retriever_resource": {"enabled": True},
+            "sensitive_word_avoidance": {"enabled": False},
+            "speech_to_text": {"enabled": False},
+            "suggested_questions": [],
+            "suggested_questions_after_answer": {"enabled": False},
+            "text_to_speech": {"enabled": False, "language": "", "voice": ""},
+        }
+
+        # View configuration (fixed template)
+        viewport = {"x": 92.96659905656679, "y": 79.13437154762897, "zoom": 0.9002006986311041}
+
+        # Nodes and edges
+        nodes_data = []
+        for node in self.nodes:
+            node_data = node.to_json()
+            nodes_data.append(node_data)
+
+        edges_data = []
+        for edge in self.edges:
+            edge_data = edge.to_json()
+            edges_data.append(edge_data)
+
+        # Build a complete workflow dictionary
+        workflow_dict = {
+            "app": app_info,
+            "kind": "app",
+            "version": "0.1.2",
+            "workflow": {
+                "conversation_variables": [],
+                "environment_variables": [],
+                "features": features,
+                "graph": {"edges": edges_data, "nodes": nodes_data, "viewport": viewport},
+            },
+        }
+
+        return workflow_dict
+
+    def save_to_yaml(self, file_path: str):
+        """
+        Save workflow to YAML file
+
+        Args:
+            file_path: File path
+        """
+        workflow_dict = self.to_dict()
+
+        with open(file_path, "w", encoding="utf-8") as f:
+            yaml.dump(workflow_dict, f, allow_unicode=True, sort_keys=False)
+
+        print(f"Workflow saved to: {file_path}")
+
+    def save_to_json(self, file_path: str):
+        """
+        Save workflow to JSON file
+
+        Args:
+            file_path: File path
+        """
+        workflow_dict = self.to_dict()
+
+        with open(file_path, "w", encoding="utf-8") as f:
+            json.dump(workflow_dict, f, indent=2, ensure_ascii=False)
+
+        print(f"Workflow saved to: {file_path}")
+
+    def to_yaml(self) -> str:
+        """
+        Convert workflow to YAML string
+
+        Returns:
+            YAML string
+        """
+        return yaml.dump(self.to_dict(), allow_unicode=True, sort_keys=False)

api/core/auto/workflow_generator/workflow_generator.py

@@ -0,0 +1,159 @@
+"""
+Workflow Generator
+Used to generate Dify workflows based on user requirements
+"""
+
+from pydantic import ValidationError
+
+from core.auto.workflow_generator.generators.edge_generator import EdgeGenerator
+from core.auto.workflow_generator.generators.layout_engine import LayoutEngine
+from core.auto.workflow_generator.generators.node_generator import NodeGenerator
+from core.auto.workflow_generator.models.workflow_description import WorkflowDescription
+from core.auto.workflow_generator.utils.config_manager import ConfigManager
+from core.auto.workflow_generator.utils.debug_manager import DebugManager
+from core.auto.workflow_generator.utils.llm_client import LLMClient
+from core.auto.workflow_generator.utils.prompts import build_workflow_prompt
+from core.auto.workflow_generator.workflow import Workflow
+from core.model_manager import ModelInstance
+
+
+class WorkflowGenerator:
+    """Workflow generator for creating Dify workflows based on user requirements"""
+
+    def __init__(self, model_instance: ModelInstance, config_dir: str = "config", debug_enabled: bool = False):
+        """
+        Initialize workflow generator
+
+        Args:
+            api_key: LLM API key
+            config_dir: Configuration directory path
+            model_name: Specified model name, uses default model if not specified
+            debug_enabled: Whether to enable debug mode
+        """
+        # Load configuration
+        self.config = ConfigManager(config_dir)
+
+        # Initialize debug manager
+        self.debug_manager = DebugManager(config=self.config.get("debug", default={}), debug_enabled=debug_enabled)
+
+        # Get model configuration
+
+        # Initialize LLM client
+        self.llm_client = LLMClient(model_instance=model_instance, debug_manager=self.debug_manager)
+
+    def generate_workflow(self, user_requirement: str) -> str:
+        """
+        Generate workflow based on user requirements
+
+        Args:
+            user_requirement: User requirement description
+            output_path: Output file path, uses default path from config if None
+
+        Returns:
+            Generated workflow YAML file path
+        """
+        print("\n===== Starting Workflow Generation =====")
+        print(f"User requirement: {user_requirement}")
+
+        # Save user requirement
+        if self.debug_manager.should_save("workflow"):
+            self.debug_manager.save_text(user_requirement, "user_requirement.txt", "workflow")
+
+        # Use default path from config if output path not specified
+
+        # Step 1: Generate simple workflow description
+        print("\n----- Step 1: Generating Simple Workflow Description -----")
+        workflow_description = self._generate_workflow_description(user_requirement)
+        print(f"Workflow name: {workflow_description.name}")
+        print(f"Workflow description: {workflow_description.description}")
+        print(f"Number of nodes: {len(workflow_description.nodes)}")
+        print(f"Number of connections: {len(workflow_description.connections)}")
+
+        # Save workflow description
+        if self.debug_manager.should_save("workflow"):
+            self.debug_manager.save_json(workflow_description.dict(), "workflow_description.json", "workflow")
+
+        # Step 2: Parse description and generate nodes
+        print("\n----- Step 2: Parsing Description, Generating Nodes -----")
+        nodes = NodeGenerator.create_nodes(workflow_description.nodes)
+        print(f"Generated nodes: {len(nodes)}")
+        for i, node in enumerate(nodes):
+            print(f"Node {i + 1}: ID={node.id}, Type={node.data.type.value}, Title={node.data.title}")
+
+        # Save node information
+        if self.debug_manager.should_save("workflow"):
+            nodes_data = [node.dict() for node in nodes]
+            self.debug_manager.save_json(nodes_data, "nodes.json", "workflow")
+
+        # Step 3: Generate edges
+        print("\n----- Step 3: Generating Edges -----")
+        edges = EdgeGenerator.create_edges(nodes, workflow_description.connections)
+        print(f"Generated edges: {len(edges)}")
+        for i, edge in enumerate(edges):
+            print(f"Edge {i + 1}: ID={edge.id}, Source={edge.source}, Target={edge.target}")
+
+        # Save edge information
+        if self.debug_manager.should_save("workflow"):
+            edges_data = [edge.dict() for edge in edges]
+            self.debug_manager.save_json(edges_data, "edges.json", "workflow")
+
+        # Step 4: Apply layout
+        print("\n----- Step 4: Applying Layout -----")
+        LayoutEngine.apply_topological_layout(nodes, edges)
+        print("Applied topological sort layout")
+
+        # Save nodes with layout
+        if self.debug_manager.should_save("workflow"):
+            nodes_with_layout = [node.dict() for node in nodes]
+            self.debug_manager.save_json(nodes_with_layout, "nodes_with_layout.json", "workflow")
+
+        # Step 5: Generate YAML
+        print("\n----- Step 5: Generating YAML -----")
+        workflow = Workflow(name=workflow_description.name, nodes=nodes, edges=edges)
+
+        # Ensure output directory exists
+
+        # Save as YAML
+
+        # Save final YAML
+        print("\n===== Workflow Generation Complete =====")
+        return workflow.to_yaml()
+
+    def _generate_workflow_description(self, user_requirement: str) -> WorkflowDescription:
+        """
+        Generate simple workflow description using LLM
+
+        Args:
+            user_requirement: User requirement description
+
+        Returns:
+            Simple workflow description
+        """
+        # Build prompt
+        print("Building prompt...")
+        prompt = build_workflow_prompt(user_requirement)
+
+        # Call LLM
+        print("Calling LLM to generate workflow description...")
+        response_text = self.llm_client.generate(prompt)
+
+        # Parse LLM response
+        print("Parsing LLM response...")
+        workflow_description_dict = self.llm_client.extract_json(response_text)
+
+        try:
+            # Parse into WorkflowDescription object
+            print("Converting JSON to WorkflowDescription object...")
+            workflow_description = WorkflowDescription.parse_obj(workflow_description_dict)
+            return workflow_description
+        except ValidationError as e:
+            # If parsing fails, print error and raise exception
+            error_msg = f"Failed to parse workflow description: {e}"
+            print(error_msg)
+
+            # Save error information
+            if self.debug_manager.should_save("workflow"):
+                self.debug_manager.save_text(str(e), "validation_error.txt", "workflow")
+                self.debug_manager.save_json(workflow_description_dict, "invalid_workflow_description.json", "workflow")
+
+            raise ValueError(error_msg)

api/core/rag/splitter/text_splitter.py

@@ -129,13 +129,6 @@ class TextSplitter(BaseDocumentTransformer, ABC):
                     while total > self._chunk_overlap or (
                         total + _len + (separator_len if len(current_doc) > 0 else 0) > self._chunk_size and total > 0
                     ):
-                        if current_doc and len(current_doc[0]) == 0:
-                            current_doc = current_doc[1:]
-                            continue
-
-                        if len(current_doc) == 0:
-                            break
-
                         total -= self._length_function([current_doc[0]])[0] + (
                             separator_len if len(current_doc) > 1 else 0
                         )

api/core/tools/tool_manager.py

@@ -765,17 +765,22 @@ class ToolManager:
 
     @classmethod
     def generate_builtin_tool_icon_url(cls, provider_id: str) -> str:
-        return (
-            dify_config.CONSOLE_API_URL
-            + "/console/api/workspaces/current/tool-provider/builtin/"
-            + provider_id
-            + "/icon"
+        return str(
+            URL(dify_config.CONSOLE_API_URL or "/")
+            / "console"
+            / "api"
+            / "workspaces"
+            / "current"
+            / "tool-provider"
+            / "builtin"
+            / provider_id
+            / "icon"
         )
 
     @classmethod
     def generate_plugin_tool_icon_url(cls, tenant_id: str, filename: str) -> str:
         return str(
-            URL(dify_config.CONSOLE_API_URL)
+            URL(dify_config.CONSOLE_API_URL or "/")
             / "console"
             / "api"
             / "workspaces"

api/fields/workflow_app_log_fields.py

@@ -17,8 +17,8 @@ workflow_app_log_partial_fields = {
 
 workflow_app_log_pagination_fields = {
     "page": fields.Integer,
-    "limit": fields.Integer(attribute="per_page"),
+    "limit": fields.Integer,
     "total": fields.Integer,
-    "has_more": fields.Boolean(attribute="has_next"),
-    "data": fields.List(fields.Nested(workflow_app_log_partial_fields), attribute="items"),
+    "has_more": fields.Boolean,
+    "data": fields.List(fields.Nested(workflow_app_log_partial_fields)),
 }

api/fields/workflow_fields.py

@@ -45,7 +45,9 @@ workflow_fields = {
     "graph": fields.Raw(attribute="graph_dict"),
     "features": fields.Raw(attribute="features_dict"),
     "hash": fields.String(attribute="unique_hash"),
-    "version": fields.String(attribute="version"),
+    "version": fields.String,
+    "marked_name": fields.String,
+    "marked_comment": fields.String,
     "created_by": fields.Nested(simple_account_fields, attribute="created_by_account"),
     "created_at": TimestampField,
     "updated_by": fields.Nested(simple_account_fields, attribute="updated_by_account", allow_null=True),

api/migrations/versions/2025_03_03_1436-ee79d9b1c156_add_marked_name_and_marked_comment_in_.py

@@ -0,0 +1,29 @@
+"""add marked_name and marked_comment in workflows
+
+Revision ID: ee79d9b1c156
+Revises: 4413929e1ec2
+Create Date: 2025-03-03 14:36:05.750346
+
+"""
+from alembic import op
+import models as models
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = 'ee79d9b1c156'
+down_revision = '5511c782ee4c'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    with op.batch_alter_table('workflows', schema=None) as batch_op:
+        batch_op.add_column(sa.Column('marked_name', sa.String(), nullable=False, server_default=''))
+        batch_op.add_column(sa.Column('marked_comment', sa.String(), nullable=False, server_default=''))
+
+
+def downgrade():
+    with op.batch_alter_table('workflows', schema=None) as batch_op:
+        batch_op.drop_column('marked_comment')
+        batch_op.drop_column('marked_name')

api/models/workflow.py

@@ -2,7 +2,8 @@ import json
 from collections.abc import Mapping, Sequence
 from datetime import UTC, datetime
 from enum import Enum
-from typing import TYPE_CHECKING, Any, Optional, Union
+from typing import TYPE_CHECKING, Any, Optional, Self, Union
+from uuid import uuid4
 
 if TYPE_CHECKING:
     from models.model import AppMode
@@ -108,7 +109,9 @@ class Workflow(Base):
     tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
     app_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
     type: Mapped[str] = mapped_column(db.String(255), nullable=False)
-    version: Mapped[str] = mapped_column(db.String(255), nullable=False)
+    version: Mapped[str]
+    marked_name: Mapped[str] = mapped_column(default="", server_default="")
+    marked_comment: Mapped[str] = mapped_column(default="", server_default="")
     graph: Mapped[str] = mapped_column(sa.Text)
     _features: Mapped[str] = mapped_column("features", sa.TEXT)
     created_by: Mapped[str] = mapped_column(StringUUID, nullable=False)
@@ -127,8 +130,9 @@ class Workflow(Base):
         "conversation_variables", db.Text, nullable=False, server_default="{}"
     )
 
-    def __init__(
-        self,
+    @classmethod
+    def new(
+        cls,
         *,
         tenant_id: str,
         app_id: str,
@@ -139,16 +143,25 @@ class Workflow(Base):
         created_by: str,
         environment_variables: Sequence[Variable],
         conversation_variables: Sequence[Variable],
-    ):
-        self.tenant_id = tenant_id
-        self.app_id = app_id
-        self.type = type
-        self.version = version
-        self.graph = graph
-        self.features = features
-        self.created_by = created_by
-        self.environment_variables = environment_variables or []
-        self.conversation_variables = conversation_variables or []
+        marked_name: str = "",
+        marked_comment: str = "",
+    ) -> Self:
+        workflow = Workflow()
+        workflow.id = str(uuid4())
+        workflow.tenant_id = tenant_id
+        workflow.app_id = app_id
+        workflow.type = type
+        workflow.version = version
+        workflow.graph = graph
+        workflow.features = features
+        workflow.created_by = created_by
+        workflow.environment_variables = environment_variables or []
+        workflow.conversation_variables = conversation_variables or []
+        workflow.marked_name = marked_name
+        workflow.marked_comment = marked_comment
+        workflow.created_at = datetime.now(UTC).replace(tzinfo=None)
+        workflow.updated_at = workflow.created_at
+        return workflow
 
     @property
     def created_by_account(self):
@@ -341,19 +354,6 @@ class WorkflowRunStatus(StrEnum):
     STOPPED = "stopped"
     PARTIAL_SUCCESSED = "partial-succeeded"
 
-    @classmethod
-    def value_of(cls, value: str) -> "WorkflowRunStatus":
-        """
-        Get value of given mode.
-
-        :param value: mode value
-        :return: mode
-        """
-        for mode in cls:
-            if mode.value == value:
-                return mode
-        raise ValueError(f"invalid workflow run status value {value}")
-
 
 class WorkflowRun(Base):
     """

api/pyproject.toml

@@ -151,6 +151,7 @@ pytest-benchmark = "~4.0.0"
 pytest-env = "~1.1.3"
 pytest-mock = "~3.14.0"
 types-beautifulsoup4 = "~4.12.0.20241020"
+types-deprecated = "~1.2.15.20250304"
 types-flask-cors = "~5.0.0.20240902"
 types-flask-migrate = "~4.1.0.20250112"
 types-html5lib = "~1.1.11.20241018"

api/services/errors/workflow_service.py

@@ -0,0 +1,10 @@
+class WorkflowInUseError(ValueError):
+    """Raised when attempting to delete a workflow that's in use by an app"""
+
+    pass
+
+
+class DraftWorkflowDeletionError(ValueError):
+    """Raised when attempting to delete a draft workflow"""
+
+    pass

api/services/tools/tools_transform_service.py

@@ -29,7 +29,9 @@ logger = logging.getLogger(__name__)
 class ToolTransformService:
     @classmethod
     def get_plugin_icon_url(cls, tenant_id: str, filename: str) -> str:
-        url_prefix = URL(dify_config.CONSOLE_API_URL) / "console" / "api" / "workspaces" / "current" / "plugin" / "icon"
+        url_prefix = (
+            URL(dify_config.CONSOLE_API_URL or "/") / "console" / "api" / "workspaces" / "current" / "plugin" / "icon"
+        )
         return str(url_prefix % {"tenant_id": tenant_id, "filename": filename})
 
     @classmethod
@@ -37,7 +39,9 @@ class ToolTransformService:
         """
         get tool provider icon url
         """
-        url_prefix = URL(dify_config.CONSOLE_API_URL) / "console" / "api" / "workspaces" / "current" / "tool-provider"
+        url_prefix = (
+            URL(dify_config.CONSOLE_API_URL or "/") / "console" / "api" / "workspaces" / "current" / "tool-provider"
+        )
 
         if provider_type == ToolProviderType.BUILT_IN.value:
             return str(url_prefix / "builtin" / provider_name / "icon")

api/services/workflow_app_service.py

@@ -1,30 +1,46 @@
 import uuid
+from datetime import datetime
 
-from flask_sqlalchemy.pagination import Pagination
-from sqlalchemy import and_, or_
+from sqlalchemy import and_, func, or_, select
+from sqlalchemy.orm import Session
 
-from extensions.ext_database import db
 from models import App, EndUser, WorkflowAppLog, WorkflowRun
 from models.enums import CreatedByRole
 from models.workflow import WorkflowRunStatus
 
 
 class WorkflowAppService:
-    def get_paginate_workflow_app_logs(self, app_model: App, args: dict) -> Pagination:
+    def get_paginate_workflow_app_logs(
+        self,
+        *,
+        session: Session,
+        app_model: App,
+        keyword: str | None = None,
+        status: WorkflowRunStatus | None = None,
+        created_at_before: datetime | None = None,
+        created_at_after: datetime | None = None,
+        page: int = 1,
+        limit: int = 20,
+    ) -> dict:
         """
-        Get paginate workflow app logs
-        :param app: app model
-        :param args: request args
-        :return:
+        Get paginate workflow app logs using SQLAlchemy 2.0 style
+        :param session: SQLAlchemy session
+        :param app_model: app model
+        :param keyword: search keyword
+        :param status: filter by status
+        :param created_at_before: filter logs created before this timestamp
+        :param created_at_after: filter logs created after this timestamp
+        :param page: page number
+        :param limit: items per page
+        :return: Pagination object
         """
-        query = db.select(WorkflowAppLog).where(
+        # Build base statement using SQLAlchemy 2.0 style
+        stmt = select(WorkflowAppLog).where(
             WorkflowAppLog.tenant_id == app_model.tenant_id, WorkflowAppLog.app_id == app_model.id
         )
 
-        status = WorkflowRunStatus.value_of(args.get("status", "")) if args.get("status") else None
-        keyword = args["keyword"]
         if keyword or status:
-            query = query.join(WorkflowRun, WorkflowRun.id == WorkflowAppLog.workflow_run_id)
+            stmt = stmt.join(WorkflowRun, WorkflowRun.id == WorkflowAppLog.workflow_run_id)
 
         if keyword:
             keyword_like_val = f"%{keyword[:30].encode('unicode_escape').decode('utf-8')}%".replace(r"\u", r"\\u")
@@ -40,20 +56,40 @@ class WorkflowAppService:
             if keyword_uuid:
                 keyword_conditions.append(WorkflowRun.id == keyword_uuid)
 
-            query = query.outerjoin(
+            stmt = stmt.outerjoin(
                 EndUser,
                 and_(WorkflowRun.created_by == EndUser.id, WorkflowRun.created_by_role == CreatedByRole.END_USER),
-            ).filter(or_(*keyword_conditions))
+            ).where(or_(*keyword_conditions))
 
         if status:
-            # join with workflow_run and filter by status
-            query = query.filter(WorkflowRun.status == status.value)
+            stmt = stmt.where(WorkflowRun.status == status)
 
-        query = query.order_by(WorkflowAppLog.created_at.desc())
+        # Add time-based filtering
+        if created_at_before:
+            stmt = stmt.where(WorkflowAppLog.created_at <= created_at_before)
 
-        pagination = db.paginate(query, page=args["page"], per_page=args["limit"], error_out=False)
+        if created_at_after:
+            stmt = stmt.where(WorkflowAppLog.created_at >= created_at_after)
 
-        return pagination
+        stmt = stmt.order_by(WorkflowAppLog.created_at.desc())
+
+        # Get total count using the same filters
+        count_stmt = select(func.count()).select_from(stmt.subquery())
+        total = session.scalar(count_stmt) or 0
+
+        # Apply pagination limits
+        offset_stmt = stmt.offset((page - 1) * limit).limit(limit)
+
+        # Execute query and get items
+        items = list(session.scalars(offset_stmt).all())
+
+        return {
+            "page": page,
+            "limit": limit,
+            "total": total,
+            "has_more": total > page * limit,
+            "data": items,
+        }
 
     @staticmethod
     def _safe_parse_uuid(value: str):

api/services/workflow_service.py

@@ -5,7 +5,8 @@ from datetime import UTC, datetime
 from typing import Any, Optional
 from uuid import uuid4
 
-from sqlalchemy import desc
+from sqlalchemy import select
+from sqlalchemy.orm import Session
 
 from core.app.apps.advanced_chat.app_config_manager import AdvancedChatAppConfigManager
 from core.app.apps.workflow.app_config_manager import WorkflowAppConfigManager
@@ -36,6 +37,8 @@ from models.workflow import (
 from services.errors.app import WorkflowHashNotEqualError
 from services.workflow.workflow_converter import WorkflowConverter
 
+from .errors.workflow_service import DraftWorkflowDeletionError, WorkflowInUseError
+
 
 class WorkflowService:
     """
@@ -79,22 +82,38 @@ class WorkflowService:
 
         return workflow
 
-    def get_all_published_workflow(self, app_model: App, page: int, limit: int) -> tuple[list[Workflow], bool]:
+    def get_all_published_workflow(
+        self,
+        *,
+        session: Session,
+        app_model: App,
+        page: int,
+        limit: int,
+        user_id: str | None,
+        named_only: bool = False,
+    ) -> tuple[Sequence[Workflow], bool]:
         """
         Get published workflow with pagination
         """
         if not app_model.workflow_id:
             return [], False
 
-        workflows = (
-            db.session.query(Workflow)
-            .filter(Workflow.app_id == app_model.id)
-            .order_by(desc(Workflow.version))
-            .offset((page - 1) * limit)
+        stmt = (
+            select(Workflow)
+            .where(Workflow.app_id == app_model.id)
+            .order_by(Workflow.version.desc())
             .limit(limit + 1)
-            .all()
+            .offset((page - 1) * limit)
         )
 
+        if user_id:
+            stmt = stmt.where(Workflow.created_by == user_id)
+
+        if named_only:
+            stmt = stmt.where(Workflow.marked_name != "")
+
+        workflows = session.scalars(stmt).all()
+
         has_more = len(workflows) > limit
         if has_more:
             workflows = workflows[:-1]
@@ -157,23 +176,26 @@ class WorkflowService:
         # return draft workflow
         return workflow
 
-    def publish_workflow(self, app_model: App, account: Account, draft_workflow: Optional[Workflow] = None) -> Workflow:
-        """
-        Publish workflow from draft
-
-        :param app_model: App instance
-        :param account: Account instance
-        :param draft_workflow: Workflow instance
-        """
-        if not draft_workflow:
-            # fetch draft workflow by app_model
-            draft_workflow = self.get_draft_workflow(app_model=app_model)
-
+    def publish_workflow(
+        self,
+        *,
+        session: Session,
+        app_model: App,
+        account: Account,
+        marked_name: str = "",
+        marked_comment: str = "",
+    ) -> Workflow:
+        draft_workflow_stmt = select(Workflow).where(
+            Workflow.tenant_id == app_model.tenant_id,
+            Workflow.app_id == app_model.id,
+            Workflow.version == "draft",
+        )
+        draft_workflow = session.scalar(draft_workflow_stmt)
         if not draft_workflow:
             raise ValueError("No valid workflow found.")
 
         # create new workflow
-        workflow = Workflow(
+        workflow = Workflow.new(
             tenant_id=app_model.tenant_id,
             app_id=app_model.id,
             type=draft_workflow.type,
@@ -183,15 +205,12 @@ class WorkflowService:
             created_by=account.id,
             environment_variables=draft_workflow.environment_variables,
             conversation_variables=draft_workflow.conversation_variables,
+            marked_name=marked_name,
+            marked_comment=marked_comment,
         )
 
         # commit db session changes
-        db.session.add(workflow)
-        db.session.flush()
-        db.session.commit()
-
-        app_model.workflow_id = workflow.id
-        db.session.commit()
+        session.add(workflow)
 
         # trigger app workflow events
         app_published_workflow_was_updated.send(app_model, published_workflow=workflow)
@@ -436,3 +455,65 @@ class WorkflowService:
             )
         else:
             raise ValueError(f"Invalid app mode: {app_model.mode}")
+
+    def update_workflow(
+        self, *, session: Session, workflow_id: str, tenant_id: str, account_id: str, data: dict
+    ) -> Optional[Workflow]:
+        """
+        Update workflow attributes
+
+        :param session: SQLAlchemy database session
+        :param workflow_id: Workflow ID
+        :param tenant_id: Tenant ID
+        :param account_id: Account ID (for permission check)
+        :param data: Dictionary containing fields to update
+        :return: Updated workflow or None if not found
+        """
+        stmt = select(Workflow).where(Workflow.id == workflow_id, Workflow.tenant_id == tenant_id)
+        workflow = session.scalar(stmt)
+
+        if not workflow:
+            return None
+
+        allowed_fields = ["marked_name", "marked_comment"]
+
+        for field, value in data.items():
+            if field in allowed_fields:
+                setattr(workflow, field, value)
+
+        workflow.updated_by = account_id
+        workflow.updated_at = datetime.now(UTC).replace(tzinfo=None)
+
+        return workflow
+
+    def delete_workflow(self, *, session: Session, workflow_id: str, tenant_id: str) -> bool:
+        """
+        Delete a workflow
+
+        :param session: SQLAlchemy database session
+        :param workflow_id: Workflow ID
+        :param tenant_id: Tenant ID
+        :return: True if successful
+        :raises: ValueError if workflow not found
+        :raises: WorkflowInUseError if workflow is in use
+        :raises: DraftWorkflowDeletionError if workflow is a draft version
+        """
+        stmt = select(Workflow).where(Workflow.id == workflow_id, Workflow.tenant_id == tenant_id)
+        workflow = session.scalar(stmt)
+
+        if not workflow:
+            raise ValueError(f"Workflow with ID {workflow_id} not found")
+
+        # Check if workflow is a draft version
+        if workflow.version == "draft":
+            raise DraftWorkflowDeletionError("Cannot delete draft workflow versions")
+
+        # Check if this workflow is currently referenced by an app
+        stmt = select(App).where(App.workflow_id == workflow_id)
+        app = session.scalar(stmt)
+        if app:
+            # Cannot delete a workflow that's currently in use by an app
+            raise WorkflowInUseError(f"Cannot delete workflow that is currently in use by app '{app.name}'")
+
+        session.delete(workflow)
+        return True

api/tests/unit_tests/libs/test_yarl.py

@@ -18,6 +18,12 @@ def test_yarl_urls():
     assert str(URL("https://dify.ai/api") / "v1") == expected_3
     assert str(URL("https://dify.ai/api/") / "v1") == expected_3
 
+    expected_4 = "api"
+    assert str(URL("") / "api") == expected_4
+
+    expected_5 = "/api"
+    assert str(URL("/") / "api") == expected_5
+
     with pytest.raises(ValueError) as e1:
         str(URL("https://dify.ai") / "/api")
     assert str(e1.value) == "Appending path '/api' starting from slash is forbidden"

api/tests/unit_tests/services/workflow/test_workflow_service.py

@@ -0,0 +1,162 @@
+from unittest.mock import MagicMock
+
+import pytest
+
+from models.model import App
+from models.workflow import Workflow
+from services.workflow_service import WorkflowService
+
+
+class TestWorkflowService:
+    @pytest.fixture
+    def workflow_service(self):
+        return WorkflowService()
+
+    @pytest.fixture
+    def mock_app(self):
+        app = MagicMock(spec=App)
+        app.id = "app-id-1"
+        app.workflow_id = "workflow-id-1"
+        app.tenant_id = "tenant-id-1"
+        return app
+
+    @pytest.fixture
+    def mock_workflows(self):
+        workflows = []
+        for i in range(5):
+            workflow = MagicMock(spec=Workflow)
+            workflow.id = f"workflow-id-{i}"
+            workflow.app_id = "app-id-1"
+            workflow.created_at = f"2023-01-0{5 - i}"  # Descending date order
+            workflow.created_by = "user-id-1" if i % 2 == 0 else "user-id-2"
+            workflow.marked_name = f"Workflow {i}" if i % 2 == 0 else ""
+            workflows.append(workflow)
+        return workflows
+
+    def test_get_all_published_workflow_no_workflow_id(self, workflow_service, mock_app):
+        mock_app.workflow_id = None
+        mock_session = MagicMock()
+
+        workflows, has_more = workflow_service.get_all_published_workflow(
+            session=mock_session, app_model=mock_app, page=1, limit=10, user_id=None
+        )
+
+        assert workflows == []
+        assert has_more is False
+        mock_session.scalars.assert_not_called()
+
+    def test_get_all_published_workflow_basic(self, workflow_service, mock_app, mock_workflows):
+        mock_session = MagicMock()
+        mock_scalar_result = MagicMock()
+        mock_scalar_result.all.return_value = mock_workflows[:3]
+        mock_session.scalars.return_value = mock_scalar_result
+
+        workflows, has_more = workflow_service.get_all_published_workflow(
+            session=mock_session, app_model=mock_app, page=1, limit=3, user_id=None
+        )
+
+        assert workflows == mock_workflows[:3]
+        assert has_more is False
+        mock_session.scalars.assert_called_once()
+
+    def test_get_all_published_workflow_pagination(self, workflow_service, mock_app, mock_workflows):
+        mock_session = MagicMock()
+        mock_scalar_result = MagicMock()
+        # Return 4 items when limit is 3, which should indicate has_more=True
+        mock_scalar_result.all.return_value = mock_workflows[:4]
+        mock_session.scalars.return_value = mock_scalar_result
+
+        workflows, has_more = workflow_service.get_all_published_workflow(
+            session=mock_session, app_model=mock_app, page=1, limit=3, user_id=None
+        )
+
+        # Should return only the first 3 items
+        assert len(workflows) == 3
+        assert workflows == mock_workflows[:3]
+        assert has_more is True
+
+        # Test page 2
+        mock_scalar_result.all.return_value = mock_workflows[3:]
+        mock_session.scalars.return_value = mock_scalar_result
+
+        workflows, has_more = workflow_service.get_all_published_workflow(
+            session=mock_session, app_model=mock_app, page=2, limit=3, user_id=None
+        )
+
+        assert len(workflows) == 2
+        assert has_more is False
+
+    def test_get_all_published_workflow_user_filter(self, workflow_service, mock_app, mock_workflows):
+        mock_session = MagicMock()
+        mock_scalar_result = MagicMock()
+        # Filter workflows for user-id-1
+        filtered_workflows = [w for w in mock_workflows if w.created_by == "user-id-1"]
+        mock_scalar_result.all.return_value = filtered_workflows
+        mock_session.scalars.return_value = mock_scalar_result
+
+        workflows, has_more = workflow_service.get_all_published_workflow(
+            session=mock_session, app_model=mock_app, page=1, limit=10, user_id="user-id-1"
+        )
+
+        assert workflows == filtered_workflows
+        assert has_more is False
+        mock_session.scalars.assert_called_once()
+
+        # Verify that the select contains a user filter clause
+        args = mock_session.scalars.call_args[0][0]
+        assert "created_by" in str(args)
+
+    def test_get_all_published_workflow_named_only(self, workflow_service, mock_app, mock_workflows):
+        mock_session = MagicMock()
+        mock_scalar_result = MagicMock()
+        # Filter workflows that have a marked_name
+        named_workflows = [w for w in mock_workflows if w.marked_name]
+        mock_scalar_result.all.return_value = named_workflows
+        mock_session.scalars.return_value = mock_scalar_result
+
+        workflows, has_more = workflow_service.get_all_published_workflow(
+            session=mock_session, app_model=mock_app, page=1, limit=10, user_id=None, named_only=True
+        )
+
+        assert workflows == named_workflows
+        assert has_more is False
+        mock_session.scalars.assert_called_once()
+
+        # Verify that the select contains a named_only filter clause
+        args = mock_session.scalars.call_args[0][0]
+        assert "marked_name !=" in str(args)
+
+    def test_get_all_published_workflow_combined_filters(self, workflow_service, mock_app, mock_workflows):
+        mock_session = MagicMock()
+        mock_scalar_result = MagicMock()
+        # Combined filter: user-id-1 and has marked_name
+        filtered_workflows = [w for w in mock_workflows if w.created_by == "user-id-1" and w.marked_name]
+        mock_scalar_result.all.return_value = filtered_workflows
+        mock_session.scalars.return_value = mock_scalar_result
+
+        workflows, has_more = workflow_service.get_all_published_workflow(
+            session=mock_session, app_model=mock_app, page=1, limit=10, user_id="user-id-1", named_only=True
+        )
+
+        assert workflows == filtered_workflows
+        assert has_more is False
+        mock_session.scalars.assert_called_once()
+
+        # Verify that both filters are applied
+        args = mock_session.scalars.call_args[0][0]
+        assert "created_by" in str(args)
+        assert "marked_name !=" in str(args)
+
+    def test_get_all_published_workflow_empty_result(self, workflow_service, mock_app):
+        mock_session = MagicMock()
+        mock_scalar_result = MagicMock()
+        mock_scalar_result.all.return_value = []
+        mock_session.scalars.return_value = mock_scalar_result
+
+        workflows, has_more = workflow_service.get_all_published_workflow(
+            session=mock_session, app_model=mock_app, page=1, limit=10, user_id=None
+        )
+
+        assert workflows == []
+        assert has_more is False
+        mock_session.scalars.assert_called_once()

docker/.env.example

@@ -971,3 +971,5 @@ FORCE_VERIFYING_SIGNATURE=true
 
 PLUGIN_PYTHON_ENV_INIT_TIMEOUT=120
 PLUGIN_MAX_EXECUTION_TIMEOUT=600
+# PIP_MIRROR_URL=https://pypi.tuna.tsinghua.edu.cn/simple
+PIP_MIRROR_URL=

docker/docker-compose-template.yaml

@@ -91,8 +91,6 @@ services:
       interval: 1s
       timeout: 3s
       retries: 30
-    ports:
-      - '${EXPOSE_DB_PORT:-5432}:5432'
 
   # The redis cache.
   redis:
@@ -151,6 +149,7 @@ services:
       FORCE_VERIFYING_SIGNATURE: ${FORCE_VERIFYING_SIGNATURE:-true}
       PYTHON_ENV_INIT_TIMEOUT: ${PLUGIN_PYTHON_ENV_INIT_TIMEOUT:-120}
       PLUGIN_MAX_EXECUTION_TIMEOUT: ${PLUGIN_MAX_EXECUTION_TIMEOUT:-600}
+      PIP_MIRROR_URL: ${PIP_MIRROR_URL:-}
     ports:
       - "${EXPOSE_PLUGIN_DEBUGGING_PORT:-5003}:${PLUGIN_DEBUGGING_PORT:-5003}"
     volumes:

docker/docker-compose.middleware.yaml

@@ -90,6 +90,7 @@ services:
       FORCE_VERIFYING_SIGNATURE: ${FORCE_VERIFYING_SIGNATURE:-true}
       PYTHON_ENV_INIT_TIMEOUT: ${PLUGIN_PYTHON_ENV_INIT_TIMEOUT:-120}
       PLUGIN_MAX_EXECUTION_TIMEOUT: ${PLUGIN_MAX_EXECUTION_TIMEOUT:-600}
+      PIP_MIRROR_URL: ${PIP_MIRROR_URL:-}
     ports:
       - "${EXPOSE_PLUGIN_DAEMON_PORT:-5002}:${PLUGIN_DAEMON_PORT:-5002}"
       - "${EXPOSE_PLUGIN_DEBUGGING_PORT:-5003}:${PLUGIN_DEBUGGING_PORT:-5003}"

docker/docker-compose.yaml

@@ -415,6 +415,7 @@ x-shared-env: &shared-api-worker-env
   FORCE_VERIFYING_SIGNATURE: ${FORCE_VERIFYING_SIGNATURE:-true}
   PLUGIN_PYTHON_ENV_INIT_TIMEOUT: ${PLUGIN_PYTHON_ENV_INIT_TIMEOUT:-120}
   PLUGIN_MAX_EXECUTION_TIMEOUT: ${PLUGIN_MAX_EXECUTION_TIMEOUT:-600}
+  PIP_MIRROR_URL: ${PIP_MIRROR_URL:-}
 
 services:
   # API service
@@ -508,8 +509,6 @@ services:
       interval: 1s
       timeout: 3s
       retries: 30
-    ports:
-      - '${EXPOSE_DB_PORT:-5432}:5432'
 
   # The redis cache.
   redis:
@@ -568,6 +567,7 @@ services:
       FORCE_VERIFYING_SIGNATURE: ${FORCE_VERIFYING_SIGNATURE:-true}
       PYTHON_ENV_INIT_TIMEOUT: ${PLUGIN_PYTHON_ENV_INIT_TIMEOUT:-120}
       PLUGIN_MAX_EXECUTION_TIMEOUT: ${PLUGIN_MAX_EXECUTION_TIMEOUT:-600}
+      PIP_MIRROR_URL: ${PIP_MIRROR_URL:-}
     ports:
       - "${EXPOSE_PLUGIN_DEBUGGING_PORT:-5003}:${PLUGIN_DEBUGGING_PORT:-5003}"
     volumes:

docker/middleware.env.example

@@ -118,3 +118,5 @@ FORCE_VERIFYING_SIGNATURE=true
 
 PLUGIN_PYTHON_ENV_INIT_TIMEOUT=120
 PLUGIN_MAX_EXECUTION_TIMEOUT=600
+# PIP_MIRROR_URL=https://pypi.tuna.tsinghua.edu.cn/simple
+PIP_MIRROR_URL=

docker/nginx/conf.d/default.conf.template

@@ -4,19 +4,6 @@ server {
     listen ${NGINX_PORT};
     server_name ${NGINX_SERVER_NAME};
 
-    # Rule 1: Handle application entry points (preserve /app/{id})
-    location ~ ^/app/[a-f0-9-]+$ {
-      proxy_pass http://api:5001;
-      include proxy.conf;
-    }
-
-    # Rule 2: Handle static resource requests (remove /app/{id} prefix)
-    location ~ ^/app/[a-f0-9-]+/(console/api/.*)$ {
-      rewrite ^/app/[a-f0-9-]+/(.*)$ /$1 break;
-      proxy_pass http://api:5001;
-      include proxy.conf;
-    }
-
     location /console/api {
       proxy_pass http://api:5001;
       include proxy.conf;

web/app/(commonLayout)/apps/NewAppCard.tsx

@@ -12,6 +12,8 @@ import CreateFromDSLModal, { CreateFromDSLModalTab } from '@/app/components/app/
 import { useProviderContext } from '@/context/provider-context'
 import { FileArrow01, FilePlus01, FilePlus02 } from '@/app/components/base/icons/src/vender/line/files'
 import cn from '@/utils/classnames'
+import AutoGenerateModal from '@/app/components/app/auto-generate-modal'
+import { Agent } from '@/app/components/base/icons/src/vender/workflow'
 
 export type CreateAppCardProps = {
   className?: string
@@ -28,7 +30,7 @@ const CreateAppCard = forwardRef<HTMLDivElement, CreateAppCardProps>(({ classNam
   const [showNewAppTemplateDialog, setShowNewAppTemplateDialog] = useState(false)
   const [showNewAppModal, setShowNewAppModal] = useState(false)
   const [showCreateFromDSLModal, setShowCreateFromDSLModal] = useState(!!dslUrl)
-
+  const [showAutoGenerateModal, setShowAutoGenerateModal] = useState(false)
   const activeTab = useMemo(() => {
     if (dslUrl)
       return CreateFromDSLModalTab.FROM_URL
@@ -39,7 +41,7 @@ const CreateAppCard = forwardRef<HTMLDivElement, CreateAppCardProps>(({ classNam
   return (
     <div
       ref={ref}
-      className={cn('relative col-span-1 inline-flex flex-col justify-between h-[160px] bg-components-card-bg rounded-xl border-[0.5px] border-components-card-border', className)}
+      className={cn('relative col-span-1 inline-flex flex-col justify-between h-[180px] bg-components-card-bg rounded-xl border-[0.5px] border-components-card-border', className)}
     >
       <div className='grow p-2 rounded-t-xl'>
         <div className='px-6 pt-2 pb-1 text-xs font-medium leading-[18px] text-text-tertiary'>{t('app.createApp')}</div>
@@ -57,6 +59,12 @@ const CreateAppCard = forwardRef<HTMLDivElement, CreateAppCardProps>(({ classNam
           <FileArrow01 className='shrink-0 mr-2 w-4 h-4' />
           {t('app.importDSL')}
         </button>
+        <button
+          onClick={() => setShowAutoGenerateModal(true)}
+          className='w-full flex items-center px-6 py-[7px] rounded-lg text-[13px] font-medium leading-[18px] text-text-tertiary cursor-pointer hover:text-text-secondary hover:bg-state-base-hover'>
+          <Agent className='shrink-0 mr-2 w-4 h-4' />
+          {t('app.autoGenerate')}
+        </button>
       </div>
 
       <CreateAppModal
@@ -101,6 +109,15 @@ const CreateAppCard = forwardRef<HTMLDivElement, CreateAppCardProps>(({ classNam
             onSuccess()
         }}
       />
+      <AutoGenerateModal
+        isShow={showAutoGenerateModal}
+        onClose={() => setShowAutoGenerateModal(false)}
+        onSuccess={() => {
+          onPlanInfoChanged()
+          if (onSuccess)
+            onSuccess()
+        }}
+      />
     </div>
   )
 })

web/app/components/app/auto-generate-modal/index.tsx

@@ -0,0 +1,203 @@
+import type { FC } from 'react'
+import React from 'react'
+import cn from 'classnames'
+import useBoolean from 'ahooks/lib/useBoolean'
+import { useTranslation } from 'react-i18next'
+import { generateWorkflow } from '@/service/debug'
+import { type Model, ModelModeType } from '@/types/app'
+import Modal from '@/app/components/base/modal'
+import Button from '@/app/components/base/button'
+import { useContext } from 'use-context-selector'
+
+import Loading from '@/app/components/base/loading'
+import { useModelListAndDefaultModelAndCurrentProviderAndModel } from '@/app/components/header/account-setting/model-provider-page/hooks'
+import { ModelTypeEnum } from '@/app/components/header/account-setting/model-provider-page/declarations'
+import ModelIcon from '@/app/components/header/account-setting/model-provider-page/model-icon'
+import ModelName from '@/app/components/header/account-setting/model-provider-page/model-name'
+import { importDSL } from '@/service/apps'
+import { DSLImportMode, DSLImportStatus } from '@/models/app'
+import { NEED_REFRESH_APP_LIST_KEY } from '@/config'
+import { getRedirection } from '@/utils/app-redirection'
+import { useAppContext } from '@/context/app-context'
+import { useRouter } from 'next/navigation'
+import { ToastContext } from '../../base/toast'
+import Generator from '../../base/icons/src/vender/other/Generator'
+export type IGetCodeGeneratorResProps = {
+  isShow: boolean
+  onClose: () => void
+  onSuccess?: () => void
+}
+
+export const AutoGenerateModal: FC<IGetCodeGeneratorResProps> = (
+  {
+    isShow,
+    onClose,
+    onSuccess,
+  },
+) => {
+  const { notify } = useContext(ToastContext)
+
+  const {
+    currentProvider,
+    currentModel,
+  } = useModelListAndDefaultModelAndCurrentProviderAndModel(ModelTypeEnum.textGeneration)
+  const { t } = useTranslation()
+  const { push } = useRouter()
+
+  const [instruction, setInstruction] = React.useState<string>('')
+  const [isLoading, { setTrue: setLoadingTrue, setFalse: setLoadingFalse }] = useBoolean(false)
+  const { isCurrentWorkspaceEditor } = useAppContext()
+  const [res, setRes] = React.useState<string | null>(null)
+  const isValid = () => {
+    if (instruction.trim() === '') {
+      notify({
+        type: 'error',
+        message: t('common.errorMsg.fieldRequired', {
+          field: t('appDebug.code.instruction'),
+        }),
+      })
+      return false
+    }
+    return true
+  }
+  const model: Model = {
+    provider: currentProvider?.provider || '',
+    name: currentModel?.model || '',
+    mode: ModelModeType.chat,
+    // This is a fixed parameter
+    completion_params: {
+      temperature: 0.7,
+      max_tokens: 0,
+      top_p: 0,
+      echo: false,
+      stop: [],
+      presence_penalty: 0,
+      frequency_penalty: 0,
+    },
+  }
+  const isInLLMNode = true
+  const onGenerate = async () => {
+    if (!isValid())
+      return
+    if (isLoading)
+      return
+    setLoadingTrue()
+    try {
+      const res = await generateWorkflow({
+        instruction,
+        model_config: model,
+      })
+      setRes(res)
+    }
+    finally {
+      setLoadingFalse()
+    }
+  }
+
+  const renderLoading = (
+    <div className='w-0 grow flex flex-col items-center justify-center h-full space-y-3'>
+      <Loading />
+      <div className='text-[13px] text-gray-400'>{t('appDebug.autoGenerate.loading')}</div>
+    </div>
+  )
+  const renderNoData = (
+    <div className='w-0 grow flex flex-col items-center px-8 justify-center h-full space-y-3'>
+      <Generator className='w-14 h-14 text-gray-300' />
+      <div className='leading-5 text-center text-[13px] font-normal text-gray-400'>
+        <div>{t('appDebug.autoGenerate.noDataLine1')}</div>
+        <div>{t('appDebug.autoGenerate.noDataLine2')}</div>
+      </div>
+    </div>
+  )
+
+  return (
+    <Modal
+      isShow={isShow}
+      onClose={onClose}
+      className='!p-0 min-w-[1140px]'
+      closable
+    >
+      <div className='relative flex h-[680px] flex-wrap'>
+        <div className='w-[570px] shrink-0 p-8 h-full overflow-y-auto border-r border-gray-100'>
+          <div className='mb-8'>
+            <div className={'leading-[28px] text-lg font-bold'}>{t('appDebug.autoGenerate.title')}</div>
+            <div className='mt-1 text-[13px] font-normal text-gray-500'>{t('appDebug.autoGenerate.description')}</div>
+          </div>
+          <div className='flex items-center'>
+            <ModelIcon
+              className='shrink-0 mr-1.5'
+              provider={currentProvider}
+              modelName={currentModel?.model}
+            />
+            <ModelName
+              className='grow'
+              modelItem={currentModel!}
+              showMode
+              showFeatures
+            />
+          </div>
+          <div className='mt-6'>
+            <div className='text-[0px]'>
+              <div className='mb-2 leading-5 text-sm font-medium text-gray-900'>{t('appDebug.autoGenerate.instruction')}</div>
+              <textarea
+                className="w-full h-[200px] overflow-y-auto px-3 py-2 text-sm bg-gray-50 rounded-lg"
+                placeholder={t('appDebug.autoGenerate.instructionPlaceholder') || ''}
+                value={instruction}
+                onChange={e => setInstruction(e.target.value)}
+              />
+            </div>
+
+            <div className='mt-5 flex justify-end'>
+              <Button
+                className='flex space-x-1'
+                variant='primary'
+                onClick={onGenerate}
+                disabled={isLoading}
+              >
+                <Generator className='w-4 h-4 text-white' />
+                <span className='text-xs font-semibold text-white'>{t('appDebug.autoGenerate.generate')}</span>
+              </Button>
+            </div>
+          </div>
+        </div>
+        {isLoading && renderLoading}
+        {!isLoading && !res && renderNoData}
+        {(!isLoading && res) && (
+          <div className='w-0 grow p-6 pb-0 h-full'>
+            <div className='shrink-0 mb-3 leading-[160%] text-base font-semibold text-gray-800'>{t('appDebug.autoGenerate.resTitle')}</div>
+            <div className={cn('max-h-[555px] overflow-y-auto', !isInLLMNode && 'pb-2')}>
+              {res}
+            </div>
+
+            <div className='flex justify-end py-4 bg-white'>
+              <Button onClick={onClose}>{t('common.operation.cancel')}</Button>
+              <Button variant='primary' className='ml-2' onClick={async () => {
+                const response = await importDSL({
+                  mode: DSLImportMode.YAML_CONTENT,
+                  yaml_content: res || '',
+                })
+                if (!response)
+                  return
+
+                const { status, app_id } = response
+                if (status === DSLImportStatus.COMPLETED || status === DSLImportStatus.COMPLETED_WITH_WARNINGS) {
+                  if (onSuccess)
+                    onSuccess()
+                }
+                notify({
+                  type: status === DSLImportStatus.COMPLETED ? 'success' : 'warning',
+                  message: t(status === DSLImportStatus.COMPLETED ? 'app.newApp.appCreated' : 'app.newApp.caution'),
+                  children: status === DSLImportStatus.COMPLETED_WITH_WARNINGS && t('app.newApp.appCreateDSLWarning'),
+                })
+                localStorage.setItem(NEED_REFRESH_APP_LIST_KEY, '1')
+                getRedirection(isCurrentWorkspaceEditor, { id: app_id }, push)
+              }}>{t('appDebug.autoGenerate.apply')}</Button>
+            </div>
+          </div>
+        )}
+      </div>
+    </Modal>
+  )
+}
+
+export default React.memo(AutoGenerateModal)

web/app/components/app/workflow-log/filter.tsx

@@ -2,11 +2,29 @@
 import type { FC } from 'react'
 import React from 'react'
 import { useTranslation } from 'react-i18next'
+import dayjs from 'dayjs'
+import { RiCalendarLine } from '@remixicon/react'
+import quarterOfYear from 'dayjs/plugin/quarterOfYear'
 import type { QueryParam } from './index'
 import Chip from '@/app/components/base/chip'
 import Input from '@/app/components/base/input'
+dayjs.extend(quarterOfYear)
 
-interface IFilterProps {
+const today = dayjs()
+
+export const TIME_PERIOD_MAPPING: { [key: string]: { value: number; name: string } } = {
+  1: { value: 0, name: 'today' },
+  2: { value: 7, name: 'last7days' },
+  3: { value: 28, name: 'last4weeks' },
+  4: { value: today.diff(today.subtract(3, 'month'), 'day'), name: 'last3months' },
+  5: { value: today.diff(today.subtract(12, 'month'), 'day'), name: 'last12months' },
+  6: { value: today.diff(today.startOf('month'), 'day'), name: 'monthToDate' },
+  7: { value: today.diff(today.startOf('quarter'), 'day'), name: 'quarterToDate' },
+  8: { value: today.diff(today.startOf('year'), 'day'), name: 'yearToDate' },
+  9: { value: -1, name: 'allTime' },
+}
+
+type IFilterProps = {
   queryParams: QueryParam
   setQueryParams: (v: QueryParam) => void
 }
@@ -27,6 +45,17 @@ const Filter: FC<IFilterProps> = ({ queryParams, setQueryParams }: IFilterProps)
           { value: 'stopped', name: 'Stop' },
         ]}
       />
+      <Chip
+        className='min-w-[150px]'
+        panelClassName='w-[270px]'
+        leftIcon={<RiCalendarLine className='h-4 w-4 text-text-secondary' />}
+        value={queryParams.period}
+        onSelect={(item) => {
+          setQueryParams({ ...queryParams, period: item.value })
+        }}
+        onClear={() => setQueryParams({ ...queryParams, period: '9' })}
+        items={Object.entries(TIME_PERIOD_MAPPING).map(([k, v]) => ({ value: k, name: t(`appLog.filter.period.${v.name}`) }))}
+      />
       <Input
         wrapperClassName='w-[200px]'
         showLeftIcon

web/app/components/app/workflow-log/index.tsx

@@ -4,21 +4,30 @@ import React, { useState } from 'react'
 import useSWR from 'swr'
 import { usePathname } from 'next/navigation'
 import { useDebounce } from 'ahooks'
+import { omit } from 'lodash-es'
+import dayjs from 'dayjs'
+import utc from 'dayjs/plugin/utc'
+import timezone from 'dayjs/plugin/timezone'
 import { Trans, useTranslation } from 'react-i18next'
 import Link from 'next/link'
 import List from './list'
-import Filter from './filter'
+import Filter, { TIME_PERIOD_MAPPING } from './filter'
 import Pagination from '@/app/components/base/pagination'
 import Loading from '@/app/components/base/loading'
 import { fetchWorkflowLogs } from '@/service/log'
 import { APP_PAGE_LIMIT } from '@/config'
 import type { App, AppMode } from '@/types/app'
+import { useAppContext } from '@/context/app-context'
+
+dayjs.extend(utc)
+dayjs.extend(timezone)
 
 export type ILogsProps = {
   appDetail: App
 }
 
 export type QueryParam = {
+  period: string
   status?: string
   keyword?: string
 }
@@ -48,7 +57,8 @@ const EmptyElement: FC<{ appUrl: string }> = ({ appUrl }) => {
 
 const Logs: FC<ILogsProps> = ({ appDetail }) => {
   const { t } = useTranslation()
-  const [queryParams, setQueryParams] = useState<QueryParam>({ status: 'all' })
+  const { userProfile: { timezone } } = useAppContext()
+  const [queryParams, setQueryParams] = useState<QueryParam>({ status: 'all', period: '2' })
   const [currPage, setCurrPage] = React.useState<number>(0)
   const debouncedQueryParams = useDebounce(queryParams, { wait: 500 })
   const [limit, setLimit] = React.useState<number>(APP_PAGE_LIMIT)
@@ -58,6 +68,13 @@ const Logs: FC<ILogsProps> = ({ appDetail }) => {
     limit,
     ...(debouncedQueryParams.status !== 'all' ? { status: debouncedQueryParams.status } : {}),
     ...(debouncedQueryParams.keyword ? { keyword: debouncedQueryParams.keyword } : {}),
+    ...((debouncedQueryParams.period !== '9')
+      ? {
+        created_at__after: dayjs().subtract(TIME_PERIOD_MAPPING[debouncedQueryParams.period].value, 'day').startOf('day').tz(timezone).format('YYYY-MM-DDTHH:mm:ssZ'),
+        created_at__before: dayjs().endOf('day').tz(timezone).format('YYYY-MM-DDTHH:mm:ssZ'),
+      }
+      : {}),
+    ...omit(debouncedQueryParams, ['period', 'status']),
   }
 
   const getWebAppType = (appType: AppMode) => {

web/app/components/datasets/documents/detail/index.tsx

@@ -23,7 +23,7 @@ import FloatRightContainer from '@/app/components/base/float-right-container'
 import useBreakpoints, { MediaType } from '@/hooks/use-breakpoints'
 import { LayoutRight2LineMod } from '@/app/components/base/icons/src/public/knowledge'
 import { useCheckSegmentBatchImportProgress, useChildSegmentListKey, useSegmentBatchImport, useSegmentListKey } from '@/service/knowledge/use-segment'
-import { useDocumentDetail, useDocumentMetadata } from '@/service/knowledge/use-document'
+import { useDocumentDetail, useDocumentMetadata, useInvalidDocumentList } from '@/service/knowledge/use-document'
 import { useInvalid } from '@/service/use-base'
 
 type DocumentContextValue = {
@@ -152,17 +152,22 @@ const DocumentDetail: FC<Props> = ({ datasetId, documentId }) => {
 
   const invalidChunkList = useInvalid(useSegmentListKey)
   const invalidChildChunkList = useInvalid(useChildSegmentListKey)
+  const invalidDocumentList = useInvalidDocumentList(datasetId)
 
   const handleOperate = (operateName?: string) => {
+    invalidDocumentList()
     if (operateName === 'delete') {
       backToPrev()
     }
     else {
       detailMutate()
-      setTimeout(() => {
-        invalidChunkList()
-        invalidChildChunkList()
-      }, 5000)
+      // If operation is not rename, refresh the chunk list after 5 seconds
+      if (operateName) {
+        setTimeout(() => {
+          invalidChunkList()
+          invalidChildChunkList()
+        }, 5000)
+      }
     }
   }
 

web/app/components/datasets/documents/index.tsx

@@ -1,11 +1,10 @@
 'use client'
 import type { FC } from 'react'
 import React, { useCallback, useEffect, useMemo, useState } from 'react'
-import useSWR from 'swr'
 import { useTranslation } from 'react-i18next'
 import { useRouter } from 'next/navigation'
 import { useDebounce, useDebounceFn } from 'ahooks'
-import { groupBy, omit } from 'lodash-es'
+import { groupBy } from 'lodash-es'
 import { PlusIcon } from '@heroicons/react/24/solid'
 import { RiExternalLinkLine } from '@remixicon/react'
 import AutoDisabledDocument from '../common/document-status-with-action/auto-disabled-document'
@@ -15,16 +14,16 @@ import Loading from '@/app/components/base/loading'
 import Button from '@/app/components/base/button'
 import Input from '@/app/components/base/input'
 import { get } from '@/service/base'
-import { createDocument, fetchDocuments } from '@/service/datasets'
+import { createDocument } from '@/service/datasets'
 import { useDatasetDetailContext } from '@/context/dataset-detail'
 import { NotionPageSelectorModal } from '@/app/components/base/notion-page-selector'
 import type { NotionPage } from '@/models/common'
 import type { CreateDocumentReq } from '@/models/datasets'
-import { DataSourceType } from '@/models/datasets'
+import { DataSourceType, ProcessMode } from '@/models/datasets'
 import IndexFailed from '@/app/components/datasets/common/document-status-with-action/index-failed'
 import { useProviderContext } from '@/context/provider-context'
 import cn from '@/utils/classnames'
-import { useInvalidDocumentDetailKey } from '@/service/knowledge/use-document'
+import { useDocumentList, useInvalidDocumentDetailKey, useInvalidDocumentList } from '@/service/knowledge/use-document'
 import { useInvalid } from '@/service/use-base'
 import { useChildSegmentListKey, useSegmentListKey } from '@/service/knowledge/use-segment'
 
@@ -73,12 +72,12 @@ const EmptyElement: FC<{ canAdd: boolean; onClick: () => void; type?: 'upload' |
   </div>
 }
 
-interface IDocumentsProps {
+type IDocumentsProps = {
   datasetId: string
 }
 
 export const fetcher = (url: string) => get(url, {}, {})
-const DEFAULT_LIMIT = 15
+const DEFAULT_LIMIT = 10
 
 const Documents: FC<IDocumentsProps> = ({ datasetId }) => {
   const { t } = useTranslation()
@@ -99,33 +98,33 @@ const Documents: FC<IDocumentsProps> = ({ datasetId }) => {
 
   const debouncedSearchValue = useDebounce(searchValue, { wait: 500 })
 
-  const query = useMemo(() => {
-    return { page: currPage + 1, limit, keyword: debouncedSearchValue, fetch: isDataSourceNotion ? true : '' }
-  }, [currPage, debouncedSearchValue, isDataSourceNotion, limit])
-
-  const { data: documentsRes, mutate, isLoading: isListLoading } = useSWR(
-    {
-      action: 'fetchDocuments',
-      datasetId,
-      params: query,
+  const { data: documentsRes, isFetching: isListLoading } = useDocumentList({
+    datasetId,
+    query: {
+      page: currPage + 1,
+      limit,
+      keyword: debouncedSearchValue,
     },
-    apiParams => fetchDocuments(omit(apiParams, 'action')),
-    { refreshInterval: (isDataSourceNotion && timerCanRun) ? 2500 : 0 },
-  )
+    refetchInterval: (isDataSourceNotion && timerCanRun) ? 2500 : 0,
+  })
+
+  const invalidDocumentList = useInvalidDocumentList(datasetId)
 
-  const [isMuting, setIsMuting] = useState(false)
   useEffect(() => {
-    if (!isListLoading && isMuting)
-      setIsMuting(false)
-  }, [isListLoading, isMuting])
+    if (documentsRes) {
+      const totalPages = Math.ceil(documentsRes.total / limit)
+      if (totalPages < currPage + 1)
+        setCurrPage(totalPages === 0 ? 0 : totalPages - 1)
+    }
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [documentsRes])
 
   const invalidDocumentDetail = useInvalidDocumentDetailKey()
   const invalidChunkList = useInvalid(useSegmentListKey)
   const invalidChildChunkList = useInvalid(useChildSegmentListKey)
 
   const handleUpdate = useCallback(() => {
-    setIsMuting(true)
-    mutate()
+    invalidDocumentList()
     invalidDocumentDetail()
     setTimeout(() => {
       invalidChunkList()
@@ -175,8 +174,6 @@ const Documents: FC<IDocumentsProps> = ({ datasetId }) => {
     router.push(`/datasets/${datasetId}/documents/create`)
   }
 
-  const isLoading = isListLoading // !documentsRes && !error
-
   const handleSaveNotionPageSelected = async (selectedPages: NotionPage[]) => {
     const workspacesMap = groupBy(selectedPages, 'workspace_id')
     const workspaces = Object.keys(workspacesMap).map((workspaceId) => {
@@ -209,7 +206,7 @@ const Documents: FC<IDocumentsProps> = ({ datasetId }) => {
       indexing_technique: dataset?.indexing_technique,
       process_rule: {
         rules: {},
-        mode: 'automatic',
+        mode: ProcessMode.general,
       },
     } as CreateDocumentReq
 
@@ -217,7 +214,7 @@ const Documents: FC<IDocumentsProps> = ({ datasetId }) => {
       datasetId,
       body: params,
     })
-    mutate()
+    invalidDocumentList()
     setTimerCanRun(true)
     // mutateDatasetIndexingStatus(undefined, { revalidate: true })
     setNotionPageSelectorModalVisible(false)
@@ -272,7 +269,7 @@ const Documents: FC<IDocumentsProps> = ({ datasetId }) => {
             )}
           </div>
         </div>
-        {(isLoading && !isMuting)
+        {isListLoading
           ? <Loading type='app' />
           : total > 0
             ? <List

web/app/components/datasets/documents/list.tsx

@@ -500,121 +500,123 @@ const DocumentList: FC<IDocumentListProps> = ({
   }
 
   return (
-    <div className='relative w-full h-full overflow-x-auto'>
-      <table className={`min-w-[700px] max-w-full w-full border-collapse border-0 text-sm mt-3 ${s.documentTable}`}>
-        <thead className="h-8 leading-8 border-b border-divider-subtle text-text-tertiary font-medium text-xs uppercase">
-          <tr>
-            <td className='w-12'>
-              <div className='flex items-center' onClick={e => e.stopPropagation()}>
-                <Checkbox
-                  className='shrink-0 mr-2'
-                  checked={isAllSelected}
-                  mixed={!isAllSelected && isSomeSelected}
-                  onCheck={onSelectedAll}
-                />
-                #
-              </div>
-            </td>
-            <td>
-              <div className='flex'>
-                {t('datasetDocuments.list.table.header.fileName')}
-              </div>
-            </td>
-            <td className='w-[130px]'>{t('datasetDocuments.list.table.header.chunkingMode')}</td>
-            <td className='w-24'>{t('datasetDocuments.list.table.header.words')}</td>
-            <td className='w-44'>{t('datasetDocuments.list.table.header.hitCount')}</td>
-            <td className='w-44'>
-              <div className='flex items-center' onClick={onClickSort}>
-                {t('datasetDocuments.list.table.header.uploadTime')}
-                <ArrowDownIcon className={cn('ml-0.5 h-3 w-3 stroke-current stroke-2 cursor-pointer', enableSort ? 'text-text-tertiary' : 'text-text-disabled')} />
-              </div>
-            </td>
-            <td className='w-40'>{t('datasetDocuments.list.table.header.status')}</td>
-            <td className='w-20'>{t('datasetDocuments.list.table.header.action')}</td>
-          </tr>
-        </thead>
-        <tbody className="text-text-secondary">
-          {localDocs.map((doc, index) => {
-            const isFile = doc.data_source_type === DataSourceType.FILE
-            const fileType = isFile ? doc.data_source_detail_dict?.upload_file?.extension : ''
-            return <tr
-              key={doc.id}
-              className={'border-b border-divider-subtle h-8 hover:bg-background-default-hover cursor-pointer'}
-              onClick={() => {
-                router.push(`/datasets/${datasetId}/documents/${doc.id}`)
-              }}>
-              <td className='text-left align-middle text-text-tertiary text-xs'>
+    <div className='flex flex-col relative w-full h-full'>
+      <div className='grow overflow-x-auto'>
+        <table className={`min-w-[700px] max-w-full w-full border-collapse border-0 text-sm mt-3 ${s.documentTable}`}>
+          <thead className="h-8 leading-8 border-b border-divider-subtle text-text-tertiary font-medium text-xs uppercase">
+            <tr>
+              <td className='w-12'>
                 <div className='flex items-center' onClick={e => e.stopPropagation()}>
                   <Checkbox
                     className='shrink-0 mr-2'
-                    checked={selectedIds.includes(doc.id)}
-                    onCheck={() => {
-                      onSelectedIdChange(
-                        selectedIds.includes(doc.id)
-                          ? selectedIds.filter(id => id !== doc.id)
-                          : [...selectedIds, doc.id],
-                      )
-                    }}
+                    checked={isAllSelected}
+                    mixed={!isAllSelected && isSomeSelected}
+                    onCheck={onSelectedAll}
                   />
-                  {/* {doc.position} */}
-                  {index + 1}
+                  #
                 </div>
               </td>
               <td>
-                <div className={'group flex items-center mr-6 hover:mr-0 max-w-[460px]'}>
-                  <div className='shrink-0'>
-                    {doc?.data_source_type === DataSourceType.NOTION && <NotionIcon className='inline-flex -mt-[3px] mr-1.5 align-middle' type='page' src={doc.data_source_info.notion_page_icon} />}
-                    {doc?.data_source_type === DataSourceType.FILE && <FileTypeIcon type={extensionToFileType(doc?.data_source_info?.upload_file?.extension ?? fileType)} className='mr-1.5' />}
-                    {doc?.data_source_type === DataSourceType.WEB && <Globe01 className='inline-flex -mt-[3px] mr-1.5 align-middle' />}
-                  </div>
-                  <span className='text-sm truncate grow-1'>{doc.name}</span>
-                  <div className='group-hover:flex group-hover:ml-auto hidden shrink-0'>
-                    <Tooltip
-                      popupContent={t('datasetDocuments.list.table.rename')}
-                    >
-                      <div
-                        className='p-1 rounded-md cursor-pointer hover:bg-state-base-hover'
-                        onClick={(e) => {
-                          e.stopPropagation()
-                          handleShowRenameModal(doc)
-                        }}
-                      >
-                        <Edit03 className='w-4 h-4 text-text-tertiary' />
-                      </div>
-                    </Tooltip>
-                  </div>
+                <div className='flex'>
+                  {t('datasetDocuments.list.table.header.fileName')}
                 </div>
               </td>
-              <td>
-                <ChunkingModeLabel
-                  isGeneralMode={isGeneralMode}
-                  isQAMode={isQAMode}
-                />
-              </td>
-              <td>{renderCount(doc.word_count)}</td>
-              <td>{renderCount(doc.hit_count)}</td>
-              <td className='text-text-secondary text-[13px]'>
-                {formatTime(doc.created_at, t('datasetHitTesting.dateTimeFormat') as string)}
-              </td>
-              <td>
-                {
-                  (['indexing', 'splitting', 'parsing', 'cleaning'].includes(doc.indexing_status) && doc?.data_source_type === DataSourceType.NOTION)
-                    ? <ProgressBar percent={doc.percent || 0} />
-                    : <StatusItem status={doc.display_status} />
-                }
-              </td>
-              <td>
-                <OperationAction
-                  embeddingAvailable={embeddingAvailable}
-                  datasetId={datasetId}
-                  detail={pick(doc, ['name', 'enabled', 'archived', 'id', 'data_source_type', 'doc_form'])}
-                  onUpdate={onUpdate}
-                />
+              <td className='w-[130px]'>{t('datasetDocuments.list.table.header.chunkingMode')}</td>
+              <td className='w-24'>{t('datasetDocuments.list.table.header.words')}</td>
+              <td className='w-44'>{t('datasetDocuments.list.table.header.hitCount')}</td>
+              <td className='w-44'>
+                <div className='flex items-center' onClick={onClickSort}>
+                  {t('datasetDocuments.list.table.header.uploadTime')}
+                  <ArrowDownIcon className={cn('ml-0.5 h-3 w-3 stroke-current stroke-2 cursor-pointer', enableSort ? 'text-text-tertiary' : 'text-text-disabled')} />
+                </div>
               </td>
+              <td className='w-40'>{t('datasetDocuments.list.table.header.status')}</td>
+              <td className='w-20'>{t('datasetDocuments.list.table.header.action')}</td>
             </tr>
-          })}
-        </tbody>
-      </table>
+          </thead>
+          <tbody className="text-text-secondary">
+            {localDocs.map((doc, index) => {
+              const isFile = doc.data_source_type === DataSourceType.FILE
+              const fileType = isFile ? doc.data_source_detail_dict?.upload_file?.extension : ''
+              return <tr
+                key={doc.id}
+                className={'border-b border-divider-subtle h-8 hover:bg-background-default-hover cursor-pointer'}
+                onClick={() => {
+                  router.push(`/datasets/${datasetId}/documents/${doc.id}`)
+                }}>
+                <td className='text-left align-middle text-text-tertiary text-xs'>
+                  <div className='flex items-center' onClick={e => e.stopPropagation()}>
+                    <Checkbox
+                      className='shrink-0 mr-2'
+                      checked={selectedIds.includes(doc.id)}
+                      onCheck={() => {
+                        onSelectedIdChange(
+                          selectedIds.includes(doc.id)
+                            ? selectedIds.filter(id => id !== doc.id)
+                            : [...selectedIds, doc.id],
+                        )
+                      }}
+                    />
+                    {/* {doc.position} */}
+                    {index + 1}
+                  </div>
+                </td>
+                <td>
+                  <div className={'group flex items-center mr-6 hover:mr-0 max-w-[460px]'}>
+                    <div className='shrink-0'>
+                      {doc?.data_source_type === DataSourceType.NOTION && <NotionIcon className='inline-flex mt-[-3px] mr-1.5 align-middle' type='page' src={doc.data_source_info.notion_page_icon} />}
+                      {doc?.data_source_type === DataSourceType.FILE && <FileTypeIcon type={extensionToFileType(doc?.data_source_info?.upload_file?.extension ?? fileType)} className='mr-1.5' />}
+                      {doc?.data_source_type === DataSourceType.WEB && <Globe01 className='inline-flex mt-[-3px] mr-1.5 align-middle' />}
+                    </div>
+                    <span className='text-sm truncate grow-1'>{doc.name}</span>
+                    <div className='group-hover:flex group-hover:ml-auto hidden shrink-0'>
+                      <Tooltip
+                        popupContent={t('datasetDocuments.list.table.rename')}
+                      >
+                        <div
+                          className='p-1 rounded-md cursor-pointer hover:bg-state-base-hover'
+                          onClick={(e) => {
+                            e.stopPropagation()
+                            handleShowRenameModal(doc)
+                          }}
+                        >
+                          <Edit03 className='w-4 h-4 text-text-tertiary' />
+                        </div>
+                      </Tooltip>
+                    </div>
+                  </div>
+                </td>
+                <td>
+                  <ChunkingModeLabel
+                    isGeneralMode={isGeneralMode}
+                    isQAMode={isQAMode}
+                  />
+                </td>
+                <td>{renderCount(doc.word_count)}</td>
+                <td>{renderCount(doc.hit_count)}</td>
+                <td className='text-text-secondary text-[13px]'>
+                  {formatTime(doc.created_at, t('datasetHitTesting.dateTimeFormat') as string)}
+                </td>
+                <td>
+                  {
+                    (['indexing', 'splitting', 'parsing', 'cleaning'].includes(doc.indexing_status) && doc?.data_source_type === DataSourceType.NOTION)
+                      ? <ProgressBar percent={doc.percent || 0} />
+                      : <StatusItem status={doc.display_status} />
+                  }
+                </td>
+                <td>
+                  <OperationAction
+                    embeddingAvailable={embeddingAvailable}
+                    datasetId={datasetId}
+                    detail={pick(doc, ['name', 'enabled', 'archived', 'id', 'data_source_type', 'doc_form'])}
+                    onUpdate={onUpdate}
+                  />
+                </td>
+              </tr>
+            })}
+          </tbody>
+        </table>
+      </div>
       {(selectedIds.length > 0) && (
         <BatchAction
           className='absolute left-0 bottom-16 z-20'
@@ -629,10 +631,10 @@ const DocumentList: FC<IDocumentListProps> = ({
         />
       )}
       {/* Show Pagination only if the total is more than the limit */}
-      {pagination.total && pagination.total > (pagination.limit || 10) && (
+      {pagination.total && (
         <Pagination
           {...pagination}
-          className='absolute bottom-0 left-0 w-full px-0 pb-0'
+          className='shrink-0 w-full px-0 pb-0'
         />
       )}
 

web/app/components/workflow/nodes/_base/components/output-vars.tsx

@@ -42,7 +42,7 @@ export const VarItem: FC<VarItemProps> = ({
     <div className='py-1'>
       <div className='flex leading-[18px] items-center'>
         <div className='code-sm-semibold text-text-secondary'>{name}</div>
-        <div className='ml-2 system-xs-regular text-text-tertiary'>{type}</div>
+        <div className='ml-2 system-xs-regular text-text-tertiary capitalize'>{type}</div>
       </div>
       <div className='mt-0.5 system-xs-regular text-text-tertiary'>
         {description}

web/i18n/en-US/app-debug.ts

@@ -4,6 +4,23 @@ const translation = {
     line2: 'Engineering',
   },
   orchestrate: 'Orchestrate',
+  autoGenerate: {
+    title: 'Auto Generate',
+    description: 'Auto generate a workflow for your app',
+    generate: 'Generate',
+    cancel: 'Cancel',
+    instructionPlaceholder: 'Write clear and specific instructions.',
+    generatedCodeTitle: 'Generating Workflow...',
+    loading: 'Generating Workflow...',
+    instruction: 'Instruction',
+    noDataLine1: 'Describe your use case on the left,',
+    noDataLine2: 'the workflow preview will show here.',
+    apply: 'Apply',
+    applyChanges: 'Apply Changes',
+    resTitle: 'Generated Workflow',
+    overwriteConfirmTitle: 'Overwrite existing code?',
+    overwriteConfirmMessage: 'This action will overwrite the existing code. Do you want to continue?',
+  },
   promptMode: {
     simple: 'Switch to Expert Mode to edit the whole PROMPT',
     advanced: 'Expert Mode',

web/i18n/en-US/app.ts

@@ -18,6 +18,7 @@ const translation = {
   export: 'Export DSL',
   exportFailed: 'Export DSL failed.',
   importDSL: 'Import DSL file',
+  autoGenerate: 'Auto Generate',
   createFromConfigFile: 'Create from DSL file',
   importFromDSL: 'Import from DSL',
   importFromDSLFile: 'From DSL file',

web/i18n/zh-Hans/app-debug.ts

@@ -3,6 +3,23 @@ const translation = {
     line1: '提示词',
     line2: '编排',
   },
+  autoGenerate: {
+    title: '自动生成',
+    description: '自动生成一个工作流',
+    generate: '生成',
+    cancel: '取消',
+    instructionPlaceholder: '写清楚具体的指令',
+    generatedCodeTitle: '正在生成工作流...',
+    loading: '正在生成工作流...',
+    instruction: '指令',
+    noDataLine1: '在左侧描述您的用例，',
+    noDataLine2: '工作流预览将在此处显示。',
+    apply: '应用',
+    applyChanges: '应用更改',
+    resTitle: '生成的工作流',
+    overwriteConfirmTitle: '是否覆盖现有代码？',
+    overwriteConfirmMessage: '此操作将覆盖现有代码。您确定要继续吗？',
+  },
   orchestrate: '编排',
   promptMode: {
     simple: '切换到专家模式以编辑完整的提示词',

web/i18n/zh-Hans/app.ts

@@ -18,6 +18,7 @@ const translation = {
   export: '导出 DSL',
   exportFailed: '导出 DSL 失败',
   importDSL: '导入 DSL 文件',
+  autoGenerate: '自动生成',
   createFromConfigFile: '通过 DSL 文件创建',
   importFromDSL: '导入 DSL',
   importFromDSLFile: '文件',

web/service/datasets.ts

@@ -5,7 +5,6 @@ import type {
   CreateDocumentReq,
   DataSet,
   DataSetListResponse,
-  DocumentListResponse,
   ErrorDocsResponse,
   ExternalAPIDeleteResponse,
   ExternalAPIItem,
@@ -122,10 +121,6 @@ export const fetchProcessRule: Fetcher<ProcessRuleResponse, { params: { document
   return get<ProcessRuleResponse>('/datasets/process-rule', { params: { document_id: documentId } })
 }
 
-export const fetchDocuments: Fetcher<DocumentListResponse, { datasetId: string; params: { keyword: string; page: number; limit: number; sort?: SortType } }> = ({ datasetId, params }) => {
-  return get<DocumentListResponse>(`/datasets/${datasetId}/documents`, { params })
-}
-
 export const createFirstDocument: Fetcher<createDocumentResponse, { body: CreateDocumentReq }> = ({ body }) => {
   return post<createDocumentResponse>('/datasets/init', { body })
 }

web/service/debug.ts

@@ -3,13 +3,13 @@ import type { IOnCompleted, IOnData, IOnError, IOnFile, IOnMessageEnd, IOnMessag
 import type { ChatPromptConfig, CompletionPromptConfig } from '@/models/debug'
 import type { ModelModeType } from '@/types/app'
 import type { ModelParameterRule } from '@/app/components/header/account-setting/model-provider-page/declarations'
-export interface AutomaticRes {
+export type AutomaticRes = {
   prompt: string
   variables: string[]
   opening_statement: string
   error?: string
 }
-export interface CodeGenRes {
+export type CodeGenRes = {
   code: string
   language: string[]
   error?: string
@@ -82,6 +82,12 @@ export const generateRuleCode = (body: Record<string, any>) => {
   })
 }
 
+export const generateWorkflow = (body: Record<string, any>) => {
+  return post<string>('/auto-generate', {
+    body,
+  })
+}
+
 export const fetchModelParams = (providerName: string, modelId: string) => {
   return get(`workspaces/current/model-providers/${providerName}/models/parameter-rules`, {
     params: {

web/service/knowledge/use-document.ts

@@ -4,8 +4,8 @@ import {
 } from '@tanstack/react-query'
 import { del, get, patch } from '../base'
 import { useInvalid } from '../use-base'
-import type { MetadataType } from '../datasets'
-import type { DocumentDetailResponse, SimpleDocumentDetail, UpdateDocumentBatchParams } from '@/models/datasets'
+import type { MetadataType, SortType } from '../datasets'
+import type { DocumentDetailResponse, DocumentListResponse, UpdateDocumentBatchParams } from '@/models/datasets'
 import { DocumentActionType } from '@/models/datasets'
 import type { CommonResponse } from '@/models/common'
 
@@ -18,19 +18,23 @@ export const useDocumentList = (payload: {
     keyword: string
     page: number
     limit: number
-  }
+    sort?: SortType
+  },
+  refetchInterval?: number | false
 }) => {
-  const { query, datasetId } = payload
-  return useQuery<{ data: SimpleDocumentDetail[] }>({
-    queryKey: [...useDocumentListKey, datasetId, query],
-    queryFn: () => get<{ data: SimpleDocumentDetail[] }>(`/datasets/${datasetId}/documents`, {
+  const { query, datasetId, refetchInterval } = payload
+  const { keyword, page, limit, sort } = query
+  return useQuery<DocumentListResponse>({
+    queryKey: [...useDocumentListKey, datasetId, keyword, page, limit, sort],
+    queryFn: () => get<DocumentListResponse>(`/datasets/${datasetId}/documents`, {
       params: query,
     }),
+    refetchInterval,
   })
 }
 
-export const useInvalidDocumentList = () => {
-  return useInvalid(useDocumentListKey)
+export const useInvalidDocumentList = (datasetId?: string) => {
+  return useInvalid(datasetId ? [...useDocumentListKey, datasetId] : useDocumentListKey)
 }
 
 const useAutoDisabledDocumentKey = [NAME_SPACE, 'autoDisabledDocument']

web/service/log.ts

@@ -17,7 +17,6 @@ import type {
   LogMessageAnnotationsResponse,
   LogMessageFeedbacksRequest,
   LogMessageFeedbacksResponse,
-  WorkflowLogsRequest,
   WorkflowLogsResponse,
   WorkflowRunDetailResponse,
 } from '@/models/log'
@@ -64,7 +63,7 @@ export const fetchAnnotationsCount: Fetcher<AnnotationsCountResponse, { url: str
   return get<AnnotationsCountResponse>(url)
 }
 
-export const fetchWorkflowLogs: Fetcher<WorkflowLogsResponse, { url: string; params?: WorkflowLogsRequest }> = ({ url, params }) => {
+export const fetchWorkflowLogs: Fetcher<WorkflowLogsResponse, { url: string; params: Record<string, any> }> = ({ url, params }) => {
   return get<WorkflowLogsResponse>(url, { params })
 }