add get default node config

api/controllers/console/app/app.py

@@ -34,7 +34,7 @@ class AppListApi(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('mode', type=str, choices=['chat', 'workflow', 'agent', 'channel', 'all'], default='all', location='args', required=False)
+        parser.add_argument('mode', type=str, choices=['chat', 'workflow', 'agent-chat', 'channel', 'all'], default='all', location='args', required=False)
         parser.add_argument('name', type=str, location='args', required=False)
         args = parser.parse_args()
 

api/controllers/console/app/workflow.py

+import json
+
 from flask_restful import Resource, marshal_with, reqparse
 
 from controllers.console import api
@@ -147,7 +149,7 @@ class PublishedWorkflowApi(Resource):
         }
 
 
-class DefaultBlockConfigApi(Resource):
+class DefaultBlockConfigsApi(Resource):
     @setup_required
     @login_required
     @account_initialization_required
@@ -161,6 +163,34 @@ class DefaultBlockConfigApi(Resource):
         return workflow_service.get_default_block_configs()
 
 
+class DefaultBlockConfigApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @get_app_model(mode=[AppMode.ADVANCED_CHAT, AppMode.WORKFLOW])
+    def get(self, app_model: App, block_type: str):
+        """
+        Get default block config
+        """
+        parser = reqparse.RequestParser()
+        parser.add_argument('q', type=str, location='args')
+        args = parser.parse_args()
+
+        filters = None
+        if args.get('q'):
+            try:
+                filters = json.loads(args.get('q'))
+            except json.JSONDecodeError:
+                raise ValueError('Invalid filters')
+
+        # Get default block configs
+        workflow_service = WorkflowService()
+        return workflow_service.get_default_block_config(
+            node_type=block_type,
+            filters=filters
+        )
+
+
 class ConvertToWorkflowApi(Resource):
     @setup_required
     @login_required
@@ -188,5 +218,6 @@ api.add_resource(DraftWorkflowRunApi, '/apps/<uuid:app_id>/workflows/draft/run')
 api.add_resource(WorkflowTaskStopApi, '/apps/<uuid:app_id>/workflows/tasks/<string:task_id>/stop')
 api.add_resource(DraftWorkflowNodeRunApi, '/apps/<uuid:app_id>/workflows/draft/nodes/<uuid:node_id>/run')
 api.add_resource(PublishedWorkflowApi, '/apps/<uuid:app_id>/workflows/published')
-api.add_resource(DefaultBlockConfigApi, '/apps/<uuid:app_id>/workflows/default-workflow-block-configs')
+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/:block_type')
 api.add_resource(ConvertToWorkflowApi, '/apps/<uuid:app_id>/convert-to-workflow')

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

@@ -30,7 +30,7 @@ from core.model_runtime.entities.llm_entities import LLMUsage
 from core.model_runtime.errors.invoke import InvokeAuthorizationError, InvokeError
 from core.moderation.output_moderation import ModerationRule, OutputModeration
 from core.tools.tool_file_manager import ToolFileManager
-from core.workflow.entities.NodeEntities import NodeType
+from core.workflow.entities.node_entities import NodeType
 from events.message_event import message_was_created
 from extensions.ext_database import db
 from models.model import Conversation, Message, MessageFile

api/core/workflow/nodes/base_node.py

+from typing import Optional
+
+
+class BaseNode:
+    @classmethod
+    def get_default_config(cls, filters: Optional[dict] = None) -> dict:
+        """
+        Get default config of node.
+        :param filters: filter by node config parameters.
+        :return:
+        """
+        return {}

api/core/workflow/nodes/code/code_node.py

