FEAT: NEW WORKFLOW ENGINE (#3160)

Co-authored-by: Joel <iamjoel007@gmail.com>
Co-authored-by: Yeuoly <admin@srmxy.cn>
Co-authored-by: JzoNg <jzongcode@gmail.com>
Co-authored-by: StyleZhang <jasonapring2015@outlook.com>
Co-authored-by: jyong <jyong@dify.ai>
Co-authored-by: nite-knite <nkCoding@gmail.com>
Co-authored-by: jyong <718720800@qq.com>

api/models/__init__.py

@@ -1 +1,44 @@
-# -*- coding:utf-8 -*-
+from enum import Enum
+
+
+class CreatedByRole(Enum):
+    """
+    Enum class for createdByRole
+    """
+    ACCOUNT = "account"
+    END_USER = "end_user"
+
+    @classmethod
+    def value_of(cls, value: str) -> 'CreatedByRole':
+        """
+        Get value of given mode.
+
+        :param value: mode value
+        :return: mode
+        """
+        for role in cls:
+            if role.value == value:
+                return role
+        raise ValueError(f'invalid createdByRole value {value}')
+
+
+class CreatedFrom(Enum):
+    """
+    Enum class for createdFrom
+    """
+    SERVICE_API = "service-api"
+    WEB_APP = "web-app"
+    EXPLORE = "explore"
+
+    @classmethod
+    def value_of(cls, value: str) -> 'CreatedFrom':
+        """
+        Get value of given mode.
+
+        :param value: mode value
+        :return: mode
+        """
+        for role in cls:
+            if role.value == value:
+                return role
+        raise ValueError(f'invalid createdFrom value {value}')

api/models/model.py

@@ -1,5 +1,8 @@
 import json
+import re
 import uuid
+from enum import Enum
+from typing import Optional
 
 from flask import current_app, request
 from flask_login import UserMixin
@@ -24,6 +27,28 @@ class DifySetup(db.Model):
     setup_at = db.Column(db.DateTime, nullable=False, server_default=db.text('CURRENT_TIMESTAMP(0)'))
 
 
+class AppMode(Enum):
+    COMPLETION = 'completion'
+    WORKFLOW = 'workflow'
+    CHAT = 'chat'
+    ADVANCED_CHAT = 'advanced-chat'
+    AGENT_CHAT = 'agent-chat'
+    CHANNEL = 'channel'
+
+    @classmethod
+    def value_of(cls, value: str) -> 'AppMode':
+        """
+        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 mode value {value}')
+
+
 class App(db.Model):
     __tablename__ = 'apps'
     __table_args__ = (
@@ -34,31 +59,53 @@ class App(db.Model):
     id = db.Column(UUID, server_default=db.text('uuid_generate_v4()'))
     tenant_id = db.Column(UUID, nullable=False)
     name = db.Column(db.String(255), nullable=False)
+    description = db.Column(db.Text, nullable=False, server_default=db.text("''::character varying"))
     mode = db.Column(db.String(255), nullable=False)
     icon = db.Column(db.String(255))
     icon_background = db.Column(db.String(255))
     app_model_config_id = db.Column(UUID, nullable=True)
+    workflow_id = db.Column(UUID, nullable=True)
     status = db.Column(db.String(255), nullable=False, server_default=db.text("'normal'::character varying"))
     enable_site = db.Column(db.Boolean, nullable=False)
     enable_api = db.Column(db.Boolean, nullable=False)
-    api_rpm = db.Column(db.Integer, nullable=False)
-    api_rph = db.Column(db.Integer, nullable=False)
+    api_rpm = db.Column(db.Integer, nullable=False, server_default=db.text('0'))
+    api_rph = db.Column(db.Integer, nullable=False, server_default=db.text('0'))
     is_demo = db.Column(db.Boolean, nullable=False, server_default=db.text('false'))
     is_public = db.Column(db.Boolean, nullable=False, server_default=db.text('false'))
     is_universal = db.Column(db.Boolean, nullable=False, server_default=db.text('false'))
     created_at = db.Column(db.DateTime, nullable=False, server_default=db.text('CURRENT_TIMESTAMP(0)'))
     updated_at = db.Column(db.DateTime, nullable=False, server_default=db.text('CURRENT_TIMESTAMP(0)'))
 
+    @property
+    def desc_or_prompt(self):
+        if self.description:
+            return self.description
+        else:
+            app_model_config = self.app_model_config
+            if app_model_config:
+                return app_model_config.pre_prompt
+            else:
+                return ''
+
     @property
     def site(self):
         site = db.session.query(Site).filter(Site.app_id == self.id).first()
         return site
 
     @property
-    def app_model_config(self):
-        app_model_config = db.session.query(AppModelConfig).filter(
-            AppModelConfig.id == self.app_model_config_id).first()
-        return app_model_config
+    def app_model_config(self) -> Optional['AppModelConfig']:
+        if self.app_model_config_id:
+            return db.session.query(AppModelConfig).filter(AppModelConfig.id == self.app_model_config_id).first()
+
+        return None
+
+    @property
+    def workflow(self):
+        if self.workflow_id:
+            from .workflow import Workflow
+            return db.session.query(Workflow).filter(Workflow.id == self.workflow_id).first()
+
+        return None
 
     @property
     def api_base_url(self):
@@ -69,7 +116,7 @@ class App(db.Model):
     def tenant(self):
         tenant = db.session.query(Tenant).filter(Tenant.id == self.tenant_id).first()
         return tenant
-    
+
     @property
     def is_agent(self) -> bool:
         app_model_config = self.app_model_config
@@ -78,10 +125,19 @@ class App(db.Model):
         if not app_model_config.agent_mode:
             return False
         if self.app_model_config.agent_mode_dict.get('enabled', False) \
-            and self.app_model_config.agent_mode_dict.get('strategy', '') in ['function_call', 'react']:
+                and self.app_model_config.agent_mode_dict.get('strategy', '') in ['function_call', 'react']:
+            self.mode = AppMode.AGENT_CHAT.value
+            db.session.commit()
             return True
         return False
-    
+
+    @property
+    def mode_compatible_with_agent(self) -> str:
+        if self.mode == AppMode.CHAT.value and self.is_agent:
+            return AppMode.AGENT_CHAT.value
+
+        return self.mode
+
     @property
     def deleted_tools(self) -> list:
         # get agent mode tools
@@ -129,6 +185,7 @@ class App(db.Model):
 
         return deleted_tools
 
+
 class AppModelConfig(db.Model):
     __tablename__ = 'app_model_configs'
     __table_args__ = (
@@ -138,9 +195,9 @@ class AppModelConfig(db.Model):
 
     id = db.Column(UUID, server_default=db.text('uuid_generate_v4()'))
     app_id = db.Column(UUID, nullable=False)
-    provider = db.Column(db.String(255), nullable=False)
-    model_id = db.Column(db.String(255), nullable=False)
-    configs = db.Column(db.JSON, nullable=False)
+    provider = db.Column(db.String(255), nullable=True)
+    model_id = db.Column(db.String(255), nullable=True)
+    configs = db.Column(db.JSON, nullable=True)
     created_at = db.Column(db.DateTime, nullable=False, server_default=db.text('CURRENT_TIMESTAMP(0)'))
     updated_at = db.Column(db.DateTime, nullable=False, server_default=db.text('CURRENT_TIMESTAMP(0)'))
     opening_statement = db.Column(db.Text)
@@ -156,7 +213,7 @@ class AppModelConfig(db.Model):
     agent_mode = db.Column(db.Text)
     sensitive_word_avoidance = db.Column(db.Text)
     retriever_resource = db.Column(db.Text)
-    prompt_type = db.Column(db.String(255), nullable=False, default='simple')
+    prompt_type = db.Column(db.String(255), nullable=False, server_default=db.text("'simple'::character varying"))
     chat_prompt_config = db.Column(db.Text)
     completion_prompt_config = db.Column(db.Text)
     dataset_configs = db.Column(db.Text)
@@ -263,9 +320,6 @@ class AppModelConfig(db.Model):
 
     def to_dict(self) -> dict:
         return {
-            "provider": "",
-            "model_id": "",
-            "configs": {},
             "opening_statement": self.opening_statement,
             "suggested_questions": self.suggested_questions_list,
             "suggested_questions_after_answer": self.suggested_questions_after_answer_dict,
@@ -289,26 +343,29 @@ class AppModelConfig(db.Model):
         }
 
     def from_model_config_dict(self, model_config: dict):
-        self.provider = ""
-        self.model_id = ""
-        self.configs = {}
-        self.opening_statement = model_config['opening_statement']
-        self.suggested_questions = json.dumps(model_config['suggested_questions'])
-        self.suggested_questions_after_answer = json.dumps(model_config['suggested_questions_after_answer'])
+        self.opening_statement = model_config.get('opening_statement')
+        self.suggested_questions = json.dumps(model_config['suggested_questions']) \
+            if model_config.get('suggested_questions') else None
+        self.suggested_questions_after_answer = json.dumps(model_config['suggested_questions_after_answer']) \
+            if model_config.get('suggested_questions_after_answer') else None
         self.speech_to_text = json.dumps(model_config['speech_to_text']) \
             if model_config.get('speech_to_text') else None
         self.text_to_speech = json.dumps(model_config['text_to_speech']) \
             if model_config.get('text_to_speech') else None
-        self.more_like_this = json.dumps(model_config['more_like_this'])
+        self.more_like_this = json.dumps(model_config['more_like_this']) \
+            if model_config.get('more_like_this') else None
         self.sensitive_word_avoidance = json.dumps(model_config['sensitive_word_avoidance']) \
             if model_config.get('sensitive_word_avoidance') else None
         self.external_data_tools = json.dumps(model_config['external_data_tools']) \
             if model_config.get('external_data_tools') else None
-        self.model = json.dumps(model_config['model'])
-        self.user_input_form = json.dumps(model_config['user_input_form'])
+        self.model = json.dumps(model_config['model']) \
+            if model_config.get('model') else None
+        self.user_input_form = json.dumps(model_config['user_input_form']) \
+            if model_config.get('user_input_form') else None
         self.dataset_query_variable = model_config.get('dataset_query_variable')
         self.pre_prompt = model_config['pre_prompt']
-        self.agent_mode = json.dumps(model_config['agent_mode'])
+        self.agent_mode = json.dumps(model_config['agent_mode']) \
+            if model_config.get('agent_mode') else None
         self.retriever_resource = json.dumps(model_config['retriever_resource']) \
             if model_config.get('retriever_resource') else None
         self.prompt_type = model_config.get('prompt_type', 'simple')
@@ -326,9 +383,6 @@ class AppModelConfig(db.Model):
         new_app_model_config = AppModelConfig(
             id=self.id,
             app_id=self.app_id,
-            provider="",
-            model_id="",
-            configs={},
             opening_statement=self.opening_statement,
             suggested_questions=self.suggested_questions,
             suggested_questions_after_answer=self.suggested_questions_after_answer,
@@ -408,12 +462,6 @@ class InstalledApp(db.Model):
         tenant = db.session.query(Tenant).filter(Tenant.id == self.tenant_id).first()
         return tenant
 
-    @property
-    def is_agent(self) -> bool:
-        app = self.app
-        if not app:
-            return False
-        return app.is_agent
 
 class Conversation(db.Model):
     __tablename__ = 'conversations'
@@ -424,10 +472,10 @@ class Conversation(db.Model):
 
     id = db.Column(UUID, server_default=db.text('uuid_generate_v4()'))
     app_id = db.Column(UUID, nullable=False)
-    app_model_config_id = db.Column(UUID, nullable=False)
-    model_provider = db.Column(db.String(255), nullable=False)
+    app_model_config_id = db.Column(UUID, nullable=True)
+    model_provider = db.Column(db.String(255), nullable=True)
     override_model_configs = db.Column(db.Text)
-    model_id = db.Column(db.String(255), nullable=False)
+    model_id = db.Column(db.String(255), nullable=True)
     mode = db.Column(db.String(255), nullable=False)
     name = db.Column(db.String(255), nullable=False)
     summary = db.Column(db.Text)
@@ -436,6 +484,7 @@ class Conversation(db.Model):
     system_instruction = db.Column(db.Text)
     system_instruction_tokens = db.Column(db.Integer, nullable=False, server_default=db.text('0'))
     status = db.Column(db.String(255), nullable=False)
+    invoke_from = db.Column(db.String(255), nullable=True)
     from_source = db.Column(db.String(255), nullable=False)
     from_end_user_id = db.Column(UUID)
     from_account_id = db.Column(UUID)
@@ -453,20 +502,25 @@ class Conversation(db.Model):
     @property
     def model_config(self):
         model_config = {}
-        if self.override_model_configs:
-            override_model_configs = json.loads(self.override_model_configs)
-
-            if 'model' in override_model_configs:
-                app_model_config = AppModelConfig()
-                app_model_config = app_model_config.from_model_config_dict(override_model_configs)
-                model_config = app_model_config.to_dict()
-            else:
-                model_config['configs'] = override_model_configs
+        if self.mode == AppMode.ADVANCED_CHAT.value:
+            if self.override_model_configs:
+                override_model_configs = json.loads(self.override_model_configs)
+                model_config = override_model_configs
         else:
-            app_model_config = db.session.query(AppModelConfig).filter(
-                AppModelConfig.id == self.app_model_config_id).first()
+            if self.override_model_configs:
+                override_model_configs = json.loads(self.override_model_configs)
 
-            model_config = app_model_config.to_dict()
+                if 'model' in override_model_configs:
+                    app_model_config = AppModelConfig()
+                    app_model_config = app_model_config.from_model_config_dict(override_model_configs)
+                    model_config = app_model_config.to_dict()
+                else:
+                    model_config['configs'] = override_model_configs
+            else:
+                app_model_config = db.session.query(AppModelConfig).filter(
+                    AppModelConfig.id == self.app_model_config_id).first()
+
+                model_config = app_model_config.to_dict()
 
         model_config['model_id'] = self.model_id
         model_config['provider'] = self.model_provider
@@ -558,8 +612,8 @@ class Message(db.Model):
 
     id = db.Column(UUID, server_default=db.text('uuid_generate_v4()'))
     app_id = db.Column(UUID, nullable=False)
-    model_provider = db.Column(db.String(255), nullable=False)
-    model_id = db.Column(db.String(255), nullable=False)
+    model_provider = db.Column(db.String(255), nullable=True)
+    model_id = db.Column(db.String(255), nullable=True)
     override_model_configs = db.Column(db.Text)
     conversation_id = db.Column(UUID, db.ForeignKey('conversations.id'), nullable=False)
     inputs = db.Column(db.JSON)
@@ -575,12 +629,82 @@ class Message(db.Model):
     provider_response_latency = db.Column(db.Float, nullable=False, server_default=db.text('0'))
     total_price = db.Column(db.Numeric(10, 7))
     currency = db.Column(db.String(255), nullable=False)
+    status = db.Column(db.String(255), nullable=False, server_default=db.text("'normal'::character varying"))
+    error = db.Column(db.Text)
+    message_metadata = db.Column(db.Text)
+    invoke_from = db.Column(db.String(255), nullable=True)
     from_source = db.Column(db.String(255), nullable=False)
     from_end_user_id = db.Column(UUID)
     from_account_id = db.Column(UUID)
     created_at = db.Column(db.DateTime, nullable=False, server_default=db.text('CURRENT_TIMESTAMP(0)'))
     updated_at = db.Column(db.DateTime, nullable=False, server_default=db.text('CURRENT_TIMESTAMP(0)'))
     agent_based = db.Column(db.Boolean, nullable=False, server_default=db.text('false'))
+    workflow_run_id = db.Column(UUID)
+
+    @property
+    def re_sign_file_url_answer(self) -> str:
+        if not self.answer:
+            return self.answer
+
+        pattern = r'\[!?.*?\]\((((http|https):\/\/.+)?\/files\/(tools\/)?[\w-]+.*?timestamp=.*&nonce=.*&sign=.*)\)'
+        matches = re.findall(pattern, self.answer)
+
+        if not matches:
+            return self.answer
+
+        urls = [match[0] for match in matches]
+
+        # remove duplicate urls
+        urls = list(set(urls))
+
+        if not urls:
+            return self.answer
+
+        re_sign_file_url_answer = self.answer
+        for url in urls:
+            if 'files/tools' in url:
+                # get tool file id
+                tool_file_id_pattern = r'\/files\/tools\/([\.\w-]+)?\?timestamp='
+                result = re.search(tool_file_id_pattern, url)
+                if not result:
+                    continue
+
+                tool_file_id = result.group(1)
+
+                # get extension
+                if '.' in tool_file_id:
+                    split_result = tool_file_id.split('.')
+                    extension = f'.{split_result[-1]}'
+                    if len(extension) > 10:
+                        extension = '.bin'
+                    tool_file_id = split_result[0]
+                else:
+                    extension = '.bin'
+
+                if not tool_file_id:
+                    continue
+
+                sign_url = ToolFileParser.get_tool_file_manager().sign_file(
+                    tool_file_id=tool_file_id,
+                    extension=extension
+                )
+            else:
+                # get upload file id
+                upload_file_id_pattern = r'\/files\/([\w-]+)\/image-preview?\?timestamp='
+                result = re.search(upload_file_id_pattern, url)
+                if not result:
+                    continue
+
+                upload_file_id = result.group(1)
+
+                if not upload_file_id:
+                    continue
+
+                sign_url = UploadFileParser.get_signed_temp_image_url(upload_file_id)
+
+            re_sign_file_url_answer = re_sign_file_url_answer.replace(url, sign_url)
+
+        return re_sign_file_url_answer
 
     @property
     def user_feedback(self):
@@ -627,6 +751,10 @@ class Message(db.Model):
     def in_debug_mode(self):
         return self.override_model_configs is not None
 
+    @property
+    def message_metadata_dict(self) -> dict:
+        return json.loads(self.message_metadata) if self.message_metadata else {}
+
     @property
     def agent_thoughts(self):
         return db.session.query(MessageAgentThought).filter(MessageAgentThought.message_id == self.id) \
@@ -652,7 +780,7 @@ class Message(db.Model):
                 if message_file.transfer_method == 'local_file':
                     upload_file = (db.session.query(UploadFile)
                                    .filter(
-                        UploadFile.id == message_file.upload_file_id
+                        UploadFile.id == message_file.related_id
                     ).first())
 
                     url = UploadFileParser.get_image_data(
@@ -660,6 +788,11 @@ class Message(db.Model):
                         force_url=True
                     )
                 if message_file.transfer_method == 'tool_file':
+                    # get tool file id
+                    tool_file_id = message_file.url.split('/')[-1]
+                    # trim extension
+                    tool_file_id = tool_file_id.split('.')[0]
+
                     # get extension
                     if '.' in message_file.url:
                         extension = f'.{message_file.url.split(".")[-1]}'
@@ -668,7 +801,7 @@ class Message(db.Model):
                     else:
                         extension = '.bin'
                     # add sign url
-                    url = ToolFileParser.get_tool_file_manager().sign_file(file_id=message_file.id, extension=extension)
+                    url = ToolFileParser.get_tool_file_manager().sign_file(tool_file_id=tool_file_id, extension=extension)
 
             files.append({
                 'id': message_file.id,
@@ -679,6 +812,14 @@ class Message(db.Model):
 
         return files
 
+    @property
+    def workflow_run(self):
+        if self.workflow_run_id:
+            from api.models.workflow import WorkflowRun
+            return db.session.query(WorkflowRun).filter(WorkflowRun.id == self.workflow_run_id).first()
+
+        return None
+
 
 class MessageFeedback(db.Model):
     __tablename__ = 'message_feedbacks'
@@ -1006,6 +1147,7 @@ class MessageAgentThought(db.Model):
     thought = db.Column(db.Text, nullable=True)
     tool = db.Column(db.Text, nullable=True)
     tool_labels_str = db.Column(db.Text, nullable=False, server_default=db.text("'{}'::text"))
+    tool_meta_str = db.Column(db.Text, nullable=False, server_default=db.text("'{}'::text"))
     tool_input = db.Column(db.Text, nullable=True)
     observation = db.Column(db.Text, nullable=True)
     # plugin_id = db.Column(UUID, nullable=True)  ## for future design
@@ -1034,6 +1176,10 @@ class MessageAgentThought(db.Model):
         else:
             return []
         
+    @property
+    def tools(self) -> list[str]:
+        return self.tool.split(";") if self.tool else []
+        
     @property
     def tool_labels(self) -> dict:
         try:
@@ -1043,6 +1189,65 @@ class MessageAgentThought(db.Model):
                 return {}
         except Exception as e:
             return {}
+        
+    @property
+    def tool_meta(self) -> dict:
+        try:
+            if self.tool_meta_str:
+                return json.loads(self.tool_meta_str)
+            else:
+                return {}
+        except Exception as e:
+            return {}
+        
+    @property
+    def tool_inputs_dict(self) -> dict:
+        tools = self.tools
+        try:
+            if self.tool_input:
+                data = json.loads(self.tool_input)
+                result = {}
+                for tool in tools:
+                    if tool in data:
+                        result[tool] = data[tool]
+                    else:
+                        if len(tools) == 1:
+                            result[tool] = data
+                        else:
+                            result[tool] = {}
+                return result
+            else:
+                return {
+                    tool: {} for tool in tools
+                }
+        except Exception as e:
+            return {}
+    
+    @property
+    def tool_outputs_dict(self) -> dict:
+        tools = self.tools
+        try:
+            if self.observation:
+                data = json.loads(self.observation)
+                result = {}
+                for tool in tools:
+                    if tool in data:
+                        result[tool] = data[tool]
+                    else:
+                        if len(tools) == 1:
+                            result[tool] = data
+                        else:
+                            result[tool] = {}
+                return result
+            else:
+                return {
+                    tool: {} for tool in tools
+                }
+        except Exception as e:
+            if self.observation:
+                return {
+                    tool: self.observation for tool in tools
+                }
 
 class DatasetRetrieverResource(db.Model):
     __tablename__ = 'dataset_retriever_resources'

api/models/tools.py

@@ -58,7 +58,7 @@ class PublishedAppTool(db.Model):
     description = db.Column(db.Text, nullable=False)
     # llm_description of the tool, for LLM
     llm_description = db.Column(db.Text, nullable=False)
-    # query decription, query will be seem as a parameter of the tool, to describe this parameter to llm, we need this field
+    # query description, query will be seem as a parameter of the tool, to describe this parameter to llm, we need this field
     query_description = db.Column(db.Text, nullable=False)
     # query name, the name of the query parameter
     query_name = db.Column(db.String(40), nullable=False)
@@ -123,10 +123,6 @@ class ApiToolProvider(db.Model):
     def credentials(self) -> dict:
         return json.loads(self.credentials_str)
     
-    @property
-    def is_taned(self) -> bool:
-        return self.tenant_id is not None
-    
     @property
     def user(self) -> Account:
         return db.session.query(Account).filter(Account.id == self.user_id).first()
@@ -218,7 +214,7 @@ class ToolFile(db.Model):
     # tenant id
     tenant_id = db.Column(UUID, nullable=False)
     # conversation id
-    conversation_id = db.Column(UUID, nullable=False)
+    conversation_id = db.Column(UUID, nullable=True)
     # file key
     file_key = db.Column(db.String(255), nullable=False)
     # mime type

api/models/workflow.py

@@ -0,0 +1,553 @@
+import json
+from enum import Enum
+from typing import Optional, Union
+
+from sqlalchemy.dialects.postgresql import UUID
+
+from core.tools.tool_manager import ToolManager
+from extensions.ext_database import db
+from models.account import Account
+
+
+class CreatedByRole(Enum):
+    """
+    Created By Role Enum
+    """
+    ACCOUNT = 'account'
+    END_USER = 'end_user'
+
+    @classmethod
+    def value_of(cls, value: str) -> 'CreatedByRole':
+        """
+        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 created by role value {value}')
+
+
+class WorkflowType(Enum):
+    """
+    Workflow Type Enum
+    """
+    WORKFLOW = 'workflow'
+    CHAT = 'chat'
+
+    @classmethod
+    def value_of(cls, value: str) -> 'WorkflowType':
+        """
+        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 type value {value}')
+
+    @classmethod
+    def from_app_mode(cls, app_mode: Union[str, 'AppMode']) -> 'WorkflowType':
+        """
+        Get workflow type from app mode.
+
+        :param app_mode: app mode
+        :return: workflow type
+        """
+        from models.model import AppMode
+        app_mode = app_mode if isinstance(app_mode, AppMode) else AppMode.value_of(app_mode)
+        return cls.WORKFLOW if app_mode == AppMode.WORKFLOW else cls.CHAT
+
+
+class Workflow(db.Model):
+    """
+    Workflow, for `Workflow App` and `Chat App workflow mode`.
+
+    Attributes:
+
+    - id (uuid) Workflow ID, pk
+    - tenant_id (uuid) Workspace ID
+    - app_id (uuid) App ID
+    - type (string) Workflow type
+
+        `workflow` for `Workflow App`
+
+        `chat` for `Chat App workflow mode`
+
+    - version (string) Version
+
+        `draft` for draft version (only one for each app), other for version number (redundant)
+
+    - graph (text) Workflow canvas configuration (JSON)
+
+        The entire canvas configuration JSON, including Node, Edge, and other configurations
+
+        - nodes (array[object]) Node list, see Node Schema
+
+        - edges (array[object]) Edge list, see Edge Schema
+
+    - created_by (uuid) Creator ID
+    - created_at (timestamp) Creation time
+    - updated_by (uuid) `optional` Last updater ID
+    - updated_at (timestamp) `optional` Last update time
+    """
+
+    __tablename__ = 'workflows'
+    __table_args__ = (
+        db.PrimaryKeyConstraint('id', name='workflow_pkey'),
+        db.Index('workflow_version_idx', 'tenant_id', 'app_id', 'version'),
+    )
+
+    id = db.Column(UUID, server_default=db.text('uuid_generate_v4()'))
+    tenant_id = db.Column(UUID, nullable=False)
+    app_id = db.Column(UUID, nullable=False)
+    type = db.Column(db.String(255), nullable=False)
+    version = db.Column(db.String(255), nullable=False)
+    graph = db.Column(db.Text)
+    features = db.Column(db.Text)
+    created_by = db.Column(UUID, nullable=False)
+    created_at = db.Column(db.DateTime, nullable=False, server_default=db.text('CURRENT_TIMESTAMP(0)'))
+    updated_by = db.Column(UUID)
+    updated_at = db.Column(db.DateTime)
+
+    @property
+    def created_by_account(self):
+        return Account.query.get(self.created_by)
+
+    @property
+    def updated_by_account(self):
+        return Account.query.get(self.updated_by) if self.updated_by else None
+
+    @property
+    def graph_dict(self):
+        return json.loads(self.graph) if self.graph else None
+
+    @property
+    def features_dict(self):
+        return json.loads(self.features) if self.features else {}
+
+    def user_input_form(self, to_old_structure: bool = False) -> list:
+        # get start node from graph
+        if not self.graph:
+            return []
+
+        graph_dict = self.graph_dict
+        if 'nodes' not in graph_dict:
+            return []
+
+        start_node = next((node for node in graph_dict['nodes'] if node['data']['type'] == 'start'), None)
+        if not start_node:
+            return []
+
+        # get user_input_form from start node
+        variables = start_node.get('data', {}).get('variables', [])
+
+        if to_old_structure:
+            old_structure_variables = []
+            for variable in variables:
+                old_structure_variables.append({
+                    variable['type']: variable
+                })
+
+            return old_structure_variables
+
+        return variables
+
+class WorkflowRunTriggeredFrom(Enum):
+    """
+    Workflow Run Triggered From Enum
+    """
+    DEBUGGING = 'debugging'
+    APP_RUN = 'app-run'
+
+    @classmethod
+    def value_of(cls, value: str) -> 'WorkflowRunTriggeredFrom':
+        """
+        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 triggered from value {value}')
+
+
+class WorkflowRunStatus(Enum):
+    """
+    Workflow Run Status Enum
+    """
+    RUNNING = 'running'
+    SUCCEEDED = 'succeeded'
+    FAILED = 'failed'
+    STOPPED = 'stopped'
+
+    @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(db.Model):
+    """
+    Workflow Run
+
+    Attributes:
+
+    - id (uuid) Run ID
+    - tenant_id (uuid) Workspace ID
+    - app_id (uuid) App ID
+    - sequence_number (int) Auto-increment sequence number, incremented within the App, starting from 1
+    - workflow_id (uuid) Workflow ID
+    - type (string) Workflow type
+    - triggered_from (string) Trigger source
+
+        `debugging` for canvas debugging
+
+        `app-run` for (published) app execution
+
+    - version (string) Version
+    - graph (text) Workflow canvas configuration (JSON)
+    - inputs (text) Input parameters
+    - status (string) Execution status, `running` / `succeeded` / `failed` / `stopped`
+    - outputs (text) `optional` Output content
+    - error (string) `optional` Error reason
+    - elapsed_time (float) `optional` Time consumption (s)
+    - total_tokens (int) `optional` Total tokens used
+    - total_steps (int) Total steps (redundant), default 0
+    - created_by_role (string) Creator role
+
+        - `account` Console account
+
+        - `end_user` End user
+
+    - created_by (uuid) Runner ID
+    - created_at (timestamp) Run time
+    - finished_at (timestamp) End time
+    """
+
+    __tablename__ = 'workflow_runs'
+    __table_args__ = (
+        db.PrimaryKeyConstraint('id', name='workflow_run_pkey'),
+        db.Index('workflow_run_triggerd_from_idx', 'tenant_id', 'app_id', 'triggered_from'),
+    )
+
+    id = db.Column(UUID, server_default=db.text('uuid_generate_v4()'))
+    tenant_id = db.Column(UUID, nullable=False)
+    app_id = db.Column(UUID, nullable=False)
+    sequence_number = db.Column(db.Integer, nullable=False)
+    workflow_id = db.Column(UUID, nullable=False)
+    type = db.Column(db.String(255), nullable=False)
+    triggered_from = db.Column(db.String(255), nullable=False)
+    version = db.Column(db.String(255), nullable=False)
+    graph = db.Column(db.Text)
+    inputs = db.Column(db.Text)
+    status = db.Column(db.String(255), nullable=False)
+    outputs = db.Column(db.Text)
+    error = db.Column(db.Text)
+    elapsed_time = db.Column(db.Float, nullable=False, server_default=db.text('0'))
+    total_tokens = db.Column(db.Integer, nullable=False, server_default=db.text('0'))
+    total_steps = db.Column(db.Integer, server_default=db.text('0'))
+    created_by_role = db.Column(db.String(255), nullable=False)
+    created_by = db.Column(UUID, nullable=False)
+    created_at = db.Column(db.DateTime, nullable=False, server_default=db.text('CURRENT_TIMESTAMP(0)'))
+    finished_at = db.Column(db.DateTime)
+
+    @property
+    def created_by_account(self):
+        created_by_role = CreatedByRole.value_of(self.created_by_role)
+        return Account.query.get(self.created_by) \
+            if created_by_role == CreatedByRole.ACCOUNT else None
+
+    @property
+    def created_by_end_user(self):
+        from models.model import EndUser
+        created_by_role = CreatedByRole.value_of(self.created_by_role)
+        return EndUser.query.get(self.created_by) \
+            if created_by_role == CreatedByRole.END_USER else None
+
+    @property
+    def graph_dict(self):
+        return json.loads(self.graph) if self.graph else None
+
+    @property
+    def inputs_dict(self):
+        return json.loads(self.inputs) if self.inputs else None
+
+    @property
+    def outputs_dict(self):
+        return json.loads(self.outputs) if self.outputs else None
+
+    @property
+    def message(self) -> Optional['Message']:
+        from models.model import Message
+        return db.session.query(Message).filter(
+            Message.app_id == self.app_id,
+            Message.workflow_run_id == self.id
+        ).first()
+
+
+class WorkflowNodeExecutionTriggeredFrom(Enum):
+    """
+    Workflow Node Execution Triggered From Enum
+    """
+    SINGLE_STEP = 'single-step'
+    WORKFLOW_RUN = 'workflow-run'
+
+    @classmethod
+    def value_of(cls, value: str) -> 'WorkflowNodeExecutionTriggeredFrom':
+        """
+        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 node execution triggered from value {value}')
+
+
+class WorkflowNodeExecutionStatus(Enum):
+    """
+    Workflow Node Execution Status Enum
+    """
+    RUNNING = 'running'
+    SUCCEEDED = 'succeeded'
+    FAILED = 'failed'
+
+    @classmethod
+    def value_of(cls, value: str) -> 'WorkflowNodeExecutionStatus':
+        """
+        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 node execution status value {value}')
+
+
+class WorkflowNodeExecution(db.Model):
+    """
+    Workflow Node Execution
+
+    - id (uuid) Execution ID
+    - tenant_id (uuid) Workspace ID
+    - app_id (uuid) App ID
+    - workflow_id (uuid) Workflow ID
+    - triggered_from (string) Trigger source
+
+        `single-step` for single-step debugging
+
+        `workflow-run` for workflow execution (debugging / user execution)
+
+    - workflow_run_id (uuid) `optional` Workflow run ID
+
+        Null for single-step debugging.
+
+    - index (int) Execution sequence number, used for displaying Tracing Node order
+    - predecessor_node_id (string) `optional` Predecessor node ID, used for displaying execution path
+    - node_id (string) Node ID
+    - node_type (string) Node type, such as `start`
+    - title (string) Node title
+    - inputs (json) All predecessor node variable content used in the node
+    - process_data (json) Node process data
+    - outputs (json) `optional` Node output variables
+    - status (string) Execution status, `running` / `succeeded` / `failed`
+    - error (string) `optional` Error reason
+    - elapsed_time (float) `optional` Time consumption (s)
+    - execution_metadata (text) Metadata
+
+        - total_tokens (int) `optional` Total tokens used
+
+        - total_price (decimal) `optional` Total cost
+
+        - currency (string) `optional` Currency, such as USD / RMB
+
+    - created_at (timestamp) Run time
+    - created_by_role (string) Creator role
+
+        - `account` Console account
+
+        - `end_user` End user
+
+    - created_by (uuid) Runner ID
+    - finished_at (timestamp) End time
+    """
+
+    __tablename__ = 'workflow_node_executions'
+    __table_args__ = (
+        db.PrimaryKeyConstraint('id', name='workflow_node_execution_pkey'),
+        db.Index('workflow_node_execution_workflow_run_idx', 'tenant_id', 'app_id', 'workflow_id',
+                 'triggered_from', 'workflow_run_id'),
+        db.Index('workflow_node_execution_node_run_idx', 'tenant_id', 'app_id', 'workflow_id',
+                 'triggered_from', 'node_id'),
+    )
+
+    id = db.Column(UUID, server_default=db.text('uuid_generate_v4()'))
+    tenant_id = db.Column(UUID, nullable=False)
+    app_id = db.Column(UUID, nullable=False)
+    workflow_id = db.Column(UUID, nullable=False)
+    triggered_from = db.Column(db.String(255), nullable=False)
+    workflow_run_id = db.Column(UUID)
+    index = db.Column(db.Integer, nullable=False)
+    predecessor_node_id = db.Column(db.String(255))
+    node_id = db.Column(db.String(255), nullable=False)
+    node_type = db.Column(db.String(255), nullable=False)
+    title = db.Column(db.String(255), nullable=False)
+    inputs = db.Column(db.Text)
+    process_data = db.Column(db.Text)
+    outputs = db.Column(db.Text)
+    status = db.Column(db.String(255), nullable=False)
+    error = db.Column(db.Text)
+    elapsed_time = db.Column(db.Float, nullable=False, server_default=db.text('0'))
+    execution_metadata = db.Column(db.Text)
+    created_at = db.Column(db.DateTime, nullable=False, server_default=db.text('CURRENT_TIMESTAMP(0)'))
+    created_by_role = db.Column(db.String(255), nullable=False)
+    created_by = db.Column(UUID, nullable=False)
+    finished_at = db.Column(db.DateTime)
+
+    @property
+    def created_by_account(self):
+        created_by_role = CreatedByRole.value_of(self.created_by_role)
+        return Account.query.get(self.created_by) \
+            if created_by_role == CreatedByRole.ACCOUNT else None
+
+    @property
+    def created_by_end_user(self):
+        from models.model import EndUser
+        created_by_role = CreatedByRole.value_of(self.created_by_role)
+        return EndUser.query.get(self.created_by) \
+            if created_by_role == CreatedByRole.END_USER else None
+
+    @property
+    def inputs_dict(self):
+        return json.loads(self.inputs) if self.inputs else None
+
+    @property
+    def outputs_dict(self):
+        return json.loads(self.outputs) if self.outputs else None
+
+    @property
+    def process_data_dict(self):
+        return json.loads(self.process_data) if self.process_data else None
+
+    @property
+    def execution_metadata_dict(self):
+        return json.loads(self.execution_metadata) if self.execution_metadata else None
+
+    @property
+    def extras(self):
+        extras = {}
+        if self.execution_metadata_dict:
+            from core.workflow.entities.node_entities import NodeType
+            if self.node_type == NodeType.TOOL.value and 'tool_info' in self.execution_metadata_dict:
+                tool_info = self.execution_metadata_dict['tool_info']
+                extras['icon'] = ToolManager.get_tool_icon(
+                    tenant_id=self.tenant_id,
+                    provider_type=tool_info['provider_type'],
+                    provider_id=tool_info['provider_id']
+                )
+
+        return extras
+
+
+class WorkflowAppLogCreatedFrom(Enum):
+    """
+    Workflow App Log Created From Enum
+    """
+    SERVICE_API = 'service-api'
+    WEB_APP = 'web-app'
+    INSTALLED_APP = 'installed-app'
+
+    @classmethod
+    def value_of(cls, value: str) -> 'WorkflowAppLogCreatedFrom':
+        """
+        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 app log created from value {value}')
+
+
+class WorkflowAppLog(db.Model):
+    """
+    Workflow App execution log, excluding workflow debugging records.
+
+    Attributes:
+
+    - id (uuid) run ID
+    - tenant_id (uuid) Workspace ID
+    - app_id (uuid) App ID
+    - workflow_id (uuid) Associated Workflow ID
+    - workflow_run_id (uuid) Associated Workflow Run ID
+    - created_from (string) Creation source
+
+        `service-api` App Execution OpenAPI
+
+        `web-app` WebApp
+
+        `installed-app` Installed App
+
+    - created_by_role (string) Creator role
+
+        - `account` Console account
+
+        - `end_user` End user
+
+    - created_by (uuid) Creator ID, depends on the user table according to created_by_role
+    - created_at (timestamp) Creation time
+    """
+
+    __tablename__ = 'workflow_app_logs'
+    __table_args__ = (
+        db.PrimaryKeyConstraint('id', name='workflow_app_log_pkey'),
+        db.Index('workflow_app_log_app_idx', 'tenant_id', 'app_id'),
+    )
+
+    id = db.Column(UUID, server_default=db.text('uuid_generate_v4()'))
+    tenant_id = db.Column(UUID, nullable=False)
+    app_id = db.Column(UUID, nullable=False)
+    workflow_id = db.Column(UUID, nullable=False)
+    workflow_run_id = db.Column(UUID, nullable=False)
+    created_from = db.Column(db.String(255), nullable=False)
+    created_by_role = db.Column(db.String(255), nullable=False)
+    created_by = db.Column(UUID, nullable=False)
+    created_at = db.Column(db.DateTime, nullable=False, server_default=db.text('CURRENT_TIMESTAMP(0)'))
+
+    @property
+    def workflow_run(self):
+        return WorkflowRun.query.get(self.workflow_run_id)
+
+    @property
+    def created_by_account(self):
+        created_by_role = CreatedByRole.value_of(self.created_by_role)
+        return Account.query.get(self.created_by) \
+            if created_by_role == CreatedByRole.ACCOUNT else None
+
+    @property
+    def created_by_end_user(self):
+        from models.model import EndUser
+        created_by_role = CreatedByRole.value_of(self.created_by_role)
+        return EndUser.query.get(self.created_by) \
+            if created_by_role == CreatedByRole.END_USER else None