+from typing import Optional
+
+from core.workflow.nodes.base_node import BaseNode
+
+
+class CodeNode(BaseNode):
+    @classmethod
+    def get_default_config(cls, filters: Optional[dict] = None) -> dict:
+        """
+        Get default config of node.
+        :param filters: filter by node config parameters.
+        :return:
+        """
+        if filters and filters.get("code_language") == "javascript":
+            return {
+                "type": "code",
+                "config": {
+                    "variables": [
+                        {
+                            "variable": "arg1",
+                            "value_selector": []
+                        },
+                        {
+                            "variable": "arg2",
+                            "value_selector": []
+                        }
+                    ],
+                    "code_language": "javascript",
+                    "code": "async function main(arg1, arg2) {\n    return new Promise((resolve, reject) => {"
+                            "\n    	if (true) {\n	        resolve({\n	            \"result\": arg1 + arg2"
+                            "\n        	});\n        } else {\n        	reject(\"e\");\n    }\n    });\n}",
+                    "outputs": [
+                        {
+                            "variable": "result",
+                            "variable_type": "number"
+                        }
+                    ]
+                }
+            }
+
+        return {
+            "type": "code",
+            "config": {
+                "variables": [
+                    {
+                        "variable": "arg1",
+                        "value_selector": []
+                    },
+                    {
+                        "variable": "arg2",
+                        "value_selector": []
+                    }
+                ],
+                "code_language": "python3",
+                "code": "def main(\n    arg1: int,\n    arg2: int,\n) -> int:\n    return {\n        \"result\": arg1 "
+                        "+ arg2\n    }",
+                "outputs": [
+                    {
+                        "variable": "result",
+                        "variable_type": "number"
+                    }
+                ]
+            }
+        }

api/core/workflow/nodes/direct_answer/direct_answer_node.py

+from core.workflow.nodes.base_node import BaseNode
+
+
+class DirectAnswerNode(BaseNode):
+    pass

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

+from core.workflow.nodes.base_node import BaseNode
+
+
+class EndNode(BaseNode):
+    pass

api/core/workflow/nodes/http_request/http_request_node.py

+from core.workflow.nodes.base_node import BaseNode
+
+
+class HttpRequestNode(BaseNode):
+    pass

api/core/workflow/nodes/if_else/if_else_node.py

+from core.workflow.nodes.base_node import BaseNode
+
+
+class IfElseNode(BaseNode):
+    pass

api/core/workflow/nodes/knowledge_retrieval/knowledge_retrieval_node.py

+from core.workflow.nodes.base_node import BaseNode
+
+
+class KnowledgeRetrievalNode(BaseNode):
+    pass

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

+from typing import Optional
+
+from core.workflow.nodes.base_node import BaseNode
+
+
+class LLMNode(BaseNode):
+    @classmethod
+    def get_default_config(cls, filters: Optional[dict] = None) -> dict:
+        """
+        Get default config of node.
+        :param filters: filter by node config parameters.
+        :return:
+        """
+        return {
+            "type": "llm",
+            "config": {
+                "prompt_templates": {
+                    "chat_model": {
+                        "prompts": [
+                            {
+                                "role": "system",
+                                "text": "You are a helpful AI assistant."
+                            }
+                        ]
+                    },
+                    "completion_model": {
+                        "conversation_histories_role": {
+                            "user_prefix": "Human",
+                            "assistant_prefix": "Assistant"
+                        },
+                        "prompt": {
+                            "text": "Here is the chat histories between human and assistant, inside "
+                                    "<histories></histories> XML tags.\n\n<histories>\n{{"
+                                    "#histories#}}\n</histories>\n\n\nHuman: {{#query#}}\n\nAssistant:"
+                        },
+                        "stop": ["Human:"]
+                    }
+                }
+            }
+        }

api/core/workflow/nodes/question_classifier/question_classifier_node.py

+from typing import Optional
+
+from core.workflow.nodes.base_node import BaseNode
+
+
+class QuestionClassifierNode(BaseNode):
+    @classmethod
+    def get_default_config(cls, filters: Optional[dict] = None) -> dict:
+        """
+        Get default config of node.
+        :param filters: filter by node config parameters.
+        :return:
+        """
+        return {
+            "type": "question-classifier",
+            "config": {
+                "instructions": ""  # TODO
+            }
+        }

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

+from core.workflow.nodes.base_node import BaseNode
+
+
+class StartNode(BaseNode):
+    pass

api/core/workflow/nodes/template_transform/template_transform_node.py

+from typing import Optional
+
+from core.workflow.nodes.base_node import BaseNode
+
+
+class TemplateTransformNode(BaseNode):
+    @classmethod
+    def get_default_config(cls, filters: Optional[dict] = None) -> dict:
+        """
+        Get default config of node.
+        :param filters: filter by node config parameters.
+        :return:
+        """
+        return {
+            "type": "template-transform",
+            "config": {
+                "variables": [
+                    {
+                        "variable": "arg1",
+                        "value_selector": []
+                    }
+                ],
+                "template": "{{ arg1 }}"
+            }
+        }

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

+from core.workflow.nodes.base_node import BaseNode
+
+
+class ToolNode(BaseNode):
+    pass

api/core/workflow/nodes/variable_assigner/variable_assigner_node.py

+from core.workflow.nodes.base_node import BaseNode
+
+
+class VariableAssignerNode(BaseNode):
+    pass

api/core/workflow/workflow_engine_manager.py

 from typing import Optional
 
+from core.workflow.entities.node_entities import NodeType
+from core.workflow.nodes.code.code_node import CodeNode
+from core.workflow.nodes.direct_answer.direct_answer_node import DirectAnswerNode
+from core.workflow.nodes.end.end_node import EndNode
+from core.workflow.nodes.http_request.http_request_node import HttpRequestNode
+from core.workflow.nodes.if_else.if_else_node import IfElseNode
+from core.workflow.nodes.knowledge_retrieval.knowledge_retrieval_node import KnowledgeRetrievalNode
+from core.workflow.nodes.llm.llm_node import LLMNode
+from core.workflow.nodes.question_classifier.question_classifier_node import QuestionClassifierNode
+from core.workflow.nodes.start.start_node import StartNode
+from core.workflow.nodes.template_transform.template_transform_node import TemplateTransformNode
+from core.workflow.nodes.tool.tool_node import ToolNode
+from core.workflow.nodes.variable_assigner.variable_assigner_node import VariableAssignerNode
 from extensions.ext_database import db
 from models.model import App
 from models.workflow import Workflow
 
+node_classes = {
+    NodeType.START: StartNode,
+    NodeType.END: EndNode,
+    NodeType.DIRECT_ANSWER: DirectAnswerNode,
+    NodeType.LLM: LLMNode,
+    NodeType.KNOWLEDGE_RETRIEVAL: KnowledgeRetrievalNode,
+    NodeType.IF_ELSE: IfElseNode,
+    NodeType.CODE: CodeNode,
+    NodeType.TEMPLATE_TRANSFORM: TemplateTransformNode,
+    NodeType.QUESTION_CLASSIFIER: QuestionClassifierNode,
+    NodeType.HTTP_REQUEST: HttpRequestNode,
+    NodeType.TOOL: ToolNode,
+    NodeType.VARIABLE_ASSIGNER: VariableAssignerNode,
+}
+
 
 class WorkflowEngineManager:
     def get_draft_workflow(self, app_model: App) -> Optional[Workflow]:
@@ -36,3 +64,35 @@ class WorkflowEngineManager:
 
         # return published workflow
         return workflow
+
+    def get_default_configs(self) -> list[dict]:
+        """
+        Get default block configs
+        """
+        default_block_configs = []
+        for node_type, node_class in node_classes.items():
+            default_config = node_class.get_default_config()
+            if default_config:
+                default_block_configs.append({
+                    'type': node_type.value,
+                    'config': default_config
+                })
+
+        return default_block_configs
+
+    def get_default_config(self, node_type: NodeType, filters: Optional[dict] = None) -> Optional[dict]:
+        """
+        Get default config of node.
+        :param node_type: node type
+        :param filters: filter by node config parameters.
+        :return:
+        """
+        node_class = node_classes.get(node_type)
+        if not node_class:
+            return None
+
+        default_config = node_class.get_default_config(filters=filters)
+        if not default_config:
+            return None
+
+        return default_config

api/services/app_service.py

@@ -35,7 +35,7 @@ class AppService:
             filters.append(App.mode.in_([AppMode.WORKFLOW.value, AppMode.COMPLETION.value]))
         elif args['mode'] == 'chat':
             filters.append(App.mode.in_([AppMode.CHAT.value, AppMode.ADVANCED_CHAT.value]))
-        elif args['mode'] == 'agent':
+        elif args['mode'] == 'agent-chat':
             filters.append(App.mode == AppMode.AGENT_CHAT.value)
         elif args['mode'] == 'channel':
             filters.append(App.mode == AppMode.CHANNEL.value)

api/services/workflow/defaults.py

-# default block config
-default_block_configs = [
-    {
-        "type": "llm",
-        "config": {
-            "prompt_templates": {
-                "chat_model": {
-                    "prompts": [
-                        {
-                            "role": "system",
-                            "text": "You are a helpful AI assistant."
-                        }
-                    ]
-                },
-                "completion_model": {
-                    "conversation_histories_role": {
-                        "user_prefix": "Human",
-                        "assistant_prefix": "Assistant"
-                    },
-                    "prompt": {
-                        "text": "Here is the chat histories between human and assistant, inside "
-                                "<histories></histories> XML tags.\n\n<histories>\n{{"
-                                "#histories#}}\n</histories>\n\n\nHuman: {{#query#}}\n\nAssistant:"
-                    },
-                    "stop": ["Human:"]
-                }
-            }
-        }
-    },
-    {
-        "type": "code",
-        "config": {
-            "variables": [
-                {
-                    "variable": "arg1",
-                    "value_selector": []
-                },
-                {
-                    "variable": "arg2",
-                    "value_selector": []
-                }
-            ],
-            "code_language": "python3",
-            "code": "def main(\n    arg1: int,\n    arg2: int,\n) -> int:\n    return {\n        \"result\": arg1 "
-                    "+ arg2\n    }",
-            "outputs": [
-                {
-                    "variable": "result",
-                    "variable_type": "number"
-                }
-            ]
-        }
-    },
-    {
-        "type": "template-transform",
-        "config": {
-            "variables": [
-                {
-                    "variable": "arg1",
-                    "value_selector": []
-                }
-            ],
-            "template": "{{ arg1 }}"
-        }
-    },
-    {
-        "type": "question-classifier",
-        "config": {
-            "instructions": ""  # TODO
-        }
-    }
-]

api/services/workflow/workflow_converter.py

@@ -18,7 +18,7 @@ from core.helper import encrypter
 from core.model_runtime.entities.llm_entities import LLMMode
 from core.model_runtime.utils.encoders import jsonable_encoder
 from core.prompt.simple_prompt_transform import SimplePromptTransform
-from core.workflow.entities.NodeEntities import NodeType
+from core.workflow.entities.node_entities import NodeType
 from core.workflow.nodes.end.entities import EndNodeOutputType
 from events.app_event import app_was_created
 from extensions.ext_database import db

api/services/workflow_service.py

@@ -4,6 +4,7 @@ from typing import Optional
 
 from core.app.apps.advanced_chat.app_config_manager import AdvancedChatAppConfigManager
 from core.app.apps.workflow.app_config_manager import WorkflowAppConfigManager
+from core.workflow.entities.node_entities import NodeType
 from core.workflow.workflow_engine_manager import WorkflowEngineManager
 from extensions.ext_database import db
 from models.account import Account
@@ -121,12 +122,26 @@ class WorkflowService:
         # return new workflow
         return workflow
 
-    def get_default_block_configs(self) -> dict:
+    def get_default_block_configs(self) -> list[dict]:
         """
         Get default block configs
         """
         # return default block config
-        return default_block_configs
+        workflow_engine_manager = WorkflowEngineManager()
+        return workflow_engine_manager.get_default_configs()
+
+    def get_default_block_config(self, node_type: str, filters: Optional[dict] = None) -> Optional[dict]:
+        """
+        Get default config of node.
+        :param node_type: node type
+        :param filters: filter by node config parameters.
+        :return:
+        """
+        node_type = NodeType.value_of(node_type)
+
+        # return default block config
+        workflow_engine_manager = WorkflowEngineManager()
+        return workflow_engine_manager.get_default_config(node_type, filters)
 
     def convert_to_workflow(self, app_model: App, account: Account) -> App:
         """