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/core/app/apps/README.md

@@ -0,0 +1,48 @@
+## Guidelines for Database Connection Management in App Runner and Task Pipeline
+
+Due to the presence of tasks in App Runner that require long execution times, such as LLM generation and external requests, Flask-Sqlalchemy's strategy for database connection pooling is to allocate one connection (transaction) per request. This approach keeps a connection occupied even during non-DB tasks, leading to the inability to acquire new connections during high concurrency requests due to multiple long-running tasks.
+
+Therefore, the database operations in App Runner and Task Pipeline must ensure connections are closed immediately after use, and it's better to pass IDs rather than Model objects to avoid deattach errors.
+
+Examples:
+
+1. Creating a new record:
+
+   ```python
+   app = App(id=1)
+   db.session.add(app)
+   db.session.commit()
+   db.session.refresh(app)  # Retrieve table default values, like created_at, cached in the app object, won't affect after close
+   
+   # Handle non-long-running tasks or store the content of the App instance in memory (via variable assignment).
+   
+   db.session.close()
+   
+   return app.id
+   ```
+
+2. Fetching a record from the table:
+
+   ```python
+   app = db.session.query(App).filter(App.id == app_id).first()
+    
+   created_at = app.created_at
+    
+   db.session.close()
+   
+   # Handle tasks (include long-running).
+   
+   ```
+
+3. Updating a table field:
+
+   ```python
+   app = db.session.query(App).filter(App.id == app_id).first()
+
+   app.updated_at = time.utcnow()
+   db.session.commit()
+   db.session.close()
+
+   return app_id
+   ```
+   

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

@@ -0,0 +1,101 @@
+
+from core.app.app_config.base_app_config_manager import BaseAppConfigManager
+from core.app.app_config.common.sensitive_word_avoidance.manager import SensitiveWordAvoidanceConfigManager
+from core.app.app_config.entities import WorkflowUIBasedAppConfig
+from core.app.app_config.features.file_upload.manager import FileUploadConfigManager
+from core.app.app_config.features.opening_statement.manager import OpeningStatementConfigManager
+from core.app.app_config.features.retrieval_resource.manager import RetrievalResourceConfigManager
+from core.app.app_config.features.speech_to_text.manager import SpeechToTextConfigManager
+from core.app.app_config.features.suggested_questions_after_answer.manager import (
+    SuggestedQuestionsAfterAnswerConfigManager,
+)
+from core.app.app_config.features.text_to_speech.manager import TextToSpeechConfigManager
+from core.app.app_config.workflow_ui_based_app.variables.manager import WorkflowVariablesConfigManager
+from models.model import App, AppMode
+from models.workflow import Workflow
+
+
+class AdvancedChatAppConfig(WorkflowUIBasedAppConfig):
+    """
+    Advanced Chatbot App Config Entity.
+    """
+    pass
+
+
+class AdvancedChatAppConfigManager(BaseAppConfigManager):
+    @classmethod
+    def get_app_config(cls, app_model: App,
+                       workflow: Workflow) -> AdvancedChatAppConfig:
+        features_dict = workflow.features_dict
+
+        app_mode = AppMode.value_of(app_model.mode)
+        app_config = AdvancedChatAppConfig(
+            tenant_id=app_model.tenant_id,
+            app_id=app_model.id,
+            app_mode=app_mode,
+            workflow_id=workflow.id,
+            sensitive_word_avoidance=SensitiveWordAvoidanceConfigManager.convert(
+                config=features_dict
+            ),
+            variables=WorkflowVariablesConfigManager.convert(
+                workflow=workflow
+            ),
+            additional_features=cls.convert_features(features_dict, app_mode)
+        )
+
+        return app_config
+
+    @classmethod
+    def config_validate(cls, tenant_id: str, config: dict, only_structure_validate: bool = False) -> dict:
+        """
+        Validate for advanced chat app model config
+
+        :param tenant_id: tenant id
+        :param config: app model config args
+        :param only_structure_validate: if True, only structure validation will be performed
+        """
+        related_config_keys = []
+
+        # file upload validation
+        config, current_related_config_keys = FileUploadConfigManager.validate_and_set_defaults(
+            config=config,
+            is_vision=False
+        )
+        related_config_keys.extend(current_related_config_keys)
+
+        # opening_statement
+        config, current_related_config_keys = OpeningStatementConfigManager.validate_and_set_defaults(config)
+        related_config_keys.extend(current_related_config_keys)
+
+        # suggested_questions_after_answer
+        config, current_related_config_keys = SuggestedQuestionsAfterAnswerConfigManager.validate_and_set_defaults(
+            config)
+        related_config_keys.extend(current_related_config_keys)
+
+        # speech_to_text
+        config, current_related_config_keys = SpeechToTextConfigManager.validate_and_set_defaults(config)
+        related_config_keys.extend(current_related_config_keys)
+
+        # text_to_speech
+        config, current_related_config_keys = TextToSpeechConfigManager.validate_and_set_defaults(config)
+        related_config_keys.extend(current_related_config_keys)
+
+        # return retriever resource
+        config, current_related_config_keys = RetrievalResourceConfigManager.validate_and_set_defaults(config)
+        related_config_keys.extend(current_related_config_keys)
+
+        # moderation validation
+        config, current_related_config_keys = SensitiveWordAvoidanceConfigManager.validate_and_set_defaults(
+            tenant_id=tenant_id,
+            config=config,
+            only_structure_validate=only_structure_validate
+        )
+        related_config_keys.extend(current_related_config_keys)
+
+        related_config_keys = list(set(related_config_keys))
+
+        # Filter out extra parameters
+        filtered_config = {key: config.get(key) for key in related_config_keys}
+
+        return filtered_config
+

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

@@ -0,0 +1,236 @@
+import logging
+import threading
+import uuid
+from collections.abc import Generator
+from typing import Union
+
+from flask import Flask, current_app
+from pydantic import ValidationError
+
+from core.app.app_config.features.file_upload.manager import FileUploadConfigManager
+from core.app.apps.advanced_chat.app_config_manager import AdvancedChatAppConfigManager
+from core.app.apps.advanced_chat.app_runner import AdvancedChatAppRunner
+from core.app.apps.advanced_chat.generate_response_converter import AdvancedChatAppGenerateResponseConverter
+from core.app.apps.advanced_chat.generate_task_pipeline import AdvancedChatAppGenerateTaskPipeline
+from core.app.apps.base_app_queue_manager import AppQueueManager, GenerateTaskStoppedException, PublishFrom
+from core.app.apps.message_based_app_generator import MessageBasedAppGenerator
+from core.app.apps.message_based_app_queue_manager import MessageBasedAppQueueManager
+from core.app.entities.app_invoke_entities import AdvancedChatAppGenerateEntity, InvokeFrom
+from core.app.entities.task_entities import ChatbotAppBlockingResponse, ChatbotAppStreamResponse
+from core.file.message_file_parser import MessageFileParser
+from core.model_runtime.errors.invoke import InvokeAuthorizationError, InvokeError
+from extensions.ext_database import db
+from models.account import Account
+from models.model import App, Conversation, EndUser, Message
+from models.workflow import Workflow
+
+logger = logging.getLogger(__name__)
+
+
+class AdvancedChatAppGenerator(MessageBasedAppGenerator):
+    def generate(self, app_model: App,
+                 workflow: Workflow,
+                 user: Union[Account, EndUser],
+                 args: dict,
+                 invoke_from: InvokeFrom,
+                 stream: bool = True) \
+            -> Union[dict, Generator[dict, None, None]]:
+        """
+        Generate App response.
+
+        :param app_model: App
+        :param workflow: Workflow
+        :param user: account or end user
+        :param args: request args
+        :param invoke_from: invoke from source
+        :param stream: is stream
+        """
+        if not args.get('query'):
+            raise ValueError('query is required')
+
+        query = args['query']
+        if not isinstance(query, str):
+            raise ValueError('query must be a string')
+
+        query = query.replace('\x00', '')
+        inputs = args['inputs']
+
+        extras = {
+            "auto_generate_conversation_name": args['auto_generate_name'] if 'auto_generate_name' in args else False
+        }
+
+        # get conversation
+        conversation = None
+        if args.get('conversation_id'):
+            conversation = self._get_conversation_by_user(app_model, args.get('conversation_id'), user)
+
+        # parse files
+        files = args['files'] if 'files' in args and args['files'] else []
+        message_file_parser = MessageFileParser(tenant_id=app_model.tenant_id, app_id=app_model.id)
+        file_extra_config = FileUploadConfigManager.convert(workflow.features_dict, is_vision=False)
+        if file_extra_config:
+            file_objs = message_file_parser.validate_and_transform_files_arg(
+                files,
+                file_extra_config,
+                user
+            )
+        else:
+            file_objs = []
+
+        # convert to app config
+        app_config = AdvancedChatAppConfigManager.get_app_config(
+            app_model=app_model,
+            workflow=workflow
+        )
+
+        # init application generate entity
+        application_generate_entity = AdvancedChatAppGenerateEntity(
+            task_id=str(uuid.uuid4()),
+            app_config=app_config,
+            conversation_id=conversation.id if conversation else None,
+            inputs=conversation.inputs if conversation else self._get_cleaned_inputs(inputs, app_config),
+            query=query,
+            files=file_objs,
+            user_id=user.id,
+            stream=stream,
+            invoke_from=invoke_from,
+            extras=extras
+        )
+
+        is_first_conversation = False
+        if not conversation:
+            is_first_conversation = True
+
+        # init generate records
+        (
+            conversation,
+            message
+        ) = self._init_generate_records(application_generate_entity, conversation)
+
+        if is_first_conversation:
+            # update conversation features
+            conversation.override_model_configs = workflow.features
+            db.session.commit()
+            db.session.refresh(conversation)
+
+        # init queue manager
+        queue_manager = MessageBasedAppQueueManager(
+            task_id=application_generate_entity.task_id,
+            user_id=application_generate_entity.user_id,
+            invoke_from=application_generate_entity.invoke_from,
+            conversation_id=conversation.id,
+            app_mode=conversation.mode,
+            message_id=message.id
+        )
+
+        # new thread
+        worker_thread = threading.Thread(target=self._generate_worker, kwargs={
+            'flask_app': current_app._get_current_object(),
+            'application_generate_entity': application_generate_entity,
+            'queue_manager': queue_manager,
+            'conversation_id': conversation.id,
+            'message_id': message.id,
+        })
+
+        worker_thread.start()
+
+        # return response or stream generator
+        response = self._handle_advanced_chat_response(
+            application_generate_entity=application_generate_entity,
+            workflow=workflow,
+            queue_manager=queue_manager,
+            conversation=conversation,
+            message=message,
+            user=user,
+            stream=stream
+        )
+
+        return AdvancedChatAppGenerateResponseConverter.convert(
+            response=response,
+            invoke_from=invoke_from
+        )
+
+    def _generate_worker(self, flask_app: Flask,
+                         application_generate_entity: AdvancedChatAppGenerateEntity,
+                         queue_manager: AppQueueManager,
+                         conversation_id: str,
+                         message_id: str) -> None:
+        """
+        Generate worker in a new thread.
+        :param flask_app: Flask app
+        :param application_generate_entity: application generate entity
+        :param queue_manager: queue manager
+        :param conversation_id: conversation ID
+        :param message_id: message ID
+        :return:
+        """
+        with flask_app.app_context():
+            try:
+                # get conversation and message
+                conversation = self._get_conversation(conversation_id)
+                message = self._get_message(message_id)
+
+                # chatbot app
+                runner = AdvancedChatAppRunner()
+                runner.run(
+                    application_generate_entity=application_generate_entity,
+                    queue_manager=queue_manager,
+                    conversation=conversation,
+                    message=message
+                )
+            except GenerateTaskStoppedException:
+                pass
+            except InvokeAuthorizationError:
+                queue_manager.publish_error(
+                    InvokeAuthorizationError('Incorrect API key provided'),
+                    PublishFrom.APPLICATION_MANAGER
+                )
+            except ValidationError as e:
+                logger.exception("Validation Error when generating")
+                queue_manager.publish_error(e, PublishFrom.APPLICATION_MANAGER)
+            except (ValueError, InvokeError) as e:
+                queue_manager.publish_error(e, PublishFrom.APPLICATION_MANAGER)
+            except Exception as e:
+                logger.exception("Unknown Error when generating")
+                queue_manager.publish_error(e, PublishFrom.APPLICATION_MANAGER)
+            finally:
+                db.session.close()
+
+    def _handle_advanced_chat_response(self, application_generate_entity: AdvancedChatAppGenerateEntity,
+                                       workflow: Workflow,
+                                       queue_manager: AppQueueManager,
+                                       conversation: Conversation,
+                                       message: Message,
+                                       user: Union[Account, EndUser],
+                                       stream: bool = False) \
+            -> Union[ChatbotAppBlockingResponse, Generator[ChatbotAppStreamResponse, None, None]]:
+        """
+        Handle response.
+        :param application_generate_entity: application generate entity
+        :param workflow: workflow
+        :param queue_manager: queue manager
+        :param conversation: conversation
+        :param message: message
+        :param user: account or end user
+        :param stream: is stream
+        :return:
+        """
+        # init generate task pipeline
+        generate_task_pipeline = AdvancedChatAppGenerateTaskPipeline(
+            application_generate_entity=application_generate_entity,
+            workflow=workflow,
+            queue_manager=queue_manager,
+            conversation=conversation,
+            message=message,
+            user=user,
+            stream=stream
+        )
+
+        try:
+            return generate_task_pipeline.process()
+        except ValueError as e:
+            if e.args[0] == "I/O operation on closed file.":  # ignore this error
+                raise GenerateTaskStoppedException()
+            else:
+                logger.exception(e)
+                raise e

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

@@ -0,0 +1,217 @@
+import logging
+import os
+import time
+from typing import Optional, cast
+
+from core.app.apps.advanced_chat.app_config_manager import AdvancedChatAppConfig
+from core.app.apps.advanced_chat.workflow_event_trigger_callback import WorkflowEventTriggerCallback
+from core.app.apps.base_app_queue_manager import AppQueueManager, PublishFrom
+from core.app.apps.base_app_runner import AppRunner
+from core.app.apps.workflow_logging_callback import WorkflowLoggingCallback
+from core.app.entities.app_invoke_entities import (
+    AdvancedChatAppGenerateEntity,
+    InvokeFrom,
+)
+from core.app.entities.queue_entities import QueueAnnotationReplyEvent, QueueStopEvent, QueueTextChunkEvent
+from core.moderation.base import ModerationException
+from core.workflow.entities.node_entities import SystemVariable
+from core.workflow.nodes.base_node import UserFrom
+from core.workflow.workflow_engine_manager import WorkflowEngineManager
+from extensions.ext_database import db
+from models.model import App, Conversation, Message
+from models.workflow import Workflow
+
+logger = logging.getLogger(__name__)
+
+
+class AdvancedChatAppRunner(AppRunner):
+    """
+    AdvancedChat Application Runner
+    """
+
+    def run(self, application_generate_entity: AdvancedChatAppGenerateEntity,
+            queue_manager: AppQueueManager,
+            conversation: Conversation,
+            message: Message) -> None:
+        """
+        Run application
+        :param application_generate_entity: application generate entity
+        :param queue_manager: application queue manager
+        :param conversation: conversation
+        :param message: message
+        :return:
+        """
+        app_config = application_generate_entity.app_config
+        app_config = cast(AdvancedChatAppConfig, app_config)
+
+        app_record = db.session.query(App).filter(App.id == app_config.app_id).first()
+        if not app_record:
+            raise ValueError("App not found")
+
+        workflow = self.get_workflow(app_model=app_record, workflow_id=app_config.workflow_id)
+        if not workflow:
+            raise ValueError("Workflow not initialized")
+
+        inputs = application_generate_entity.inputs
+        query = application_generate_entity.query
+        files = application_generate_entity.files
+
+        # moderation
+        if self.handle_input_moderation(
+                queue_manager=queue_manager,
+                app_record=app_record,
+                app_generate_entity=application_generate_entity,
+                inputs=inputs,
+                query=query
+        ):
+            return
+
+        # annotation reply
+        if self.handle_annotation_reply(
+                app_record=app_record,
+                message=message,
+                query=query,
+                queue_manager=queue_manager,
+                app_generate_entity=application_generate_entity
+        ):
+            return
+
+        db.session.close()
+
+        workflow_callbacks = [WorkflowEventTriggerCallback(
+            queue_manager=queue_manager,
+            workflow=workflow
+        )]
+
+        if bool(os.environ.get("DEBUG", 'False').lower() == 'true'):
+            workflow_callbacks.append(WorkflowLoggingCallback())
+
+        # RUN WORKFLOW
+        workflow_engine_manager = WorkflowEngineManager()
+        workflow_engine_manager.run_workflow(
+            workflow=workflow,
+            user_id=application_generate_entity.user_id,
+            user_from=UserFrom.ACCOUNT
+            if application_generate_entity.invoke_from in [InvokeFrom.EXPLORE, InvokeFrom.DEBUGGER]
+            else UserFrom.END_USER,
+            user_inputs=inputs,
+            system_inputs={
+                SystemVariable.QUERY: query,
+                SystemVariable.FILES: files,
+                SystemVariable.CONVERSATION: conversation.id,
+            },
+            callbacks=workflow_callbacks
+        )
+
+    def get_workflow(self, app_model: App, workflow_id: str) -> Optional[Workflow]:
+        """
+        Get workflow
+        """
+        # fetch workflow by workflow_id
+        workflow = db.session.query(Workflow).filter(
+            Workflow.tenant_id == app_model.tenant_id,
+            Workflow.app_id == app_model.id,
+            Workflow.id == workflow_id
+        ).first()
+
+        # return workflow
+        return workflow
+
+    def handle_input_moderation(self, queue_manager: AppQueueManager,
+                                app_record: App,
+                                app_generate_entity: AdvancedChatAppGenerateEntity,
+                                inputs: dict,
+                                query: str) -> bool:
+        """
+        Handle input moderation
+        :param queue_manager: application queue manager
+        :param app_record: app record
+        :param app_generate_entity: application generate entity
+        :param inputs: inputs
+        :param query: query
+        :return:
+        """
+        try:
+            # process sensitive_word_avoidance
+            _, inputs, query = self.moderation_for_inputs(
+                app_id=app_record.id,
+                tenant_id=app_generate_entity.app_config.tenant_id,
+                app_generate_entity=app_generate_entity,
+                inputs=inputs,
+                query=query,
+            )
+        except ModerationException as e:
+            self._stream_output(
+                queue_manager=queue_manager,
+                text=str(e),
+                stream=app_generate_entity.stream,
+                stopped_by=QueueStopEvent.StopBy.INPUT_MODERATION
+            )
+            return True
+
+        return False
+
+    def handle_annotation_reply(self, app_record: App,
+                                message: Message,
+                                query: str,
+                                queue_manager: AppQueueManager,
+                                app_generate_entity: AdvancedChatAppGenerateEntity) -> bool:
+        """
+        Handle annotation reply
+        :param app_record: app record
+        :param message: message
+        :param query: query
+        :param queue_manager: application queue manager
+        :param app_generate_entity: application generate entity
+        """
+        # annotation reply
+        annotation_reply = self.query_app_annotations_to_reply(
+            app_record=app_record,
+            message=message,
+            query=query,
+            user_id=app_generate_entity.user_id,
+            invoke_from=app_generate_entity.invoke_from
+        )
+
+        if annotation_reply:
+            queue_manager.publish(
+                QueueAnnotationReplyEvent(message_annotation_id=annotation_reply.id),
+                PublishFrom.APPLICATION_MANAGER
+            )
+
+            self._stream_output(
+                queue_manager=queue_manager,
+                text=annotation_reply.content,
+                stream=app_generate_entity.stream,
+                stopped_by=QueueStopEvent.StopBy.ANNOTATION_REPLY
+            )
+            return True
+
+        return False
+
+    def _stream_output(self, queue_manager: AppQueueManager,
+                       text: str,
+                       stream: bool,
+                       stopped_by: QueueStopEvent.StopBy) -> None:
+        """
+        Direct output
+        :param queue_manager: application queue manager
+        :param text: text
+        :param stream: stream
+        :return:
+        """
+        if stream:
+            index = 0
+            for token in text:
+                queue_manager.publish(
+                    QueueTextChunkEvent(
+                        text=token
+                    ), PublishFrom.APPLICATION_MANAGER
+                )
+                index += 1
+                time.sleep(0.01)
+
+        queue_manager.publish(
+            QueueStopEvent(stopped_by=stopped_by),
+            PublishFrom.APPLICATION_MANAGER
+        )

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

@@ -0,0 +1,117 @@
+import json
+from collections.abc import Generator
+from typing import cast
+
+from core.app.apps.base_app_generate_response_converter import AppGenerateResponseConverter
+from core.app.entities.task_entities import (
+    ChatbotAppBlockingResponse,
+    ChatbotAppStreamResponse,
+    ErrorStreamResponse,
+    MessageEndStreamResponse,
+    PingStreamResponse,
+)
+
+
+class AdvancedChatAppGenerateResponseConverter(AppGenerateResponseConverter):
+    _blocking_response_type = ChatbotAppBlockingResponse
+
+    @classmethod
+    def convert_blocking_full_response(cls, blocking_response: ChatbotAppBlockingResponse) -> dict:
+        """
+        Convert blocking full response.
+        :param blocking_response: blocking response
+        :return:
+        """
+        response = {
+            'event': 'message',
+            'task_id': blocking_response.task_id,
+            'id': blocking_response.data.id,
+            'message_id': blocking_response.data.message_id,
+            'conversation_id': blocking_response.data.conversation_id,
+            'mode': blocking_response.data.mode,
+            'answer': blocking_response.data.answer,
+            'metadata': blocking_response.data.metadata,
+            'created_at': blocking_response.data.created_at
+        }
+
+        return response
+
+    @classmethod
+    def convert_blocking_simple_response(cls, blocking_response: ChatbotAppBlockingResponse) -> dict:
+        """
+        Convert blocking simple response.
+        :param blocking_response: blocking response
+        :return:
+        """
+        response = cls.convert_blocking_full_response(blocking_response)
+
+        metadata = response.get('metadata', {})
+        response['metadata'] = cls._get_simple_metadata(metadata)
+
+        return response
+
+    @classmethod
+    def convert_stream_full_response(cls, stream_response: Generator[ChatbotAppStreamResponse, None, None]) \
+            -> Generator[str, None, None]:
+        """
+        Convert stream full response.
+        :param stream_response: stream response
+        :return:
+        """
+        for chunk in stream_response:
+            chunk = cast(ChatbotAppStreamResponse, chunk)
+            sub_stream_response = chunk.stream_response
+
+            if isinstance(sub_stream_response, PingStreamResponse):
+                yield 'ping'
+                continue
+
+            response_chunk = {
+                'event': sub_stream_response.event.value,
+                'conversation_id': chunk.conversation_id,
+                'message_id': chunk.message_id,
+                'created_at': chunk.created_at
+            }
+
+            if isinstance(sub_stream_response, ErrorStreamResponse):
+                data = cls._error_to_stream_response(sub_stream_response.err)
+                response_chunk.update(data)
+            else:
+                response_chunk.update(sub_stream_response.to_dict())
+            yield json.dumps(response_chunk)
+
+    @classmethod
+    def convert_stream_simple_response(cls, stream_response: Generator[ChatbotAppStreamResponse, None, None]) \
+            -> Generator[str, None, None]:
+        """
+        Convert stream simple response.
+        :param stream_response: stream response
+        :return:
+        """
+        for chunk in stream_response:
+            chunk = cast(ChatbotAppStreamResponse, chunk)
+            sub_stream_response = chunk.stream_response
+
+            if isinstance(sub_stream_response, PingStreamResponse):
+                yield 'ping'
+                continue
+
+            response_chunk = {
+                'event': sub_stream_response.event.value,
+                'conversation_id': chunk.conversation_id,
+                'message_id': chunk.message_id,
+                'created_at': chunk.created_at
+            }
+
+            if isinstance(sub_stream_response, MessageEndStreamResponse):
+                sub_stream_response_dict = sub_stream_response.to_dict()
+                metadata = sub_stream_response_dict.get('metadata', {})
+                sub_stream_response_dict['metadata'] = cls._get_simple_metadata(metadata)
+                response_chunk.update(sub_stream_response_dict)
+            if isinstance(sub_stream_response, ErrorStreamResponse):
+                data = cls._error_to_stream_response(sub_stream_response.err)
+                response_chunk.update(data)
+            else:
+                response_chunk.update(sub_stream_response.to_dict())
+
+            yield json.dumps(response_chunk)

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

@@ -0,0 +1,611 @@
+import json
+import logging
+import time
+from collections.abc import Generator
+from typing import Any, Optional, Union, cast
+
+from core.app.apps.base_app_queue_manager import AppQueueManager, PublishFrom
+from core.app.entities.app_invoke_entities import (
+    AdvancedChatAppGenerateEntity,
+)
+from core.app.entities.queue_entities import (
+    QueueAdvancedChatMessageEndEvent,
+    QueueAnnotationReplyEvent,
+    QueueErrorEvent,
+    QueueMessageReplaceEvent,
+    QueueNodeFailedEvent,
+    QueueNodeStartedEvent,
+    QueueNodeSucceededEvent,
+    QueuePingEvent,
+    QueueRetrieverResourcesEvent,
+    QueueStopEvent,
+    QueueTextChunkEvent,
+    QueueWorkflowFailedEvent,
+    QueueWorkflowStartedEvent,
+    QueueWorkflowSucceededEvent,
+)
+from core.app.entities.task_entities import (
+    AdvancedChatTaskState,
+    ChatbotAppBlockingResponse,
+    ChatbotAppStreamResponse,
+    ErrorStreamResponse,
+    MessageEndStreamResponse,
+    StreamGenerateRoute,
+    StreamResponse,
+)
+from core.app.task_pipeline.based_generate_task_pipeline import BasedGenerateTaskPipeline
+from core.app.task_pipeline.message_cycle_manage import MessageCycleManage
+from core.app.task_pipeline.workflow_cycle_manage import WorkflowCycleManage
+from core.file.file_obj import FileVar
+from core.model_runtime.entities.llm_entities import LLMUsage
+from core.model_runtime.utils.encoders import jsonable_encoder
+from core.workflow.entities.node_entities import NodeType, SystemVariable
+from core.workflow.nodes.answer.answer_node import AnswerNode
+from core.workflow.nodes.answer.entities import TextGenerateRouteChunk, VarGenerateRouteChunk
+from events.message_event import message_was_created
+from extensions.ext_database import db
+from models.account import Account
+from models.model import Conversation, EndUser, Message
+from models.workflow import (
+    Workflow,
+    WorkflowNodeExecution,
+    WorkflowRunStatus,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class AdvancedChatAppGenerateTaskPipeline(BasedGenerateTaskPipeline, WorkflowCycleManage, MessageCycleManage):
+    """
+    AdvancedChatAppGenerateTaskPipeline is a class that generate stream output and state management for Application.
+    """
+    _task_state: AdvancedChatTaskState
+    _application_generate_entity: AdvancedChatAppGenerateEntity
+    _workflow: Workflow
+    _user: Union[Account, EndUser]
+    _workflow_system_variables: dict[SystemVariable, Any]
+
+    def __init__(self, application_generate_entity: AdvancedChatAppGenerateEntity,
+                 workflow: Workflow,
+                 queue_manager: AppQueueManager,
+                 conversation: Conversation,
+                 message: Message,
+                 user: Union[Account, EndUser],
+                 stream: bool) -> None:
+        """
+        Initialize AdvancedChatAppGenerateTaskPipeline.
+        :param application_generate_entity: application generate entity
+        :param workflow: workflow
+        :param queue_manager: queue manager
+        :param conversation: conversation
+        :param message: message
+        :param user: user
+        :param stream: stream
+        """
+        super().__init__(application_generate_entity, queue_manager, user, stream)
+
+        self._workflow = workflow
+        self._conversation = conversation
+        self._message = message
+        self._workflow_system_variables = {
+            SystemVariable.QUERY: message.query,
+            SystemVariable.FILES: application_generate_entity.files,
+            SystemVariable.CONVERSATION: conversation.id,
+        }
+
+        self._task_state = AdvancedChatTaskState(
+            usage=LLMUsage.empty_usage()
+        )
+
+        self._stream_generate_routes = self._get_stream_generate_routes()
+
+    def process(self) -> Union[ChatbotAppBlockingResponse, Generator[ChatbotAppStreamResponse, None, None]]:
+        """
+        Process generate task pipeline.
+        :return:
+        """
+        db.session.refresh(self._workflow)
+        db.session.refresh(self._user)
+        db.session.close()
+
+        generator = self._process_stream_response()
+        if self._stream:
+            return self._to_stream_response(generator)
+        else:
+            return self._to_blocking_response(generator)
+
+    def _to_blocking_response(self, generator: Generator[StreamResponse, None, None]) \
+            -> ChatbotAppBlockingResponse:
+        """
+        Process blocking response.
+        :return:
+        """
+        for stream_response in generator:
+            if isinstance(stream_response, ErrorStreamResponse):
+                raise stream_response.err
+            elif isinstance(stream_response, MessageEndStreamResponse):
+                extras = {}
+                if stream_response.metadata:
+                    extras['metadata'] = stream_response.metadata
+
+                return ChatbotAppBlockingResponse(
+                    task_id=stream_response.task_id,
+                    data=ChatbotAppBlockingResponse.Data(
+                        id=self._message.id,
+                        mode=self._conversation.mode,
+                        conversation_id=self._conversation.id,
+                        message_id=self._message.id,
+                        answer=self._task_state.answer,
+                        created_at=int(self._message.created_at.timestamp()),
+                        **extras
+                    )
+                )
+            else:
+                continue
+
+        raise Exception('Queue listening stopped unexpectedly.')
+
+    def _to_stream_response(self, generator: Generator[StreamResponse, None, None]) \
+            -> Generator[ChatbotAppStreamResponse, None, None]:
+        """
+        To stream response.
+        :return:
+        """
+        for stream_response in generator:
+            yield ChatbotAppStreamResponse(
+                conversation_id=self._conversation.id,
+                message_id=self._message.id,
+                created_at=int(self._message.created_at.timestamp()),
+                stream_response=stream_response
+            )
+
+    def _process_stream_response(self) -> Generator[StreamResponse, None, None]:
+        """
+        Process stream response.
+        :return:
+        """
+        for message in self._queue_manager.listen():
+            event = message.event
+
+            if isinstance(event, QueueErrorEvent):
+                err = self._handle_error(event, self._message)
+                yield self._error_to_stream_response(err)
+                break
+            elif isinstance(event, QueueWorkflowStartedEvent):
+                workflow_run = self._handle_workflow_start()
+
+                self._message = db.session.query(Message).filter(Message.id == self._message.id).first()
+                self._message.workflow_run_id = workflow_run.id
+
+                db.session.commit()
+                db.session.refresh(self._message)
+                db.session.close()
+
+                yield self._workflow_start_to_stream_response(
+                    task_id=self._application_generate_entity.task_id,
+                    workflow_run=workflow_run
+                )
+            elif isinstance(event, QueueNodeStartedEvent):
+                workflow_node_execution = self._handle_node_start(event)
+
+                # search stream_generate_routes if node id is answer start at node
+                if not self._task_state.current_stream_generate_state and event.node_id in self._stream_generate_routes:
+                    self._task_state.current_stream_generate_state = self._stream_generate_routes[event.node_id]
+
+                    # generate stream outputs when node started
+                    yield from self._generate_stream_outputs_when_node_started()
+
+                yield self._workflow_node_start_to_stream_response(
+                    event=event,
+                    task_id=self._application_generate_entity.task_id,
+                    workflow_node_execution=workflow_node_execution
+                )
+            elif isinstance(event, QueueNodeSucceededEvent | QueueNodeFailedEvent):
+                workflow_node_execution = self._handle_node_finished(event)
+
+                # stream outputs when node finished
+                generator = self._generate_stream_outputs_when_node_finished()
+                if generator:
+                    yield from generator
+
+                yield self._workflow_node_finish_to_stream_response(
+                    task_id=self._application_generate_entity.task_id,
+                    workflow_node_execution=workflow_node_execution
+                )
+            elif isinstance(event, QueueStopEvent | QueueWorkflowSucceededEvent | QueueWorkflowFailedEvent):
+                workflow_run = self._handle_workflow_finished(event)
+                if workflow_run:
+                    yield self._workflow_finish_to_stream_response(
+                        task_id=self._application_generate_entity.task_id,
+                        workflow_run=workflow_run
+                    )
+
+                    if workflow_run.status == WorkflowRunStatus.FAILED.value:
+                        err_event = QueueErrorEvent(error=ValueError(f'Run failed: {workflow_run.error}'))
+                        yield self._error_to_stream_response(self._handle_error(err_event, self._message))
+                        break
+
+                if isinstance(event, QueueStopEvent):
+                    # Save message
+                    self._save_message()
+
+                    yield self._message_end_to_stream_response()
+                    break
+                else:
+                    self._queue_manager.publish(
+                        QueueAdvancedChatMessageEndEvent(),
+                        PublishFrom.TASK_PIPELINE
+                    )
+            elif isinstance(event, QueueAdvancedChatMessageEndEvent):
+                output_moderation_answer = self._handle_output_moderation_when_task_finished(self._task_state.answer)
+                if output_moderation_answer:
+                    self._task_state.answer = output_moderation_answer
+                    yield self._message_replace_to_stream_response(answer=output_moderation_answer)
+
+                # Save message
+                self._save_message()
+
+                yield self._message_end_to_stream_response()
+            elif isinstance(event, QueueRetrieverResourcesEvent):
+                self._handle_retriever_resources(event)
+            elif isinstance(event, QueueAnnotationReplyEvent):
+                self._handle_annotation_reply(event)
+            # elif isinstance(event, QueueMessageFileEvent):
+            #     response = self._message_file_to_stream_response(event)
+            #     if response:
+            #         yield response
+            elif isinstance(event, QueueTextChunkEvent):
+                delta_text = event.text
+                if delta_text is None:
+                    continue
+
+                if not self._is_stream_out_support(
+                        event=event
+                ):
+                    continue
+
+                # handle output moderation chunk
+                should_direct_answer = self._handle_output_moderation_chunk(delta_text)
+                if should_direct_answer:
+                    continue
+
+                self._task_state.answer += delta_text
+                yield self._message_to_stream_response(delta_text, self._message.id)
+            elif isinstance(event, QueueMessageReplaceEvent):
+                yield self._message_replace_to_stream_response(answer=event.text)
+            elif isinstance(event, QueuePingEvent):
+                yield self._ping_stream_response()
+            else:
+                continue
+
+    def _save_message(self) -> None:
+        """
+        Save message.
+        :return:
+        """
+        self._message = db.session.query(Message).filter(Message.id == self._message.id).first()
+
+        self._message.answer = self._task_state.answer
+        self._message.provider_response_latency = time.perf_counter() - self._start_at
+        self._message.message_metadata = json.dumps(jsonable_encoder(self._task_state.metadata)) \
+            if self._task_state.metadata else None
+
+        if self._task_state.metadata and self._task_state.metadata.get('usage'):
+            usage = LLMUsage(**self._task_state.metadata['usage'])
+
+            self._message.message_tokens = usage.prompt_tokens
+            self._message.message_unit_price = usage.prompt_unit_price
+            self._message.message_price_unit = usage.prompt_price_unit
+            self._message.answer_tokens = usage.completion_tokens
+            self._message.answer_unit_price = usage.completion_unit_price
+            self._message.answer_price_unit = usage.completion_price_unit
+            self._message.total_price = usage.total_price
+            self._message.currency = usage.currency
+
+        db.session.commit()
+
+        message_was_created.send(
+            self._message,
+            application_generate_entity=self._application_generate_entity,
+            conversation=self._conversation,
+            is_first_message=self._application_generate_entity.conversation_id is None,
+            extras=self._application_generate_entity.extras
+        )
+
+    def _message_end_to_stream_response(self) -> MessageEndStreamResponse:
+        """
+        Message end to stream response.
+        :return:
+        """
+        extras = {}
+        if self._task_state.metadata:
+            extras['metadata'] = self._task_state.metadata
+
+        return MessageEndStreamResponse(
+            task_id=self._application_generate_entity.task_id,
+            id=self._message.id,
+            **extras
+        )
+
+    def _get_stream_generate_routes(self) -> dict[str, StreamGenerateRoute]:
+        """
+        Get stream generate routes.
+        :return:
+        """
+        # find all answer nodes
+        graph = self._workflow.graph_dict
+        answer_node_configs = [
+            node for node in graph['nodes']
+            if node.get('data', {}).get('type') == NodeType.ANSWER.value
+        ]
+
+        # parse stream output node value selectors of answer nodes
+        stream_generate_routes = {}
+        for node_config in answer_node_configs:
+            # get generate route for stream output
+            answer_node_id = node_config['id']
+            generate_route = AnswerNode.extract_generate_route_selectors(node_config)
+            start_node_ids = self._get_answer_start_at_node_ids(graph, answer_node_id)
+            if not start_node_ids:
+                continue
+
+            for start_node_id in start_node_ids:
+                stream_generate_routes[start_node_id] = StreamGenerateRoute(
+                    answer_node_id=answer_node_id,
+                    generate_route=generate_route
+                )
+
+        return stream_generate_routes
+
+    def _get_answer_start_at_node_ids(self, graph: dict, target_node_id: str) \
+            -> list[str]:
+        """
+        Get answer start at node id.
+        :param graph: graph
+        :param target_node_id: target node ID
+        :return:
+        """
+        nodes = graph.get('nodes')
+        edges = graph.get('edges')
+
+        # fetch all ingoing edges from source node
+        ingoing_edges = []
+        for edge in edges:
+            if edge.get('target') == target_node_id:
+                ingoing_edges.append(edge)
+
+        if not ingoing_edges:
+            return []
+
+        start_node_ids = []
+        for ingoing_edge in ingoing_edges:
+            source_node_id = ingoing_edge.get('source')
+            source_node = next((node for node in nodes if node.get('id') == source_node_id), None)
+            if not source_node:
+                continue
+
+            node_type = source_node.get('data', {}).get('type')
+            if node_type in [
+                NodeType.ANSWER.value,
+                NodeType.IF_ELSE.value,
+                NodeType.QUESTION_CLASSIFIER.value
+            ]:
+                start_node_id = target_node_id
+                start_node_ids.append(start_node_id)
+            elif node_type == NodeType.START.value:
+                start_node_id = source_node_id
+                start_node_ids.append(start_node_id)
+            else:
+                sub_start_node_ids = self._get_answer_start_at_node_ids(graph, source_node_id)
+                if sub_start_node_ids:
+                    start_node_ids.extend(sub_start_node_ids)
+
+        return start_node_ids
+
+    def _generate_stream_outputs_when_node_started(self) -> Generator:
+        """
+        Generate stream outputs.
+        :return:
+        """
+        if self._task_state.current_stream_generate_state:
+            route_chunks = self._task_state.current_stream_generate_state.generate_route[
+                           self._task_state.current_stream_generate_state.current_route_position:]
+
+            for route_chunk in route_chunks:
+                if route_chunk.type == 'text':
+                    route_chunk = cast(TextGenerateRouteChunk, route_chunk)
+                    for token in route_chunk.text:
+                        # handle output moderation chunk
+                        should_direct_answer = self._handle_output_moderation_chunk(token)
+                        if should_direct_answer:
+                            continue
+
+                        self._task_state.answer += token
+                        yield self._message_to_stream_response(token, self._message.id)
+                        time.sleep(0.01)
+                else:
+                    break
+
+                self._task_state.current_stream_generate_state.current_route_position += 1
+
+            # all route chunks are generated
+            if self._task_state.current_stream_generate_state.current_route_position == len(
+                    self._task_state.current_stream_generate_state.generate_route):
+                self._task_state.current_stream_generate_state = None
+
+    def _generate_stream_outputs_when_node_finished(self) -> Optional[Generator]:
+        """
+        Generate stream outputs.
+        :return:
+        """
+        if not self._task_state.current_stream_generate_state:
+            return None
+
+        route_chunks = self._task_state.current_stream_generate_state.generate_route[
+                       self._task_state.current_stream_generate_state.current_route_position:]
+
+        for route_chunk in route_chunks:
+            if route_chunk.type == 'text':
+                route_chunk = cast(TextGenerateRouteChunk, route_chunk)
+                for token in route_chunk.text:
+                    self._task_state.answer += token
+                    yield self._message_to_stream_response(token, self._message.id)
+                    time.sleep(0.01)
+            else:
+                route_chunk = cast(VarGenerateRouteChunk, route_chunk)
+                value_selector = route_chunk.value_selector
+                if not value_selector:
+                    self._task_state.current_stream_generate_state.current_route_position += 1
+                    continue
+
+                route_chunk_node_id = value_selector[0]
+
+                if route_chunk_node_id == 'sys':
+                    # system variable
+                    value = self._workflow_system_variables.get(SystemVariable.value_of(value_selector[1]))
+                else:
+                    # check chunk node id is before current node id or equal to current node id
+                    if route_chunk_node_id not in self._task_state.ran_node_execution_infos:
+                        break
+
+                    latest_node_execution_info = self._task_state.latest_node_execution_info
+
+                    # get route chunk node execution info
+                    route_chunk_node_execution_info = self._task_state.ran_node_execution_infos[route_chunk_node_id]
+                    if (route_chunk_node_execution_info.node_type == NodeType.LLM
+                            and latest_node_execution_info.node_type == NodeType.LLM):
+                        # only LLM support chunk stream output
+                        self._task_state.current_stream_generate_state.current_route_position += 1
+                        continue
+
+                    # get route chunk node execution
+                    route_chunk_node_execution = db.session.query(WorkflowNodeExecution).filter(
+                        WorkflowNodeExecution.id == route_chunk_node_execution_info.workflow_node_execution_id).first()
+
+                    outputs = route_chunk_node_execution.outputs_dict
+
+                    # get value from outputs
+                    value = None
+                    for key in value_selector[1:]:
+                        if not value:
+                            value = outputs.get(key) if outputs else None
+                        else:
+                            value = value.get(key)
+
+                if value:
+                    text = ''
+                    if isinstance(value, str | int | float):
+                        text = str(value)
+                    elif isinstance(value, FileVar):
+                        # convert file to markdown
+                        text = value.to_markdown()
+                    elif isinstance(value, dict):
+                        # handle files
+                        file_vars = self._fetch_files_from_variable_value(value)
+                        if file_vars:
+                            file_var = file_vars[0]
+                            try:
+                                file_var_obj = FileVar(**file_var)
+
+                                # convert file to markdown
+                                text = file_var_obj.to_markdown()
+                            except Exception as e:
+                                logger.error(f'Error creating file var: {e}')
+
+                        if not text:
+                            # other types
+                            text = json.dumps(value, ensure_ascii=False)
+                    elif isinstance(value, list):
+                        # handle files
+                        file_vars = self._fetch_files_from_variable_value(value)
+                        for file_var in file_vars:
+                            try:
+                                file_var_obj = FileVar(**file_var)
+                            except Exception as e:
+                                logger.error(f'Error creating file var: {e}')
+                                continue
+
+                            # convert file to markdown
+                            text = file_var_obj.to_markdown() + ' '
+
+                        text = text.strip()
+
+                        if not text and value:
+                            # other types
+                            text = json.dumps(value, ensure_ascii=False)
+
+                    if text:
+                        self._task_state.answer += text
+                        yield self._message_to_stream_response(text, self._message.id)
+
+            self._task_state.current_stream_generate_state.current_route_position += 1
+
+        # all route chunks are generated
+        if self._task_state.current_stream_generate_state.current_route_position == len(
+                self._task_state.current_stream_generate_state.generate_route):
+            self._task_state.current_stream_generate_state = None
+
+    def _is_stream_out_support(self, event: QueueTextChunkEvent) -> bool:
+        """
+        Is stream out support
+        :param event: queue text chunk event
+        :return:
+        """
+        if not event.metadata:
+            return True
+
+        if 'node_id' not in event.metadata:
+            return True
+
+        node_type = event.metadata.get('node_type')
+        stream_output_value_selector = event.metadata.get('value_selector')
+        if not stream_output_value_selector:
+            return False
+
+        if not self._task_state.current_stream_generate_state:
+            return False
+
+        route_chunk = self._task_state.current_stream_generate_state.generate_route[
+            self._task_state.current_stream_generate_state.current_route_position]
+
+        if route_chunk.type != 'var':
+            return False
+
+        if node_type != NodeType.LLM:
+            # only LLM support chunk stream output
+            return False
+
+        route_chunk = cast(VarGenerateRouteChunk, route_chunk)
+        value_selector = route_chunk.value_selector
+
+        # check chunk node id is before current node id or equal to current node id
+        if value_selector != stream_output_value_selector:
+            return False
+
+        return True
+
+    def _handle_output_moderation_chunk(self, text: str) -> bool:
+        """
+        Handle output moderation chunk.
+        :param text: text
+        :return: True if output moderation should direct output, otherwise False
+        """
+        if self._output_moderation_handler:
+            if self._output_moderation_handler.should_direct_output():
+                # stop subscribe new token when output moderation should direct output
+                self._task_state.answer = self._output_moderation_handler.get_final_output()
+                self._queue_manager.publish(
+                    QueueTextChunkEvent(
+                        text=self._task_state.answer
+                    ), PublishFrom.TASK_PIPELINE
+                )
+
+                self._queue_manager.publish(
+                    QueueStopEvent(stopped_by=QueueStopEvent.StopBy.OUTPUT_MODERATION),
+                    PublishFrom.TASK_PIPELINE
+                )
+                return True
+            else:
+                self._output_moderation_handler.append_new_token(text)
+
+        return False

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

@@ -0,0 +1,140 @@
+from typing import Optional
+
+from core.app.apps.base_app_queue_manager import AppQueueManager, PublishFrom
+from core.app.entities.queue_entities import (
+    AppQueueEvent,
+    QueueNodeFailedEvent,
+    QueueNodeStartedEvent,
+    QueueNodeSucceededEvent,
+    QueueTextChunkEvent,
+    QueueWorkflowFailedEvent,
+    QueueWorkflowStartedEvent,
+    QueueWorkflowSucceededEvent,
+)
+from core.workflow.callbacks.base_workflow_callback import BaseWorkflowCallback
+from core.workflow.entities.base_node_data_entities import BaseNodeData
+from core.workflow.entities.node_entities import NodeType
+from models.workflow import Workflow
+
+
+class WorkflowEventTriggerCallback(BaseWorkflowCallback):
+
+    def __init__(self, queue_manager: AppQueueManager, workflow: Workflow):
+        self._queue_manager = queue_manager
+
+    def on_workflow_run_started(self) -> None:
+        """
+        Workflow run started
+        """
+        self._queue_manager.publish(
+            QueueWorkflowStartedEvent(),
+            PublishFrom.APPLICATION_MANAGER
+        )
+
+    def on_workflow_run_succeeded(self) -> None:
+        """
+        Workflow run succeeded
+        """
+        self._queue_manager.publish(
+            QueueWorkflowSucceededEvent(),
+            PublishFrom.APPLICATION_MANAGER
+        )
+
+    def on_workflow_run_failed(self, error: str) -> None:
+        """
+        Workflow run failed
+        """
+        self._queue_manager.publish(
+            QueueWorkflowFailedEvent(
+                error=error
+            ),
+            PublishFrom.APPLICATION_MANAGER
+        )
+
+    def on_workflow_node_execute_started(self, node_id: str,
+                                         node_type: NodeType,
+                                         node_data: BaseNodeData,
+                                         node_run_index: int = 1,
+                                         predecessor_node_id: Optional[str] = None) -> None:
+        """
+        Workflow node execute started
+        """
+        self._queue_manager.publish(
+            QueueNodeStartedEvent(
+                node_id=node_id,
+                node_type=node_type,
+                node_data=node_data,
+                node_run_index=node_run_index,
+                predecessor_node_id=predecessor_node_id
+            ),
+            PublishFrom.APPLICATION_MANAGER
+        )
+
+    def on_workflow_node_execute_succeeded(self, node_id: str,
+                                           node_type: NodeType,
+                                           node_data: BaseNodeData,
+                                           inputs: Optional[dict] = None,
+                                           process_data: Optional[dict] = None,
+                                           outputs: Optional[dict] = None,
+                                           execution_metadata: Optional[dict] = None) -> None:
+        """
+        Workflow node execute succeeded
+        """
+        self._queue_manager.publish(
+            QueueNodeSucceededEvent(
+                node_id=node_id,
+                node_type=node_type,
+                node_data=node_data,
+                inputs=inputs,
+                process_data=process_data,
+                outputs=outputs,
+                execution_metadata=execution_metadata
+            ),
+            PublishFrom.APPLICATION_MANAGER
+        )
+
+    def on_workflow_node_execute_failed(self, node_id: str,
+                                        node_type: NodeType,
+                                        node_data: BaseNodeData,
+                                        error: str,
+                                        inputs: Optional[dict] = None,
+                                        outputs: Optional[dict] = None,
+                                        process_data: Optional[dict] = None) -> None:
+        """
+        Workflow node execute failed
+        """
+        self._queue_manager.publish(
+            QueueNodeFailedEvent(
+                node_id=node_id,
+                node_type=node_type,
+                node_data=node_data,
+                inputs=inputs,
+                outputs=outputs,
+                process_data=process_data,
+                error=error
+            ),
+            PublishFrom.APPLICATION_MANAGER
+        )
+
+    def on_node_text_chunk(self, node_id: str, text: str, metadata: Optional[dict] = None) -> None:
+        """
+        Publish text chunk
+        """
+        self._queue_manager.publish(
+            QueueTextChunkEvent(
+                text=text,
+                metadata={
+                    "node_id": node_id,
+                    **metadata
+                }
+            ), PublishFrom.APPLICATION_MANAGER
+        )
+
+    def on_event(self, event: AppQueueEvent) -> None:
+        """
+        Publish event
+        """
+        self._queue_manager.publish(
+            event,
+            PublishFrom.APPLICATION_MANAGER
+        )

api/core/app/apps/agent_chat/app_config_manager.py

@@ -0,0 +1,236 @@
+import uuid
+from typing import Optional
+
+from core.agent.entities import AgentEntity
+from core.app.app_config.base_app_config_manager import BaseAppConfigManager
+from core.app.app_config.common.sensitive_word_avoidance.manager import SensitiveWordAvoidanceConfigManager
+from core.app.app_config.easy_ui_based_app.agent.manager import AgentConfigManager
+from core.app.app_config.easy_ui_based_app.dataset.manager import DatasetConfigManager
+from core.app.app_config.easy_ui_based_app.model_config.manager import ModelConfigManager
+from core.app.app_config.easy_ui_based_app.prompt_template.manager import PromptTemplateConfigManager
+from core.app.app_config.easy_ui_based_app.variables.manager import BasicVariablesConfigManager
+from core.app.app_config.entities import EasyUIBasedAppConfig, EasyUIBasedAppModelConfigFrom
+from core.app.app_config.features.file_upload.manager import FileUploadConfigManager
+from core.app.app_config.features.opening_statement.manager import OpeningStatementConfigManager
+from core.app.app_config.features.retrieval_resource.manager import RetrievalResourceConfigManager
+from core.app.app_config.features.speech_to_text.manager import SpeechToTextConfigManager
+from core.app.app_config.features.suggested_questions_after_answer.manager import (
+    SuggestedQuestionsAfterAnswerConfigManager,
+)
+from core.app.app_config.features.text_to_speech.manager import TextToSpeechConfigManager
+from core.entities.agent_entities import PlanningStrategy
+from models.model import App, AppMode, AppModelConfig, Conversation
+
+OLD_TOOLS = ["dataset", "google_search", "web_reader", "wikipedia", "current_datetime"]
+
+
+class AgentChatAppConfig(EasyUIBasedAppConfig):
+    """
+    Agent Chatbot App Config Entity.
+    """
+    agent: Optional[AgentEntity] = None
+
+
+class AgentChatAppConfigManager(BaseAppConfigManager):
+    @classmethod
+    def get_app_config(cls, app_model: App,
+                       app_model_config: AppModelConfig,
+                       conversation: Optional[Conversation] = None,
+                       override_config_dict: Optional[dict] = None) -> AgentChatAppConfig:
+        """
+        Convert app model config to agent chat app config
+        :param app_model: app model
+        :param app_model_config: app model config
+        :param conversation: conversation
+        :param override_config_dict: app model config dict
+        :return:
+        """
+        if override_config_dict:
+            config_from = EasyUIBasedAppModelConfigFrom.ARGS
+        elif conversation:
+            config_from = EasyUIBasedAppModelConfigFrom.CONVERSATION_SPECIFIC_CONFIG
+        else:
+            config_from = EasyUIBasedAppModelConfigFrom.APP_LATEST_CONFIG
+
+        if config_from != EasyUIBasedAppModelConfigFrom.ARGS:
+            app_model_config_dict = app_model_config.to_dict()
+            config_dict = app_model_config_dict.copy()
+        else:
+            config_dict = override_config_dict
+
+        app_mode = AppMode.value_of(app_model.mode)
+        app_config = AgentChatAppConfig(
+            tenant_id=app_model.tenant_id,
+            app_id=app_model.id,
+            app_mode=app_mode,
+            app_model_config_from=config_from,
+            app_model_config_id=app_model_config.id,
+            app_model_config_dict=config_dict,
+            model=ModelConfigManager.convert(
+                config=config_dict
+            ),
+            prompt_template=PromptTemplateConfigManager.convert(
+                config=config_dict
+            ),
+            sensitive_word_avoidance=SensitiveWordAvoidanceConfigManager.convert(
+                config=config_dict
+            ),
+            dataset=DatasetConfigManager.convert(
+                config=config_dict
+            ),
+            agent=AgentConfigManager.convert(
+                config=config_dict
+            ),
+            additional_features=cls.convert_features(config_dict, app_mode)
+        )
+
+        app_config.variables, app_config.external_data_variables = BasicVariablesConfigManager.convert(
+            config=config_dict
+        )
+
+        return app_config
+
+    @classmethod
+    def config_validate(cls, tenant_id: str, config: dict) -> dict:
+        """
+        Validate for agent chat app model config
+
+        :param tenant_id: tenant id
+        :param config: app model config args
+        """
+        app_mode = AppMode.AGENT_CHAT
+
+        related_config_keys = []
+
+        # model
+        config, current_related_config_keys = ModelConfigManager.validate_and_set_defaults(tenant_id, config)
+        related_config_keys.extend(current_related_config_keys)
+
+        # user_input_form
+        config, current_related_config_keys = BasicVariablesConfigManager.validate_and_set_defaults(tenant_id, config)
+        related_config_keys.extend(current_related_config_keys)
+
+        # file upload validation
+        config, current_related_config_keys = FileUploadConfigManager.validate_and_set_defaults(config)
+        related_config_keys.extend(current_related_config_keys)
+
+        # prompt
+        config, current_related_config_keys = PromptTemplateConfigManager.validate_and_set_defaults(app_mode, config)
+        related_config_keys.extend(current_related_config_keys)
+
+        # agent_mode
+        config, current_related_config_keys = cls.validate_agent_mode_and_set_defaults(tenant_id, config)
+        related_config_keys.extend(current_related_config_keys)
+
+        # opening_statement
+        config, current_related_config_keys = OpeningStatementConfigManager.validate_and_set_defaults(config)
+        related_config_keys.extend(current_related_config_keys)
+
+        # suggested_questions_after_answer
+        config, current_related_config_keys = SuggestedQuestionsAfterAnswerConfigManager.validate_and_set_defaults(
+            config)
+        related_config_keys.extend(current_related_config_keys)
+
+        # speech_to_text
+        config, current_related_config_keys = SpeechToTextConfigManager.validate_and_set_defaults(config)
+        related_config_keys.extend(current_related_config_keys)
+
+        # text_to_speech
+        config, current_related_config_keys = TextToSpeechConfigManager.validate_and_set_defaults(config)
+        related_config_keys.extend(current_related_config_keys)
+
+        # return retriever resource
+        config, current_related_config_keys = RetrievalResourceConfigManager.validate_and_set_defaults(config)
+        related_config_keys.extend(current_related_config_keys)
+
+        # dataset configs
+        # dataset_query_variable
+        config, current_related_config_keys = DatasetConfigManager.validate_and_set_defaults(tenant_id, app_mode,
+                                                                                             config)
+        related_config_keys.extend(current_related_config_keys)
+
+        # moderation validation
+        config, current_related_config_keys = SensitiveWordAvoidanceConfigManager.validate_and_set_defaults(tenant_id,
+                                                                                                            config)
+        related_config_keys.extend(current_related_config_keys)
+
+        related_config_keys = list(set(related_config_keys))
+
+        # Filter out extra parameters
+        filtered_config = {key: config.get(key) for key in related_config_keys}
+
+        return filtered_config
+
+    @classmethod
+    def validate_agent_mode_and_set_defaults(cls, tenant_id: str, config: dict) -> tuple[dict, list[str]]:
+        """
+        Validate agent_mode and set defaults for agent feature
+
+        :param tenant_id: tenant ID
+        :param config: app model config args
+        """
+        if not config.get("agent_mode"):
+            config["agent_mode"] = {
+                "enabled": False,
+                "tools": []
+            }
+
+        if not isinstance(config["agent_mode"], dict):
+            raise ValueError("agent_mode must be of object type")
+
+        if "enabled" not in config["agent_mode"] or not config["agent_mode"]["enabled"]:
+            config["agent_mode"]["enabled"] = False
+
+        if not isinstance(config["agent_mode"]["enabled"], bool):
+            raise ValueError("enabled in agent_mode must be of boolean type")
+
+        if not config["agent_mode"].get("strategy"):
+            config["agent_mode"]["strategy"] = PlanningStrategy.ROUTER.value
+
+        if config["agent_mode"]["strategy"] not in [member.value for member in
+                                                    list(PlanningStrategy.__members__.values())]:
+            raise ValueError("strategy in agent_mode must be in the specified strategy list")
+
+        if not config["agent_mode"].get("tools"):
+            config["agent_mode"]["tools"] = []
+
+        if not isinstance(config["agent_mode"]["tools"], list):
+            raise ValueError("tools in agent_mode must be a list of objects")
+
+        for tool in config["agent_mode"]["tools"]:
+            key = list(tool.keys())[0]
+            if key in OLD_TOOLS:
+                # old style, use tool name as key
+                tool_item = tool[key]
+
+                if "enabled" not in tool_item or not tool_item["enabled"]:
+                    tool_item["enabled"] = False
+
+                if not isinstance(tool_item["enabled"], bool):
+                    raise ValueError("enabled in agent_mode.tools must be of boolean type")
+
+                if key == "dataset":
+                    if 'id' not in tool_item:
+                        raise ValueError("id is required in dataset")
+
+                    try:
+                        uuid.UUID(tool_item["id"])
+                    except ValueError:
+                        raise ValueError("id in dataset must be of UUID type")
+
+                    if not DatasetConfigManager.is_dataset_exists(tenant_id, tool_item["id"]):
+                        raise ValueError("Dataset ID does not exist, please check your permission.")
+            else:
+                # latest style, use key-value pair
+                if "enabled" not in tool or not tool["enabled"]:
+                    tool["enabled"] = False
+                if "provider_type" not in tool:
+                    raise ValueError("provider_type is required in agent_mode.tools")
+                if "provider_id" not in tool:
+                    raise ValueError("provider_id is required in agent_mode.tools")
+                if "tool_name" not in tool:
+                    raise ValueError("tool_name is required in agent_mode.tools")
+                if "tool_parameters" not in tool:
+                    raise ValueError("tool_parameters is required in agent_mode.tools")
+
+        return config, ["agent_mode"]

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

@@ -0,0 +1,206 @@
+import logging
+import threading
+import uuid
+from collections.abc import Generator
+from typing import Any, Union
+
+from flask import Flask, current_app
+from pydantic import ValidationError
+
+from core.app.app_config.easy_ui_based_app.model_config.converter import ModelConfigConverter
+from core.app.app_config.features.file_upload.manager import FileUploadConfigManager
+from core.app.apps.agent_chat.app_config_manager import AgentChatAppConfigManager
+from core.app.apps.agent_chat.app_runner import AgentChatAppRunner
+from core.app.apps.agent_chat.generate_response_converter import AgentChatAppGenerateResponseConverter
+from core.app.apps.base_app_queue_manager import AppQueueManager, GenerateTaskStoppedException, PublishFrom
+from core.app.apps.message_based_app_generator import MessageBasedAppGenerator
+from core.app.apps.message_based_app_queue_manager import MessageBasedAppQueueManager
+from core.app.entities.app_invoke_entities import AgentChatAppGenerateEntity, InvokeFrom
+from core.file.message_file_parser import MessageFileParser
+from core.model_runtime.errors.invoke import InvokeAuthorizationError, InvokeError
+from extensions.ext_database import db
+from models.account import Account
+from models.model import App, EndUser
+
+logger = logging.getLogger(__name__)
+
+
+class AgentChatAppGenerator(MessageBasedAppGenerator):
+    def generate(self, app_model: App,
+                 user: Union[Account, EndUser],
+                 args: Any,
+                 invoke_from: InvokeFrom,
+                 stream: bool = True) \
+            -> Union[dict, Generator[dict, None, None]]:
+        """
+        Generate App response.
+
+        :param app_model: App
+        :param user: account or end user
+        :param args: request args
+        :param invoke_from: invoke from source
+        :param stream: is stream
+        """
+        if not stream:
+            raise ValueError('Agent Chat App does not support blocking mode')
+
+        if not args.get('query'):
+            raise ValueError('query is required')
+
+        query = args['query']
+        if not isinstance(query, str):
+            raise ValueError('query must be a string')
+
+        query = query.replace('\x00', '')
+        inputs = args['inputs']
+
+        extras = {
+            "auto_generate_conversation_name": args['auto_generate_name'] if 'auto_generate_name' in args else True
+        }
+
+        # get conversation
+        conversation = None
+        if args.get('conversation_id'):
+            conversation = self._get_conversation_by_user(app_model, args.get('conversation_id'), user)
+
+        # get app model config
+        app_model_config = self._get_app_model_config(
+            app_model=app_model,
+            conversation=conversation
+        )
+
+        # validate override model config
+        override_model_config_dict = None
+        if args.get('model_config'):
+            if invoke_from != InvokeFrom.DEBUGGER:
+                raise ValueError('Only in App debug mode can override model config')
+
+            # validate config
+            override_model_config_dict = AgentChatAppConfigManager.config_validate(
+                tenant_id=app_model.tenant_id,
+                config=args.get('model_config')
+            )
+
+        # parse files
+        files = args['files'] if 'files' in args and args['files'] else []
+        message_file_parser = MessageFileParser(tenant_id=app_model.tenant_id, app_id=app_model.id)
+        file_extra_config = FileUploadConfigManager.convert(override_model_config_dict or app_model_config.to_dict())
+        if file_extra_config:
+            file_objs = message_file_parser.validate_and_transform_files_arg(
+                files,
+                file_extra_config,
+                user
+            )
+        else:
+            file_objs = []
+
+        # convert to app config
+        app_config = AgentChatAppConfigManager.get_app_config(
+            app_model=app_model,
+            app_model_config=app_model_config,
+            conversation=conversation,
+            override_config_dict=override_model_config_dict
+        )
+
+        # init application generate entity
+        application_generate_entity = AgentChatAppGenerateEntity(
+            task_id=str(uuid.uuid4()),
+            app_config=app_config,
+            model_config=ModelConfigConverter.convert(app_config),
+            conversation_id=conversation.id if conversation else None,
+            inputs=conversation.inputs if conversation else self._get_cleaned_inputs(inputs, app_config),
+            query=query,
+            files=file_objs,
+            user_id=user.id,
+            stream=stream,
+            invoke_from=invoke_from,
+            extras=extras
+        )
+
+        # init generate records
+        (
+            conversation,
+            message
+        ) = self._init_generate_records(application_generate_entity, conversation)
+
+        # init queue manager
+        queue_manager = MessageBasedAppQueueManager(
+            task_id=application_generate_entity.task_id,
+            user_id=application_generate_entity.user_id,
+            invoke_from=application_generate_entity.invoke_from,
+            conversation_id=conversation.id,
+            app_mode=conversation.mode,
+            message_id=message.id
+        )
+
+        # new thread
+        worker_thread = threading.Thread(target=self._generate_worker, kwargs={
+            'flask_app': current_app._get_current_object(),
+            'application_generate_entity': application_generate_entity,
+            'queue_manager': queue_manager,
+            'conversation_id': conversation.id,
+            'message_id': message.id,
+        })
+
+        worker_thread.start()
+
+        # return response or stream generator
+        response = self._handle_response(
+            application_generate_entity=application_generate_entity,
+            queue_manager=queue_manager,
+            conversation=conversation,
+            message=message,
+            user=user,
+            stream=stream
+        )
+
+        return AgentChatAppGenerateResponseConverter.convert(
+            response=response,
+            invoke_from=invoke_from
+        )
+
+    def _generate_worker(self, flask_app: Flask,
+                         application_generate_entity: AgentChatAppGenerateEntity,
+                         queue_manager: AppQueueManager,
+                         conversation_id: str,
+                         message_id: str) -> None:
+        """
+        Generate worker in a new thread.
+        :param flask_app: Flask app
+        :param application_generate_entity: application generate entity
+        :param queue_manager: queue manager
+        :param conversation_id: conversation ID
+        :param message_id: message ID
+        :return:
+        """
+        with flask_app.app_context():
+            try:
+                # get conversation and message
+                conversation = self._get_conversation(conversation_id)
+                message = self._get_message(message_id)
+
+                # chatbot app
+                runner = AgentChatAppRunner()
+                runner.run(
+                    application_generate_entity=application_generate_entity,
+                    queue_manager=queue_manager,
+                    conversation=conversation,
+                    message=message
+                )
+            except GenerateTaskStoppedException:
+                pass
+            except InvokeAuthorizationError:
+                queue_manager.publish_error(
+                    InvokeAuthorizationError('Incorrect API key provided'),
+                    PublishFrom.APPLICATION_MANAGER
+                )
+            except ValidationError as e:
+                logger.exception("Validation Error when generating")
+                queue_manager.publish_error(e, PublishFrom.APPLICATION_MANAGER)
+            except (ValueError, InvokeError) as e:
+                queue_manager.publish_error(e, PublishFrom.APPLICATION_MANAGER)
+            except Exception as e:
+                logger.exception("Unknown Error when generating")
+                queue_manager.publish_error(e, PublishFrom.APPLICATION_MANAGER)
+            finally:
+                db.session.close()

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

@@ -0,0 +1,322 @@
+import logging
+from typing import cast
+
+from core.agent.cot_agent_runner import CotAgentRunner
+from core.agent.entities import AgentEntity
+from core.agent.fc_agent_runner import FunctionCallAgentRunner
+from core.app.apps.agent_chat.app_config_manager import AgentChatAppConfig
+from core.app.apps.base_app_queue_manager import AppQueueManager, PublishFrom
+from core.app.apps.base_app_runner import AppRunner
+from core.app.entities.app_invoke_entities import AgentChatAppGenerateEntity, ModelConfigWithCredentialsEntity
+from core.app.entities.queue_entities import QueueAnnotationReplyEvent
+from core.memory.token_buffer_memory import TokenBufferMemory
+from core.model_manager import ModelInstance
+from core.model_runtime.entities.llm_entities import LLMUsage
+from core.model_runtime.entities.model_entities import ModelFeature
+from core.model_runtime.model_providers.__base.large_language_model import LargeLanguageModel
+from core.moderation.base import ModerationException
+from core.tools.entities.tool_entities import ToolRuntimeVariablePool
+from extensions.ext_database import db
+from models.model import App, Conversation, Message, MessageAgentThought
+from models.tools import ToolConversationVariables
+
+logger = logging.getLogger(__name__)
+
+
+class AgentChatAppRunner(AppRunner):
+    """
+    Agent Application Runner
+    """
+    def run(self, application_generate_entity: AgentChatAppGenerateEntity,
+            queue_manager: AppQueueManager,
+            conversation: Conversation,
+            message: Message) -> None:
+        """
+        Run assistant application
+        :param application_generate_entity: application generate entity
+        :param queue_manager: application queue manager
+        :param conversation: conversation
+        :param message: message
+        :return:
+        """
+        app_config = application_generate_entity.app_config
+        app_config = cast(AgentChatAppConfig, app_config)
+
+        app_record = db.session.query(App).filter(App.id == app_config.app_id).first()
+        if not app_record:
+            raise ValueError("App not found")
+
+        inputs = application_generate_entity.inputs
+        query = application_generate_entity.query
+        files = application_generate_entity.files
+
+        # Pre-calculate the number of tokens of the prompt messages,
+        # and return the rest number of tokens by model context token size limit and max token size limit.
+        # If the rest number of tokens is not enough, raise exception.
+        # Include: prompt template, inputs, query(optional), files(optional)
+        # Not Include: memory, external data, dataset context
+        self.get_pre_calculate_rest_tokens(
+            app_record=app_record,
+            model_config=application_generate_entity.model_config,
+            prompt_template_entity=app_config.prompt_template,
+            inputs=inputs,
+            files=files,
+            query=query
+        )
+
+        memory = None
+        if application_generate_entity.conversation_id:
+            # get memory of conversation (read-only)
+            model_instance = ModelInstance(
+                provider_model_bundle=application_generate_entity.model_config.provider_model_bundle,
+                model=application_generate_entity.model_config.model
+            )
+
+            memory = TokenBufferMemory(
+                conversation=conversation,
+                model_instance=model_instance
+            )
+
+        # organize all inputs and template to prompt messages
+        # Include: prompt template, inputs, query(optional), files(optional)
+        #          memory(optional)
+        prompt_messages, _ = self.organize_prompt_messages(
+            app_record=app_record,
+            model_config=application_generate_entity.model_config,
+            prompt_template_entity=app_config.prompt_template,
+            inputs=inputs,
+            files=files,
+            query=query,
+            memory=memory
+        )
+
+        # moderation
+        try:
+            # process sensitive_word_avoidance
+            _, inputs, query = self.moderation_for_inputs(
+                app_id=app_record.id,
+                tenant_id=app_config.tenant_id,
+                app_generate_entity=application_generate_entity,
+                inputs=inputs,
+                query=query,
+            )
+        except ModerationException as e:
+            self.direct_output(
+                queue_manager=queue_manager,
+                app_generate_entity=application_generate_entity,
+                prompt_messages=prompt_messages,
+                text=str(e),
+                stream=application_generate_entity.stream
+            )
+            return
+
+        if query:
+            # annotation reply
+            annotation_reply = self.query_app_annotations_to_reply(
+                app_record=app_record,
+                message=message,
+                query=query,
+                user_id=application_generate_entity.user_id,
+                invoke_from=application_generate_entity.invoke_from
+            )
+
+            if annotation_reply:
+                queue_manager.publish(
+                    QueueAnnotationReplyEvent(message_annotation_id=annotation_reply.id),
+                    PublishFrom.APPLICATION_MANAGER
+                )
+
+                self.direct_output(
+                    queue_manager=queue_manager,
+                    app_generate_entity=application_generate_entity,
+                    prompt_messages=prompt_messages,
+                    text=annotation_reply.content,
+                    stream=application_generate_entity.stream
+                )
+                return
+
+        # fill in variable inputs from external data tools if exists
+        external_data_tools = app_config.external_data_variables
+        if external_data_tools:
+            inputs = self.fill_in_inputs_from_external_data_tools(
+                tenant_id=app_record.tenant_id,
+                app_id=app_record.id,
+                external_data_tools=external_data_tools,
+                inputs=inputs,
+                query=query
+            )
+
+        # reorganize all inputs and template to prompt messages
+        # Include: prompt template, inputs, query(optional), files(optional)
+        #          memory(optional), external data, dataset context(optional)
+        prompt_messages, _ = self.organize_prompt_messages(
+            app_record=app_record,
+            model_config=application_generate_entity.model_config,
+            prompt_template_entity=app_config.prompt_template,
+            inputs=inputs,
+            files=files,
+            query=query,
+            memory=memory
+        )
+
+        # check hosting moderation
+        hosting_moderation_result = self.check_hosting_moderation(
+            application_generate_entity=application_generate_entity,
+            queue_manager=queue_manager,
+            prompt_messages=prompt_messages
+        )
+
+        if hosting_moderation_result:
+            return
+
+        agent_entity = app_config.agent
+
+        # load tool variables
+        tool_conversation_variables = self._load_tool_variables(conversation_id=conversation.id,
+                                                   user_id=application_generate_entity.user_id,
+                                                   tenant_id=app_config.tenant_id)
+
+        # convert db variables to tool variables
+        tool_variables = self._convert_db_variables_to_tool_variables(tool_conversation_variables)
+
+        # init model instance
+        model_instance = ModelInstance(
+            provider_model_bundle=application_generate_entity.model_config.provider_model_bundle,
+            model=application_generate_entity.model_config.model
+        )
+        prompt_message, _ = self.organize_prompt_messages(
+            app_record=app_record,
+            model_config=application_generate_entity.model_config,
+            prompt_template_entity=app_config.prompt_template,
+            inputs=inputs,
+            files=files,
+            query=query,
+            memory=memory,
+        )
+
+        # change function call strategy based on LLM model
+        llm_model = cast(LargeLanguageModel, model_instance.model_type_instance)
+        model_schema = llm_model.get_model_schema(model_instance.model, model_instance.credentials)
+
+        if set([ModelFeature.MULTI_TOOL_CALL, ModelFeature.TOOL_CALL]).intersection(model_schema.features or []):
+            agent_entity.strategy = AgentEntity.Strategy.FUNCTION_CALLING
+
+        conversation = db.session.query(Conversation).filter(Conversation.id == conversation.id).first()
+        message = db.session.query(Message).filter(Message.id == message.id).first()
+        db.session.close()
+
+        # start agent runner
+        if agent_entity.strategy == AgentEntity.Strategy.CHAIN_OF_THOUGHT:
+            assistant_cot_runner = CotAgentRunner(
+                tenant_id=app_config.tenant_id,
+                application_generate_entity=application_generate_entity,
+                app_config=app_config,
+                model_config=application_generate_entity.model_config,
+                config=agent_entity,
+                queue_manager=queue_manager,
+                message=message,
+                user_id=application_generate_entity.user_id,
+                memory=memory,
+                prompt_messages=prompt_message,
+                variables_pool=tool_variables,
+                db_variables=tool_conversation_variables,
+                model_instance=model_instance
+            )
+            invoke_result = assistant_cot_runner.run(
+                conversation=conversation,
+                message=message,
+                query=query,
+                inputs=inputs,
+            )
+        elif agent_entity.strategy == AgentEntity.Strategy.FUNCTION_CALLING:
+            assistant_fc_runner = FunctionCallAgentRunner(
+                tenant_id=app_config.tenant_id,
+                application_generate_entity=application_generate_entity,
+                app_config=app_config,
+                model_config=application_generate_entity.model_config,
+                config=agent_entity,
+                queue_manager=queue_manager,
+                message=message,
+                user_id=application_generate_entity.user_id,
+                memory=memory,
+                prompt_messages=prompt_message,
+                variables_pool=tool_variables,
+                db_variables=tool_conversation_variables,
+                model_instance=model_instance
+            )
+            invoke_result = assistant_fc_runner.run(
+                conversation=conversation,
+                message=message,
+                query=query,
+            )
+
+        # handle invoke result
+        self._handle_invoke_result(
+            invoke_result=invoke_result,
+            queue_manager=queue_manager,
+            stream=application_generate_entity.stream,
+            agent=True
+        )
+
+    def _load_tool_variables(self, conversation_id: str, user_id: str, tenant_id: str) -> ToolConversationVariables:
+        """
+        load tool variables from database
+        """
+        tool_variables: ToolConversationVariables = db.session.query(ToolConversationVariables).filter(
+            ToolConversationVariables.conversation_id == conversation_id,
+            ToolConversationVariables.tenant_id == tenant_id
+        ).first()
+
+        if tool_variables:
+            # save tool variables to session, so that we can update it later
+            db.session.add(tool_variables)
+        else:
+            # create new tool variables
+            tool_variables = ToolConversationVariables(
+                conversation_id=conversation_id,
+                user_id=user_id,
+                tenant_id=tenant_id,
+                variables_str='[]',
+            )
+            db.session.add(tool_variables)
+            db.session.commit()
+
+        return tool_variables
+    
+    def _convert_db_variables_to_tool_variables(self, db_variables: ToolConversationVariables) -> ToolRuntimeVariablePool:
+        """
+        convert db variables to tool variables
+        """
+        return ToolRuntimeVariablePool(**{
+            'conversation_id': db_variables.conversation_id,
+            'user_id': db_variables.user_id,
+            'tenant_id': db_variables.tenant_id,
+            'pool': db_variables.variables
+        })
+
+    def _get_usage_of_all_agent_thoughts(self, model_config: ModelConfigWithCredentialsEntity,
+                                         message: Message) -> LLMUsage:
+        """
+        Get usage of all agent thoughts
+        :param model_config: model config
+        :param message: message
+        :return:
+        """
+        agent_thoughts = (db.session.query(MessageAgentThought)
+                          .filter(MessageAgentThought.message_id == message.id).all())
+
+        all_message_tokens = 0
+        all_answer_tokens = 0
+        for agent_thought in agent_thoughts:
+            all_message_tokens += agent_thought.message_tokens
+            all_answer_tokens += agent_thought.answer_tokens
+
+        model_type_instance = model_config.provider_model_bundle.model_type_instance
+        model_type_instance = cast(LargeLanguageModel, model_type_instance)
+
+        return model_type_instance._calc_response_usage(
+            model_config.model,
+            model_config.credentials,
+            all_message_tokens,
+            all_answer_tokens
+        )

api/core/app/apps/agent_chat/generate_response_converter.py

@@ -0,0 +1,117 @@
+import json
+from collections.abc import Generator
+from typing import cast
+
+from core.app.apps.base_app_generate_response_converter import AppGenerateResponseConverter
+from core.app.entities.task_entities import (
+    ChatbotAppBlockingResponse,
+    ChatbotAppStreamResponse,
+    ErrorStreamResponse,
+    MessageEndStreamResponse,
+    PingStreamResponse,
+)
+
+
+class AgentChatAppGenerateResponseConverter(AppGenerateResponseConverter):
+    _blocking_response_type = ChatbotAppBlockingResponse
+
+    @classmethod
+    def convert_blocking_full_response(cls, blocking_response: ChatbotAppBlockingResponse) -> dict:
+        """
+        Convert blocking full response.
+        :param blocking_response: blocking response
+        :return:
+        """
+        response = {
+            'event': 'message',
+            'task_id': blocking_response.task_id,
+            'id': blocking_response.data.id,
+            'message_id': blocking_response.data.message_id,
+            'conversation_id': blocking_response.data.conversation_id,
+            'mode': blocking_response.data.mode,
+            'answer': blocking_response.data.answer,
+            'metadata': blocking_response.data.metadata,
+            'created_at': blocking_response.data.created_at
+        }
+
+        return response
+
+    @classmethod
+    def convert_blocking_simple_response(cls, blocking_response: ChatbotAppBlockingResponse) -> dict:
+        """
+        Convert blocking simple response.
+        :param blocking_response: blocking response
+        :return:
+        """
+        response = cls.convert_blocking_full_response(blocking_response)
+
+        metadata = response.get('metadata', {})
+        response['metadata'] = cls._get_simple_metadata(metadata)
+
+        return response
+
+    @classmethod
+    def convert_stream_full_response(cls, stream_response: Generator[ChatbotAppStreamResponse, None, None]) \
+            -> Generator[str, None, None]:
+        """
+        Convert stream full response.
+        :param stream_response: stream response
+        :return:
+        """
+        for chunk in stream_response:
+            chunk = cast(ChatbotAppStreamResponse, chunk)
+            sub_stream_response = chunk.stream_response
+
+            if isinstance(sub_stream_response, PingStreamResponse):
+                yield 'ping'
+                continue
+
+            response_chunk = {
+                'event': sub_stream_response.event.value,
+                'conversation_id': chunk.conversation_id,
+                'message_id': chunk.message_id,
+                'created_at': chunk.created_at
+            }
+
+            if isinstance(sub_stream_response, ErrorStreamResponse):
+                data = cls._error_to_stream_response(sub_stream_response.err)
+                response_chunk.update(data)
+            else:
+                response_chunk.update(sub_stream_response.to_dict())
+            yield json.dumps(response_chunk)
+
+    @classmethod
+    def convert_stream_simple_response(cls, stream_response: Generator[ChatbotAppStreamResponse, None, None]) \
+            -> Generator[str, None, None]:
+        """
+        Convert stream simple response.
+        :param stream_response: stream response
+        :return:
+        """
+        for chunk in stream_response:
+            chunk = cast(ChatbotAppStreamResponse, chunk)
+            sub_stream_response = chunk.stream_response
+
+            if isinstance(sub_stream_response, PingStreamResponse):
+                yield 'ping'
+                continue
+
+            response_chunk = {
+                'event': sub_stream_response.event.value,
+                'conversation_id': chunk.conversation_id,
+                'message_id': chunk.message_id,
+                'created_at': chunk.created_at
+            }
+
+            if isinstance(sub_stream_response, MessageEndStreamResponse):
+                sub_stream_response_dict = sub_stream_response.to_dict()
+                metadata = sub_stream_response_dict.get('metadata', {})
+                sub_stream_response_dict['metadata'] = cls._get_simple_metadata(metadata)
+                response_chunk.update(sub_stream_response_dict)
+            if isinstance(sub_stream_response, ErrorStreamResponse):
+                data = cls._error_to_stream_response(sub_stream_response.err)
+                response_chunk.update(data)
+            else:
+                response_chunk.update(sub_stream_response.to_dict())
+
+            yield json.dumps(response_chunk)

api/core/app/apps/base_app_generate_response_converter.py

@@ -0,0 +1,129 @@
+import logging
+from abc import ABC, abstractmethod
+from collections.abc import Generator
+from typing import Union
+
+from core.app.entities.app_invoke_entities import InvokeFrom
+from core.app.entities.task_entities import AppBlockingResponse, AppStreamResponse
+from core.errors.error import ModelCurrentlyNotSupportError, ProviderTokenNotInitError, QuotaExceededError
+from core.model_runtime.errors.invoke import InvokeError
+
+
+class AppGenerateResponseConverter(ABC):
+    _blocking_response_type: type[AppBlockingResponse]
+
+    @classmethod
+    def convert(cls, response: Union[
+        AppBlockingResponse,
+        Generator[AppStreamResponse, None, None]
+    ], invoke_from: InvokeFrom) -> Union[
+        dict,
+        Generator[str, None, None]
+    ]:
+        if invoke_from in [InvokeFrom.DEBUGGER, InvokeFrom.SERVICE_API]:
+            if isinstance(response, cls._blocking_response_type):
+                return cls.convert_blocking_full_response(response)
+            else:
+                def _generate():
+                    for chunk in cls.convert_stream_full_response(response):
+                        yield f'data: {chunk}\n\n'
+
+                return _generate()
+        else:
+            if isinstance(response, cls._blocking_response_type):
+                return cls.convert_blocking_simple_response(response)
+            else:
+                def _generate():
+                    for chunk in cls.convert_stream_simple_response(response):
+                        yield f'data: {chunk}\n\n'
+
+                return _generate()
+
+    @classmethod
+    @abstractmethod
+    def convert_blocking_full_response(cls, blocking_response: AppBlockingResponse) -> dict:
+        raise NotImplementedError
+
+    @classmethod
+    @abstractmethod
+    def convert_blocking_simple_response(cls, blocking_response: AppBlockingResponse) -> dict:
+        raise NotImplementedError
+
+    @classmethod
+    @abstractmethod
+    def convert_stream_full_response(cls, stream_response: Generator[AppStreamResponse, None, None]) \
+            -> Generator[str, None, None]:
+        raise NotImplementedError
+
+    @classmethod
+    @abstractmethod
+    def convert_stream_simple_response(cls, stream_response: Generator[AppStreamResponse, None, None]) \
+            -> Generator[str, None, None]:
+        raise NotImplementedError
+
+    @classmethod
+    def _get_simple_metadata(cls, metadata: dict) -> dict:
+        """
+        Get simple metadata.
+        :param metadata: metadata
+        :return:
+        """
+        # show_retrieve_source
+        if 'retriever_resources' in metadata:
+            metadata['retriever_resources'] = []
+            for resource in metadata['retriever_resources']:
+                metadata['retriever_resources'].append({
+                    'segment_id': resource['segment_id'],
+                    'position': resource['position'],
+                    'document_name': resource['document_name'],
+                    'score': resource['score'],
+                    'content': resource['content'],
+                })
+
+        # show annotation reply
+        if 'annotation_reply' in metadata:
+            del metadata['annotation_reply']
+
+        # show usage
+        if 'usage' in metadata:
+            del metadata['usage']
+
+        return metadata
+
+    @classmethod
+    def _error_to_stream_response(cls, e: Exception) -> dict:
+        """
+        Error to stream response.
+        :param e: exception
+        :return:
+        """
+        error_responses = {
+            ValueError: {'code': 'invalid_param', 'status': 400},
+            ProviderTokenNotInitError: {'code': 'provider_not_initialize', 'status': 400},
+            QuotaExceededError: {
+                'code': 'provider_quota_exceeded',
+                'message': "Your quota for Dify Hosted Model Provider has been exhausted. "
+                           "Please go to Settings -> Model Provider to complete your own provider credentials.",
+                'status': 400
+            },
+            ModelCurrentlyNotSupportError: {'code': 'model_currently_not_support', 'status': 400},
+            InvokeError: {'code': 'completion_request_error', 'status': 400}
+        }
+
+        # Determine the response based on the type of exception
+        data = None
+        for k, v in error_responses.items():
+            if isinstance(e, k):
+                data = v
+
+        if data:
+            data.setdefault('message', getattr(e, 'description', str(e)))
+        else:
+            logging.error(e)
+            data = {
+                'code': 'internal_server_error',
+                'message': 'Internal Server Error, please contact support.',
+                'status': 500
+            }
+
+        return data

api/core/app/apps/base_app_generator.py

@@ -0,0 +1,42 @@
+from core.app.app_config.entities import AppConfig, VariableEntity
+
+
+class BaseAppGenerator:
+    def _get_cleaned_inputs(self, user_inputs: dict, app_config: AppConfig):
+        if user_inputs is None:
+            user_inputs = {}
+
+        filtered_inputs = {}
+
+        # Filter input variables from form configuration, handle required fields, default values, and option values
+        variables = app_config.variables
+        for variable_config in variables:
+            variable = variable_config.variable
+
+            if variable not in user_inputs or not user_inputs[variable]:
+                if variable_config.required:
+                    raise ValueError(f"{variable} is required in input form")
+                else:
+                    filtered_inputs[variable] = variable_config.default if variable_config.default is not None else ""
+                    continue
+
+            value = user_inputs[variable]
+
+            if value:
+                if not isinstance(value, str):
+                    raise ValueError(f"{variable} in input form must be a string")
+
+            if variable_config.type == VariableEntity.Type.SELECT:
+                options = variable_config.options if variable_config.options is not None else []
+                if value not in options:
+                    raise ValueError(f"{variable} in input form must be one of the following: {options}")
+            else:
+                if variable_config.max_length is not None:
+                    max_length = variable_config.max_length
+                    if len(value) > max_length:
+                        raise ValueError(f'{variable} in input form must be less than {max_length} characters')
+
+            filtered_inputs[variable] = value.replace('\x00', '') if value else None
+
+        return filtered_inputs
+

api/core/app/apps/base_app_queue_manager.py

@@ -0,0 +1,177 @@
+import queue
+import time
+from abc import abstractmethod
+from collections.abc import Generator
+from enum import Enum
+from typing import Any
+
+from sqlalchemy.orm import DeclarativeMeta
+
+from core.app.entities.app_invoke_entities import InvokeFrom
+from core.app.entities.queue_entities import (
+    AppQueueEvent,
+    QueueErrorEvent,
+    QueuePingEvent,
+    QueueStopEvent,
+)
+from extensions.ext_redis import redis_client
+
+
+class PublishFrom(Enum):
+    APPLICATION_MANAGER = 1
+    TASK_PIPELINE = 2
+
+
+class AppQueueManager:
+    def __init__(self, task_id: str,
+                 user_id: str,
+                 invoke_from: InvokeFrom) -> None:
+        if not user_id:
+            raise ValueError("user is required")
+
+        self._task_id = task_id
+        self._user_id = user_id
+        self._invoke_from = invoke_from
+
+        user_prefix = 'account' if self._invoke_from in [InvokeFrom.EXPLORE, InvokeFrom.DEBUGGER] else 'end-user'
+        redis_client.setex(AppQueueManager._generate_task_belong_cache_key(self._task_id), 1800,
+                           f"{user_prefix}-{self._user_id}")
+
+        q = queue.Queue()
+
+        self._q = q
+
+    def listen(self) -> Generator:
+        """
+        Listen to queue
+        :return:
+        """
+        # wait for 10 minutes to stop listen
+        listen_timeout = 600
+        start_time = time.time()
+        last_ping_time = 0
+
+        while True:
+            try:
+                message = self._q.get(timeout=1)
+                if message is None:
+                    break
+
+                yield message
+            except queue.Empty:
+                continue
+            finally:
+                elapsed_time = time.time() - start_time
+                if elapsed_time >= listen_timeout or self._is_stopped():
+                    # publish two messages to make sure the client can receive the stop signal
+                    # and stop listening after the stop signal processed
+                    self.publish(
+                        QueueStopEvent(stopped_by=QueueStopEvent.StopBy.USER_MANUAL),
+                        PublishFrom.TASK_PIPELINE
+                    )
+
+                if elapsed_time // 10 > last_ping_time:
+                    self.publish(QueuePingEvent(), PublishFrom.TASK_PIPELINE)
+                    last_ping_time = elapsed_time // 10
+
+    def stop_listen(self) -> None:
+        """
+        Stop listen to queue
+        :return:
+        """
+        self._q.put(None)
+
+    def publish_error(self, e, pub_from: PublishFrom) -> None:
+        """
+        Publish error
+        :param e: error
+        :param pub_from: publish from
+        :return:
+        """
+        self.publish(QueueErrorEvent(
+            error=e
+        ), pub_from)
+
+    def publish(self, event: AppQueueEvent, pub_from: PublishFrom) -> None:
+        """
+        Publish event to queue
+        :param event:
+        :param pub_from:
+        :return:
+        """
+        self._check_for_sqlalchemy_models(event.dict())
+        self._publish(event, pub_from)
+
+    @abstractmethod
+    def _publish(self, event: AppQueueEvent, pub_from: PublishFrom) -> None:
+        """
+        Publish event to queue
+        :param event:
+        :param pub_from:
+        :return:
+        """
+        raise NotImplementedError
+
+    @classmethod
+    def set_stop_flag(cls, task_id: str, invoke_from: InvokeFrom, user_id: str) -> None:
+        """
+        Set task stop flag
+        :return:
+        """
+        result = redis_client.get(cls._generate_task_belong_cache_key(task_id))
+        if result is None:
+            return
+
+        user_prefix = 'account' if invoke_from in [InvokeFrom.EXPLORE, InvokeFrom.DEBUGGER] else 'end-user'
+        if result.decode('utf-8') != f"{user_prefix}-{user_id}":
+            return
+
+        stopped_cache_key = cls._generate_stopped_cache_key(task_id)
+        redis_client.setex(stopped_cache_key, 600, 1)
+
+    def _is_stopped(self) -> bool:
+        """
+        Check if task is stopped
+        :return:
+        """
+        stopped_cache_key = AppQueueManager._generate_stopped_cache_key(self._task_id)
+        result = redis_client.get(stopped_cache_key)
+        if result is not None:
+            return True
+
+        return False
+
+    @classmethod
+    def _generate_task_belong_cache_key(cls, task_id: str) -> str:
+        """
+        Generate task belong cache key
+        :param task_id: task id
+        :return:
+        """
+        return f"generate_task_belong:{task_id}"
+
+    @classmethod
+    def _generate_stopped_cache_key(cls, task_id: str) -> str:
+        """
+        Generate stopped cache key
+        :param task_id: task id
+        :return:
+        """
+        return f"generate_task_stopped:{task_id}"
+
+    def _check_for_sqlalchemy_models(self, data: Any):
+        # from entity to dict or list
+        if isinstance(data, dict):
+            for key, value in data.items():
+                self._check_for_sqlalchemy_models(value)
+        elif isinstance(data, list):
+            for item in data:
+                self._check_for_sqlalchemy_models(item)
+        else:
+            if isinstance(data, DeclarativeMeta) or hasattr(data, '_sa_instance_state'):
+                raise TypeError("Critical Error: Passing SQLAlchemy Model instances "
+                                "that cause thread safety issues is not allowed.")
+
+
+class GenerateTaskStoppedException(Exception):
+    pass

api/core/app/apps/base_app_runner.py

@@ -0,0 +1,436 @@
+import time
+from collections.abc import Generator
+from typing import Optional, Union, cast
+
+from core.app.app_config.entities import ExternalDataVariableEntity, PromptTemplateEntity
+from core.app.apps.base_app_queue_manager import AppQueueManager, PublishFrom
+from core.app.entities.app_invoke_entities import (
+    AppGenerateEntity,
+    EasyUIBasedAppGenerateEntity,
+    InvokeFrom,
+    ModelConfigWithCredentialsEntity,
+)
+from core.app.entities.queue_entities import QueueAgentMessageEvent, QueueLLMChunkEvent, QueueMessageEndEvent
+from core.app.features.annotation_reply.annotation_reply import AnnotationReplyFeature
+from core.app.features.hosting_moderation.hosting_moderation import HostingModerationFeature
+from core.external_data_tool.external_data_fetch import ExternalDataFetch
+from core.file.file_obj import FileVar
+from core.memory.token_buffer_memory import TokenBufferMemory
+from core.model_runtime.entities.llm_entities import LLMResult, LLMResultChunk, LLMResultChunkDelta, LLMUsage
+from core.model_runtime.entities.message_entities import AssistantPromptMessage, PromptMessage
+from core.model_runtime.entities.model_entities import ModelPropertyKey
+from core.model_runtime.errors.invoke import InvokeBadRequestError
+from core.model_runtime.model_providers.__base.large_language_model import LargeLanguageModel
+from core.moderation.input_moderation import InputModeration
+from core.prompt.advanced_prompt_transform import AdvancedPromptTransform
+from core.prompt.entities.advanced_prompt_entities import ChatModelMessage, CompletionModelPromptTemplate, MemoryConfig
+from core.prompt.simple_prompt_transform import ModelMode, SimplePromptTransform
+from models.model import App, AppMode, Message, MessageAnnotation
+
+
+class AppRunner:
+    def get_pre_calculate_rest_tokens(self, app_record: App,
+                                      model_config: ModelConfigWithCredentialsEntity,
+                                      prompt_template_entity: PromptTemplateEntity,
+                                      inputs: dict[str, str],
+                                      files: list[FileVar],
+                                      query: Optional[str] = None) -> int:
+        """
+        Get pre calculate rest tokens
+        :param app_record: app record
+        :param model_config: model config entity
+        :param prompt_template_entity: prompt template entity
+        :param inputs: inputs
+        :param files: files
+        :param query: query
+        :return:
+        """
+        model_type_instance = model_config.provider_model_bundle.model_type_instance
+        model_type_instance = cast(LargeLanguageModel, model_type_instance)
+
+        model_context_tokens = model_config.model_schema.model_properties.get(ModelPropertyKey.CONTEXT_SIZE)
+
+        max_tokens = 0
+        for parameter_rule in model_config.model_schema.parameter_rules:
+            if (parameter_rule.name == 'max_tokens'
+                    or (parameter_rule.use_template and parameter_rule.use_template == 'max_tokens')):
+                max_tokens = (model_config.parameters.get(parameter_rule.name)
+                              or model_config.parameters.get(parameter_rule.use_template)) or 0
+
+        if model_context_tokens is None:
+            return -1
+
+        if max_tokens is None:
+            max_tokens = 0
+
+        # get prompt messages without memory and context
+        prompt_messages, stop = self.organize_prompt_messages(
+            app_record=app_record,
+            model_config=model_config,
+            prompt_template_entity=prompt_template_entity,
+            inputs=inputs,
+            files=files,
+            query=query
+        )
+
+        prompt_tokens = model_type_instance.get_num_tokens(
+            model_config.model,
+            model_config.credentials,
+            prompt_messages
+        )
+
+        rest_tokens = model_context_tokens - max_tokens - prompt_tokens
+        if rest_tokens < 0:
+            raise InvokeBadRequestError("Query or prefix prompt is too long, you can reduce the prefix prompt, "
+                                        "or shrink the max token, or switch to a llm with a larger token limit size.")
+
+        return rest_tokens
+
+    def recalc_llm_max_tokens(self, model_config: ModelConfigWithCredentialsEntity,
+                              prompt_messages: list[PromptMessage]):
+        # recalc max_tokens if sum(prompt_token +  max_tokens) over model token limit
+        model_type_instance = model_config.provider_model_bundle.model_type_instance
+        model_type_instance = cast(LargeLanguageModel, model_type_instance)
+
+        model_context_tokens = model_config.model_schema.model_properties.get(ModelPropertyKey.CONTEXT_SIZE)
+
+        max_tokens = 0
+        for parameter_rule in model_config.model_schema.parameter_rules:
+            if (parameter_rule.name == 'max_tokens'
+                    or (parameter_rule.use_template and parameter_rule.use_template == 'max_tokens')):
+                max_tokens = (model_config.parameters.get(parameter_rule.name)
+                              or model_config.parameters.get(parameter_rule.use_template)) or 0
+
+        if model_context_tokens is None:
+            return -1
+
+        if max_tokens is None:
+            max_tokens = 0
+
+        prompt_tokens = model_type_instance.get_num_tokens(
+            model_config.model,
+            model_config.credentials,
+            prompt_messages
+        )
+
+        if prompt_tokens + max_tokens > model_context_tokens:
+            max_tokens = max(model_context_tokens - prompt_tokens, 16)
+
+            for parameter_rule in model_config.model_schema.parameter_rules:
+                if (parameter_rule.name == 'max_tokens'
+                        or (parameter_rule.use_template and parameter_rule.use_template == 'max_tokens')):
+                    model_config.parameters[parameter_rule.name] = max_tokens
+
+    def organize_prompt_messages(self, app_record: App,
+                                 model_config: ModelConfigWithCredentialsEntity,
+                                 prompt_template_entity: PromptTemplateEntity,
+                                 inputs: dict[str, str],
+                                 files: list[FileVar],
+                                 query: Optional[str] = None,
+                                 context: Optional[str] = None,
+                                 memory: Optional[TokenBufferMemory] = None) \
+            -> tuple[list[PromptMessage], Optional[list[str]]]:
+        """
+        Organize prompt messages
+        :param context:
+        :param app_record: app record
+        :param model_config: model config entity
+        :param prompt_template_entity: prompt template entity
+        :param inputs: inputs
+        :param files: files
+        :param query: query
+        :param memory: memory
+        :return:
+        """
+        # get prompt without memory and context
+        if prompt_template_entity.prompt_type == PromptTemplateEntity.PromptType.SIMPLE:
+            prompt_transform = SimplePromptTransform()
+            prompt_messages, stop = prompt_transform.get_prompt(
+                app_mode=AppMode.value_of(app_record.mode),
+                prompt_template_entity=prompt_template_entity,
+                inputs=inputs,
+                query=query if query else '',
+                files=files,
+                context=context,
+                memory=memory,
+                model_config=model_config
+            )
+        else:
+            memory_config = MemoryConfig(
+                window=MemoryConfig.WindowConfig(
+                    enabled=False
+                )
+            )
+
+            model_mode = ModelMode.value_of(model_config.mode)
+            if model_mode == ModelMode.COMPLETION:
+                advanced_completion_prompt_template = prompt_template_entity.advanced_completion_prompt_template
+                prompt_template = CompletionModelPromptTemplate(
+                    text=advanced_completion_prompt_template.prompt
+                )
+
+                if advanced_completion_prompt_template.role_prefix:
+                    memory_config.role_prefix = MemoryConfig.RolePrefix(
+                        user=advanced_completion_prompt_template.role_prefix.user,
+                        assistant=advanced_completion_prompt_template.role_prefix.assistant
+                    )
+            else:
+                prompt_template = []
+                for message in prompt_template_entity.advanced_chat_prompt_template.messages:
+                    prompt_template.append(ChatModelMessage(
+                        text=message.text,
+                        role=message.role
+                    ))
+
+            prompt_transform = AdvancedPromptTransform()
+            prompt_messages = prompt_transform.get_prompt(
+                prompt_template=prompt_template,
+                inputs=inputs,
+                query=query if query else '',
+                files=files,
+                context=context,
+                memory_config=memory_config,
+                memory=memory,
+                model_config=model_config
+            )
+            stop = model_config.stop
+
+        return prompt_messages, stop
+
+    def direct_output(self, queue_manager: AppQueueManager,
+                      app_generate_entity: EasyUIBasedAppGenerateEntity,
+                      prompt_messages: list,
+                      text: str,
+                      stream: bool,
+                      usage: Optional[LLMUsage] = None) -> None:
+        """
+        Direct output
+        :param queue_manager: application queue manager
+        :param app_generate_entity: app generate entity
+        :param prompt_messages: prompt messages
+        :param text: text
+        :param stream: stream
+        :param usage: usage
+        :return:
+        """
+        if stream:
+            index = 0
+            for token in text:
+                chunk = LLMResultChunk(
+                    model=app_generate_entity.model_config.model,
+                    prompt_messages=prompt_messages,
+                    delta=LLMResultChunkDelta(
+                        index=index,
+                        message=AssistantPromptMessage(content=token)
+                    )
+                )
+
+                queue_manager.publish(
+                    QueueLLMChunkEvent(
+                        chunk=chunk
+                    ), PublishFrom.APPLICATION_MANAGER
+                )
+                index += 1
+                time.sleep(0.01)
+
+        queue_manager.publish(
+            QueueMessageEndEvent(
+                llm_result=LLMResult(
+                    model=app_generate_entity.model_config.model,
+                    prompt_messages=prompt_messages,
+                    message=AssistantPromptMessage(content=text),
+                    usage=usage if usage else LLMUsage.empty_usage()
+                ),
+            ), PublishFrom.APPLICATION_MANAGER
+        )
+
+    def _handle_invoke_result(self, invoke_result: Union[LLMResult, Generator],
+                              queue_manager: AppQueueManager,
+                              stream: bool,
+                              agent: bool = False) -> None:
+        """
+        Handle invoke result
+        :param invoke_result: invoke result
+        :param queue_manager: application queue manager
+        :param stream: stream
+        :return:
+        """
+        if not stream:
+            self._handle_invoke_result_direct(
+                invoke_result=invoke_result,
+                queue_manager=queue_manager,
+                agent=agent
+            )
+        else:
+            self._handle_invoke_result_stream(
+                invoke_result=invoke_result,
+                queue_manager=queue_manager,
+                agent=agent
+            )
+
+    def _handle_invoke_result_direct(self, invoke_result: LLMResult,
+                                     queue_manager: AppQueueManager,
+                                     agent: bool) -> None:
+        """
+        Handle invoke result direct
+        :param invoke_result: invoke result
+        :param queue_manager: application queue manager
+        :return:
+        """
+        queue_manager.publish(
+            QueueMessageEndEvent(
+                llm_result=invoke_result,
+            ), PublishFrom.APPLICATION_MANAGER
+        )
+
+    def _handle_invoke_result_stream(self, invoke_result: Generator,
+                                     queue_manager: AppQueueManager,
+                                     agent: bool) -> None:
+        """
+        Handle invoke result
+        :param invoke_result: invoke result
+        :param queue_manager: application queue manager
+        :return:
+        """
+        model = None
+        prompt_messages = []
+        text = ''
+        usage = None
+        for result in invoke_result:
+            if not agent:
+                queue_manager.publish(
+                    QueueLLMChunkEvent(
+                        chunk=result
+                    ), PublishFrom.APPLICATION_MANAGER
+                )
+            else:
+                queue_manager.publish(
+                    QueueAgentMessageEvent(
+                        chunk=result
+                    ), PublishFrom.APPLICATION_MANAGER
+                )
+
+            text += result.delta.message.content
+
+            if not model:
+                model = result.model
+
+            if not prompt_messages:
+                prompt_messages = result.prompt_messages
+
+            if not usage and result.delta.usage:
+                usage = result.delta.usage
+
+        if not usage:
+            usage = LLMUsage.empty_usage()
+
+        llm_result = LLMResult(
+            model=model,
+            prompt_messages=prompt_messages,
+            message=AssistantPromptMessage(content=text),
+            usage=usage
+        )
+
+        queue_manager.publish(
+            QueueMessageEndEvent(
+                llm_result=llm_result,
+            ), PublishFrom.APPLICATION_MANAGER
+        )
+
+    def moderation_for_inputs(self, app_id: str,
+                              tenant_id: str,
+                              app_generate_entity: AppGenerateEntity,
+                              inputs: dict,
+                              query: str) -> tuple[bool, dict, str]:
+        """
+        Process sensitive_word_avoidance.
+        :param app_id: app id
+        :param tenant_id: tenant id
+        :param app_generate_entity: app generate entity
+        :param inputs: inputs
+        :param query: query
+        :return:
+        """
+        moderation_feature = InputModeration()
+        return moderation_feature.check(
+            app_id=app_id,
+            tenant_id=tenant_id,
+            app_config=app_generate_entity.app_config,
+            inputs=inputs,
+            query=query if query else ''
+        )
+    
+    def check_hosting_moderation(self, application_generate_entity: EasyUIBasedAppGenerateEntity,
+                                 queue_manager: AppQueueManager,
+                                 prompt_messages: list[PromptMessage]) -> bool:
+        """
+        Check hosting moderation
+        :param application_generate_entity: application generate entity
+        :param queue_manager: queue manager
+        :param prompt_messages: prompt messages
+        :return:
+        """
+        hosting_moderation_feature = HostingModerationFeature()
+        moderation_result = hosting_moderation_feature.check(
+            application_generate_entity=application_generate_entity,
+            prompt_messages=prompt_messages
+        )
+
+        if moderation_result:
+            self.direct_output(
+                queue_manager=queue_manager,
+                app_generate_entity=application_generate_entity,
+                prompt_messages=prompt_messages,
+                text="I apologize for any confusion, " \
+                     "but I'm an AI assistant to be helpful, harmless, and honest.",
+                stream=application_generate_entity.stream
+            )
+
+        return moderation_result
+
+    def fill_in_inputs_from_external_data_tools(self, tenant_id: str,
+                                                app_id: str,
+                                                external_data_tools: list[ExternalDataVariableEntity],
+                                                inputs: dict,
+                                                query: str) -> dict:
+        """
+        Fill in variable inputs from external data tools if exists.
+
+        :param tenant_id: workspace id
+        :param app_id: app id
+        :param external_data_tools: external data tools configs
+        :param inputs: the inputs
+        :param query: the query
+        :return: the filled inputs
+        """
+        external_data_fetch_feature = ExternalDataFetch()
+        return external_data_fetch_feature.fetch(
+            tenant_id=tenant_id,
+            app_id=app_id,
+            external_data_tools=external_data_tools,
+            inputs=inputs,
+            query=query
+        )
+    
+    def query_app_annotations_to_reply(self, app_record: App,
+                                       message: Message,
+                                       query: str,
+                                       user_id: str,
+                                       invoke_from: InvokeFrom) -> Optional[MessageAnnotation]:
+        """
+        Query app annotations to reply
+        :param app_record: app record
+        :param message: message
+        :param query: query
+        :param user_id: user id
+        :param invoke_from: invoke from
+        :return:
+        """
+        annotation_reply_feature = AnnotationReplyFeature()
+        return annotation_reply_feature.query(
+            app_record=app_record,
+            message=message,
+            query=query,
+            user_id=user_id,
+            invoke_from=invoke_from
+        )

api/core/app/apps/chat/app_config_manager.py

@@ -0,0 +1,148 @@
+from typing import Optional
+
+from core.app.app_config.base_app_config_manager import BaseAppConfigManager
+from core.app.app_config.common.sensitive_word_avoidance.manager import SensitiveWordAvoidanceConfigManager
+from core.app.app_config.easy_ui_based_app.dataset.manager import DatasetConfigManager
+from core.app.app_config.easy_ui_based_app.model_config.manager import ModelConfigManager
+from core.app.app_config.easy_ui_based_app.prompt_template.manager import PromptTemplateConfigManager
+from core.app.app_config.easy_ui_based_app.variables.manager import BasicVariablesConfigManager
+from core.app.app_config.entities import EasyUIBasedAppConfig, EasyUIBasedAppModelConfigFrom
+from core.app.app_config.features.file_upload.manager import FileUploadConfigManager
+from core.app.app_config.features.opening_statement.manager import OpeningStatementConfigManager
+from core.app.app_config.features.retrieval_resource.manager import RetrievalResourceConfigManager
+from core.app.app_config.features.speech_to_text.manager import SpeechToTextConfigManager
+from core.app.app_config.features.suggested_questions_after_answer.manager import (
+    SuggestedQuestionsAfterAnswerConfigManager,
+)
+from core.app.app_config.features.text_to_speech.manager import TextToSpeechConfigManager
+from models.model import App, AppMode, AppModelConfig, Conversation
+
+
+class ChatAppConfig(EasyUIBasedAppConfig):
+    """
+    Chatbot App Config Entity.
+    """
+    pass
+
+
+class ChatAppConfigManager(BaseAppConfigManager):
+    @classmethod
+    def get_app_config(cls, app_model: App,
+                       app_model_config: AppModelConfig,
+                       conversation: Optional[Conversation] = None,
+                       override_config_dict: Optional[dict] = None) -> ChatAppConfig:
+        """
+        Convert app model config to chat app config
+        :param app_model: app model
+        :param app_model_config: app model config
+        :param conversation: conversation
+        :param override_config_dict: app model config dict
+        :return:
+        """
+        if override_config_dict:
+            config_from = EasyUIBasedAppModelConfigFrom.ARGS
+        elif conversation:
+            config_from = EasyUIBasedAppModelConfigFrom.CONVERSATION_SPECIFIC_CONFIG
+        else:
+            config_from = EasyUIBasedAppModelConfigFrom.APP_LATEST_CONFIG
+
+        if config_from != EasyUIBasedAppModelConfigFrom.ARGS:
+            app_model_config_dict = app_model_config.to_dict()
+            config_dict = app_model_config_dict.copy()
+        else:
+            config_dict = override_config_dict
+
+        app_mode = AppMode.value_of(app_model.mode)
+        app_config = ChatAppConfig(
+            tenant_id=app_model.tenant_id,
+            app_id=app_model.id,
+            app_mode=app_mode,
+            app_model_config_from=config_from,
+            app_model_config_id=app_model_config.id,
+            app_model_config_dict=config_dict,
+            model=ModelConfigManager.convert(
+                config=config_dict
+            ),
+            prompt_template=PromptTemplateConfigManager.convert(
+                config=config_dict
+            ),
+            sensitive_word_avoidance=SensitiveWordAvoidanceConfigManager.convert(
+                config=config_dict
+            ),
+            dataset=DatasetConfigManager.convert(
+                config=config_dict
+            ),
+            additional_features=cls.convert_features(config_dict, app_mode)
+        )
+
+        app_config.variables, app_config.external_data_variables = BasicVariablesConfigManager.convert(
+            config=config_dict
+        )
+
+        return app_config
+
+    @classmethod
+    def config_validate(cls, tenant_id: str, config: dict) -> dict:
+        """
+        Validate for chat app model config
+
+        :param tenant_id: tenant id
+        :param config: app model config args
+        """
+        app_mode = AppMode.CHAT
+
+        related_config_keys = []
+
+        # model
+        config, current_related_config_keys = ModelConfigManager.validate_and_set_defaults(tenant_id, config)
+        related_config_keys.extend(current_related_config_keys)
+
+        # user_input_form
+        config, current_related_config_keys = BasicVariablesConfigManager.validate_and_set_defaults(tenant_id, config)
+        related_config_keys.extend(current_related_config_keys)
+
+        # file upload validation
+        config, current_related_config_keys = FileUploadConfigManager.validate_and_set_defaults(config)
+        related_config_keys.extend(current_related_config_keys)
+
+        # prompt
+        config, current_related_config_keys = PromptTemplateConfigManager.validate_and_set_defaults(app_mode, config)
+        related_config_keys.extend(current_related_config_keys)
+
+        # dataset_query_variable
+        config, current_related_config_keys = DatasetConfigManager.validate_and_set_defaults(tenant_id, app_mode,
+                                                                                             config)
+        related_config_keys.extend(current_related_config_keys)
+
+        # opening_statement
+        config, current_related_config_keys = OpeningStatementConfigManager.validate_and_set_defaults(config)
+        related_config_keys.extend(current_related_config_keys)
+
+        # suggested_questions_after_answer
+        config, current_related_config_keys = SuggestedQuestionsAfterAnswerConfigManager.validate_and_set_defaults(
+            config)
+        related_config_keys.extend(current_related_config_keys)
+
+        # speech_to_text
+        config, current_related_config_keys = SpeechToTextConfigManager.validate_and_set_defaults(config)
+        related_config_keys.extend(current_related_config_keys)
+
+        # text_to_speech
+        config, current_related_config_keys = TextToSpeechConfigManager.validate_and_set_defaults(config)
+        related_config_keys.extend(current_related_config_keys)
+
+        # return retriever resource
+        config, current_related_config_keys = RetrievalResourceConfigManager.validate_and_set_defaults(config)
+        related_config_keys.extend(current_related_config_keys)
+
+        # moderation validation
+        config, current_related_config_keys = SensitiveWordAvoidanceConfigManager.validate_and_set_defaults(tenant_id,
+                                                                                                            config)
+        related_config_keys.extend(current_related_config_keys)
+
+        related_config_keys = list(set(related_config_keys))
+
+        # Filter out extra parameters
+        filtered_config = {key: config.get(key) for key in related_config_keys}
+
+        return filtered_config

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

@@ -0,0 +1,203 @@
+import logging
+import threading
+import uuid
+from collections.abc import Generator
+from typing import Any, Union
+
+from flask import Flask, current_app
+from pydantic import ValidationError
+
+from core.app.app_config.easy_ui_based_app.model_config.converter import ModelConfigConverter
+from core.app.app_config.features.file_upload.manager import FileUploadConfigManager
+from core.app.apps.base_app_queue_manager import AppQueueManager, GenerateTaskStoppedException, PublishFrom
+from core.app.apps.chat.app_config_manager import ChatAppConfigManager
+from core.app.apps.chat.app_runner import ChatAppRunner
+from core.app.apps.chat.generate_response_converter import ChatAppGenerateResponseConverter
+from core.app.apps.message_based_app_generator import MessageBasedAppGenerator
+from core.app.apps.message_based_app_queue_manager import MessageBasedAppQueueManager
+from core.app.entities.app_invoke_entities import ChatAppGenerateEntity, InvokeFrom
+from core.file.message_file_parser import MessageFileParser
+from core.model_runtime.errors.invoke import InvokeAuthorizationError, InvokeError
+from extensions.ext_database import db
+from models.account import Account
+from models.model import App, EndUser
+
+logger = logging.getLogger(__name__)
+
+
+class ChatAppGenerator(MessageBasedAppGenerator):
+    def generate(self, app_model: App,
+                 user: Union[Account, EndUser],
+                 args: Any,
+                 invoke_from: InvokeFrom,
+                 stream: bool = True) \
+            -> Union[dict, Generator[dict, None, None]]:
+        """
+        Generate App response.
+
+        :param app_model: App
+        :param user: account or end user
+        :param args: request args
+        :param invoke_from: invoke from source
+        :param stream: is stream
+        """
+        if not args.get('query'):
+            raise ValueError('query is required')
+
+        query = args['query']
+        if not isinstance(query, str):
+            raise ValueError('query must be a string')
+
+        query = query.replace('\x00', '')
+        inputs = args['inputs']
+
+        extras = {
+            "auto_generate_conversation_name": args['auto_generate_name'] if 'auto_generate_name' in args else True
+        }
+
+        # get conversation
+        conversation = None
+        if args.get('conversation_id'):
+            conversation = self._get_conversation_by_user(app_model, args.get('conversation_id'), user)
+
+        # get app model config
+        app_model_config = self._get_app_model_config(
+            app_model=app_model,
+            conversation=conversation
+        )
+
+        # validate override model config
+        override_model_config_dict = None
+        if args.get('model_config'):
+            if invoke_from != InvokeFrom.DEBUGGER:
+                raise ValueError('Only in App debug mode can override model config')
+
+            # validate config
+            override_model_config_dict = ChatAppConfigManager.config_validate(
+                tenant_id=app_model.tenant_id,
+                config=args.get('model_config')
+            )
+
+        # parse files
+        files = args['files'] if 'files' in args and args['files'] else []
+        message_file_parser = MessageFileParser(tenant_id=app_model.tenant_id, app_id=app_model.id)
+        file_extra_config = FileUploadConfigManager.convert(override_model_config_dict or app_model_config.to_dict())
+        if file_extra_config:
+            file_objs = message_file_parser.validate_and_transform_files_arg(
+                files,
+                file_extra_config,
+                user
+            )
+        else:
+            file_objs = []
+
+        # convert to app config
+        app_config = ChatAppConfigManager.get_app_config(
+            app_model=app_model,
+            app_model_config=app_model_config,
+            conversation=conversation,
+            override_config_dict=override_model_config_dict
+        )
+
+        # init application generate entity
+        application_generate_entity = ChatAppGenerateEntity(
+            task_id=str(uuid.uuid4()),
+            app_config=app_config,
+            model_config=ModelConfigConverter.convert(app_config),
+            conversation_id=conversation.id if conversation else None,
+            inputs=conversation.inputs if conversation else self._get_cleaned_inputs(inputs, app_config),
+            query=query,
+            files=file_objs,
+            user_id=user.id,
+            stream=stream,
+            invoke_from=invoke_from,
+            extras=extras
+        )
+
+        # init generate records
+        (
+            conversation,
+            message
+        ) = self._init_generate_records(application_generate_entity, conversation)
+
+        # init queue manager
+        queue_manager = MessageBasedAppQueueManager(
+            task_id=application_generate_entity.task_id,
+            user_id=application_generate_entity.user_id,
+            invoke_from=application_generate_entity.invoke_from,
+            conversation_id=conversation.id,
+            app_mode=conversation.mode,
+            message_id=message.id
+        )
+
+        # new thread
+        worker_thread = threading.Thread(target=self._generate_worker, kwargs={
+            'flask_app': current_app._get_current_object(),
+            'application_generate_entity': application_generate_entity,
+            'queue_manager': queue_manager,
+            'conversation_id': conversation.id,
+            'message_id': message.id,
+        })
+
+        worker_thread.start()
+
+        # return response or stream generator
+        response = self._handle_response(
+            application_generate_entity=application_generate_entity,
+            queue_manager=queue_manager,
+            conversation=conversation,
+            message=message,
+            user=user,
+            stream=stream
+        )
+
+        return ChatAppGenerateResponseConverter.convert(
+            response=response,
+            invoke_from=invoke_from
+        )
+
+    def _generate_worker(self, flask_app: Flask,
+                         application_generate_entity: ChatAppGenerateEntity,
+                         queue_manager: AppQueueManager,
+                         conversation_id: str,
+                         message_id: str) -> None:
+        """
+        Generate worker in a new thread.
+        :param flask_app: Flask app
+        :param application_generate_entity: application generate entity
+        :param queue_manager: queue manager
+        :param conversation_id: conversation ID
+        :param message_id: message ID
+        :return:
+        """
+        with flask_app.app_context():
+            try:
+                # get conversation and message
+                conversation = self._get_conversation(conversation_id)
+                message = self._get_message(message_id)
+
+                # chatbot app
+                runner = ChatAppRunner()
+                runner.run(
+                    application_generate_entity=application_generate_entity,
+                    queue_manager=queue_manager,
+                    conversation=conversation,
+                    message=message
+                )
+            except GenerateTaskStoppedException:
+                pass
+            except InvokeAuthorizationError:
+                queue_manager.publish_error(
+                    InvokeAuthorizationError('Incorrect API key provided'),
+                    PublishFrom.APPLICATION_MANAGER
+                )
+            except ValidationError as e:
+                logger.exception("Validation Error when generating")
+                queue_manager.publish_error(e, PublishFrom.APPLICATION_MANAGER)
+            except (ValueError, InvokeError) as e:
+                queue_manager.publish_error(e, PublishFrom.APPLICATION_MANAGER)
+            except Exception as e:
+                logger.exception("Unknown Error when generating")
+                queue_manager.publish_error(e, PublishFrom.APPLICATION_MANAGER)
+            finally:
+                db.session.close()

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

@@ -0,0 +1,220 @@
+import logging
+from typing import cast
+
+from core.app.apps.base_app_queue_manager import AppQueueManager, PublishFrom
+from core.app.apps.base_app_runner import AppRunner
+from core.app.apps.chat.app_config_manager import ChatAppConfig
+from core.app.entities.app_invoke_entities import (
+    ChatAppGenerateEntity,
+)
+from core.app.entities.queue_entities import QueueAnnotationReplyEvent
+from core.callback_handler.index_tool_callback_handler import DatasetIndexToolCallbackHandler
+from core.memory.token_buffer_memory import TokenBufferMemory
+from core.model_manager import ModelInstance
+from core.moderation.base import ModerationException
+from core.rag.retrieval.dataset_retrieval import DatasetRetrieval
+from extensions.ext_database import db
+from models.model import App, Conversation, Message
+
+logger = logging.getLogger(__name__)
+
+
+class ChatAppRunner(AppRunner):
+    """
+    Chat Application Runner
+    """
+
+    def run(self, application_generate_entity: ChatAppGenerateEntity,
+            queue_manager: AppQueueManager,
+            conversation: Conversation,
+            message: Message) -> None:
+        """
+        Run application
+        :param application_generate_entity: application generate entity
+        :param queue_manager: application queue manager
+        :param conversation: conversation
+        :param message: message
+        :return:
+        """
+        app_config = application_generate_entity.app_config
+        app_config = cast(ChatAppConfig, app_config)
+
+        app_record = db.session.query(App).filter(App.id == app_config.app_id).first()
+        if not app_record:
+            raise ValueError("App not found")
+
+        inputs = application_generate_entity.inputs
+        query = application_generate_entity.query
+        files = application_generate_entity.files
+
+        # Pre-calculate the number of tokens of the prompt messages,
+        # and return the rest number of tokens by model context token size limit and max token size limit.
+        # If the rest number of tokens is not enough, raise exception.
+        # Include: prompt template, inputs, query(optional), files(optional)
+        # Not Include: memory, external data, dataset context
+        self.get_pre_calculate_rest_tokens(
+            app_record=app_record,
+            model_config=application_generate_entity.model_config,
+            prompt_template_entity=app_config.prompt_template,
+            inputs=inputs,
+            files=files,
+            query=query
+        )
+
+        memory = None
+        if application_generate_entity.conversation_id:
+            # get memory of conversation (read-only)
+            model_instance = ModelInstance(
+                provider_model_bundle=application_generate_entity.model_config.provider_model_bundle,
+                model=application_generate_entity.model_config.model
+            )
+
+            memory = TokenBufferMemory(
+                conversation=conversation,
+                model_instance=model_instance
+            )
+
+        # organize all inputs and template to prompt messages
+        # Include: prompt template, inputs, query(optional), files(optional)
+        #          memory(optional)
+        prompt_messages, stop = self.organize_prompt_messages(
+            app_record=app_record,
+            model_config=application_generate_entity.model_config,
+            prompt_template_entity=app_config.prompt_template,
+            inputs=inputs,
+            files=files,
+            query=query,
+            memory=memory
+        )
+
+        # moderation
+        try:
+            # process sensitive_word_avoidance
+            _, inputs, query = self.moderation_for_inputs(
+                app_id=app_record.id,
+                tenant_id=app_config.tenant_id,
+                app_generate_entity=application_generate_entity,
+                inputs=inputs,
+                query=query,
+            )
+        except ModerationException as e:
+            self.direct_output(
+                queue_manager=queue_manager,
+                app_generate_entity=application_generate_entity,
+                prompt_messages=prompt_messages,
+                text=str(e),
+                stream=application_generate_entity.stream
+            )
+            return
+
+        if query:
+            # annotation reply
+            annotation_reply = self.query_app_annotations_to_reply(
+                app_record=app_record,
+                message=message,
+                query=query,
+                user_id=application_generate_entity.user_id,
+                invoke_from=application_generate_entity.invoke_from
+            )
+
+            if annotation_reply:
+                queue_manager.publish(
+                    QueueAnnotationReplyEvent(message_annotation_id=annotation_reply.id),
+                    PublishFrom.APPLICATION_MANAGER
+                )
+
+                self.direct_output(
+                    queue_manager=queue_manager,
+                    app_generate_entity=application_generate_entity,
+                    prompt_messages=prompt_messages,
+                    text=annotation_reply.content,
+                    stream=application_generate_entity.stream
+                )
+                return
+
+        # fill in variable inputs from external data tools if exists
+        external_data_tools = app_config.external_data_variables
+        if external_data_tools:
+            inputs = self.fill_in_inputs_from_external_data_tools(
+                tenant_id=app_record.tenant_id,
+                app_id=app_record.id,
+                external_data_tools=external_data_tools,
+                inputs=inputs,
+                query=query
+            )
+
+        # get context from datasets
+        context = None
+        if app_config.dataset and app_config.dataset.dataset_ids:
+            hit_callback = DatasetIndexToolCallbackHandler(
+                queue_manager,
+                app_record.id,
+                message.id,
+                application_generate_entity.user_id,
+                application_generate_entity.invoke_from
+            )
+
+            dataset_retrieval = DatasetRetrieval()
+            context = dataset_retrieval.retrieve(
+                tenant_id=app_record.tenant_id,
+                model_config=application_generate_entity.model_config,
+                config=app_config.dataset,
+                query=query,
+                invoke_from=application_generate_entity.invoke_from,
+                show_retrieve_source=app_config.additional_features.show_retrieve_source,
+                hit_callback=hit_callback,
+                memory=memory
+            )
+
+        # reorganize all inputs and template to prompt messages
+        # Include: prompt template, inputs, query(optional), files(optional)
+        #          memory(optional), external data, dataset context(optional)
+        prompt_messages, stop = self.organize_prompt_messages(
+            app_record=app_record,
+            model_config=application_generate_entity.model_config,
+            prompt_template_entity=app_config.prompt_template,
+            inputs=inputs,
+            files=files,
+            query=query,
+            context=context,
+            memory=memory
+        )
+
+        # check hosting moderation
+        hosting_moderation_result = self.check_hosting_moderation(
+            application_generate_entity=application_generate_entity,
+            queue_manager=queue_manager,
+            prompt_messages=prompt_messages
+        )
+
+        if hosting_moderation_result:
+            return
+
+        # Re-calculate the max tokens if sum(prompt_token +  max_tokens) over model token limit
+        self.recalc_llm_max_tokens(
+            model_config=application_generate_entity.model_config,
+            prompt_messages=prompt_messages
+        )
+
+        # Invoke model
+        model_instance = ModelInstance(
+            provider_model_bundle=application_generate_entity.model_config.provider_model_bundle,
+            model=application_generate_entity.model_config.model
+        )
+
+        db.session.close()
+
+        invoke_result = model_instance.invoke_llm(
+            prompt_messages=prompt_messages,
+            model_parameters=application_generate_entity.model_config.parameters,
+            stop=stop,
+            stream=application_generate_entity.stream,
+            user=application_generate_entity.user_id,
+        )
+
+        # handle invoke result
+        self._handle_invoke_result(
+            invoke_result=invoke_result,
+            queue_manager=queue_manager,
+            stream=application_generate_entity.stream
+        )

api/core/app/apps/chat/generate_response_converter.py

@@ -0,0 +1,117 @@
+import json
+from collections.abc import Generator
+from typing import cast
+
+from core.app.apps.base_app_generate_response_converter import AppGenerateResponseConverter
+from core.app.entities.task_entities import (
+    ChatbotAppBlockingResponse,
+    ChatbotAppStreamResponse,
+    ErrorStreamResponse,
+    MessageEndStreamResponse,
+    PingStreamResponse,
+)
+
+
+class ChatAppGenerateResponseConverter(AppGenerateResponseConverter):
+    _blocking_response_type = ChatbotAppBlockingResponse
+
+    @classmethod
+    def convert_blocking_full_response(cls, blocking_response: ChatbotAppBlockingResponse) -> dict:
+        """
+        Convert blocking full response.
+        :param blocking_response: blocking response
+        :return:
+        """
+        response = {
+            'event': 'message',
+            'task_id': blocking_response.task_id,
+            'id': blocking_response.data.id,
+            'message_id': blocking_response.data.message_id,
+            'conversation_id': blocking_response.data.conversation_id,
+            'mode': blocking_response.data.mode,
+            'answer': blocking_response.data.answer,
+            'metadata': blocking_response.data.metadata,
+            'created_at': blocking_response.data.created_at
+        }
+
+        return response
+
+    @classmethod
+    def convert_blocking_simple_response(cls, blocking_response: ChatbotAppBlockingResponse) -> dict:
+        """
+        Convert blocking simple response.
+        :param blocking_response: blocking response
+        :return:
+        """
+        response = cls.convert_blocking_full_response(blocking_response)
+
+        metadata = response.get('metadata', {})
+        response['metadata'] = cls._get_simple_metadata(metadata)
+
+        return response
+
+    @classmethod
+    def convert_stream_full_response(cls, stream_response: Generator[ChatbotAppStreamResponse, None, None]) \
+            -> Generator[str, None, None]:
+        """
+        Convert stream full response.
+        :param stream_response: stream response
+        :return:
+        """
+        for chunk in stream_response:
+            chunk = cast(ChatbotAppStreamResponse, chunk)
+            sub_stream_response = chunk.stream_response
+
+            if isinstance(sub_stream_response, PingStreamResponse):
+                yield 'ping'
+                continue
+
+            response_chunk = {
+                'event': sub_stream_response.event.value,
+                'conversation_id': chunk.conversation_id,
+                'message_id': chunk.message_id,
+                'created_at': chunk.created_at
+            }
+
+            if isinstance(sub_stream_response, ErrorStreamResponse):
+                data = cls._error_to_stream_response(sub_stream_response.err)
+                response_chunk.update(data)
+            else:
+                response_chunk.update(sub_stream_response.to_dict())
+            yield json.dumps(response_chunk)
+
+    @classmethod
+    def convert_stream_simple_response(cls, stream_response: Generator[ChatbotAppStreamResponse, None, None]) \
+            -> Generator[str, None, None]:
+        """
+        Convert stream simple response.
+        :param stream_response: stream response
+        :return:
+        """
+        for chunk in stream_response:
+            chunk = cast(ChatbotAppStreamResponse, chunk)
+            sub_stream_response = chunk.stream_response
+
+            if isinstance(sub_stream_response, PingStreamResponse):
+                yield 'ping'
+                continue
+
+            response_chunk = {
+                'event': sub_stream_response.event.value,
+                'conversation_id': chunk.conversation_id,
+                'message_id': chunk.message_id,
+                'created_at': chunk.created_at
+            }
+
+            if isinstance(sub_stream_response, MessageEndStreamResponse):
+                sub_stream_response_dict = sub_stream_response.to_dict()
+                metadata = sub_stream_response_dict.get('metadata', {})
+                sub_stream_response_dict['metadata'] = cls._get_simple_metadata(metadata)
+                response_chunk.update(sub_stream_response_dict)
+            if isinstance(sub_stream_response, ErrorStreamResponse):
+                data = cls._error_to_stream_response(sub_stream_response.err)
+                response_chunk.update(data)
+            else:
+                response_chunk.update(sub_stream_response.to_dict())
+
+            yield json.dumps(response_chunk)

api/core/app/apps/completion/app_config_manager.py

@@ -0,0 +1,126 @@
+from typing import Optional
+
+from core.app.app_config.base_app_config_manager import BaseAppConfigManager
+from core.app.app_config.common.sensitive_word_avoidance.manager import SensitiveWordAvoidanceConfigManager
+from core.app.app_config.easy_ui_based_app.dataset.manager import DatasetConfigManager
+from core.app.app_config.easy_ui_based_app.model_config.manager import ModelConfigManager
+from core.app.app_config.easy_ui_based_app.prompt_template.manager import PromptTemplateConfigManager
+from core.app.app_config.easy_ui_based_app.variables.manager import BasicVariablesConfigManager
+from core.app.app_config.entities import EasyUIBasedAppConfig, EasyUIBasedAppModelConfigFrom
+from core.app.app_config.features.file_upload.manager import FileUploadConfigManager
+from core.app.app_config.features.more_like_this.manager import MoreLikeThisConfigManager
+from core.app.app_config.features.text_to_speech.manager import TextToSpeechConfigManager
+from models.model import App, AppMode, AppModelConfig
+
+
+class CompletionAppConfig(EasyUIBasedAppConfig):
+    """
+    Completion App Config Entity.
+    """
+    pass
+
+
+class CompletionAppConfigManager(BaseAppConfigManager):
+    @classmethod
+    def get_app_config(cls, app_model: App,
+                       app_model_config: AppModelConfig,
+                       override_config_dict: Optional[dict] = None) -> CompletionAppConfig:
+        """
+        Convert app model config to completion app config
+        :param app_model: app model
+        :param app_model_config: app model config
+        :param override_config_dict: app model config dict
+        :return:
+        """
+        if override_config_dict:
+            config_from = EasyUIBasedAppModelConfigFrom.ARGS
+        else:
+            config_from = EasyUIBasedAppModelConfigFrom.APP_LATEST_CONFIG
+
+        if config_from != EasyUIBasedAppModelConfigFrom.ARGS:
+            app_model_config_dict = app_model_config.to_dict()
+            config_dict = app_model_config_dict.copy()
+        else:
+            config_dict = override_config_dict
+
+        app_mode = AppMode.value_of(app_model.mode)
+        app_config = CompletionAppConfig(
+            tenant_id=app_model.tenant_id,
+            app_id=app_model.id,
+            app_mode=app_mode,
+            app_model_config_from=config_from,
+            app_model_config_id=app_model_config.id,
+            app_model_config_dict=config_dict,
+            model=ModelConfigManager.convert(
+                config=config_dict
+            ),
+            prompt_template=PromptTemplateConfigManager.convert(
+                config=config_dict
+            ),
+            sensitive_word_avoidance=SensitiveWordAvoidanceConfigManager.convert(
+                config=config_dict
+            ),
+            dataset=DatasetConfigManager.convert(
+                config=config_dict
+            ),
+            additional_features=cls.convert_features(config_dict, app_mode)
+        )
+
+        app_config.variables, app_config.external_data_variables = BasicVariablesConfigManager.convert(
+            config=config_dict
+        )
+
+        return app_config
+
+    @classmethod
+    def config_validate(cls, tenant_id: str, config: dict) -> dict:
+        """
+        Validate for completion app model config
+
+        :param tenant_id: tenant id
+        :param config: app model config args
+        """
+        app_mode = AppMode.COMPLETION
+
+        related_config_keys = []
+
+        # model
+        config, current_related_config_keys = ModelConfigManager.validate_and_set_defaults(tenant_id, config)
+        related_config_keys.extend(current_related_config_keys)
+
+        # user_input_form
+        config, current_related_config_keys = BasicVariablesConfigManager.validate_and_set_defaults(tenant_id, config)
+        related_config_keys.extend(current_related_config_keys)
+
+        # file upload validation
+        config, current_related_config_keys = FileUploadConfigManager.validate_and_set_defaults(config)
+        related_config_keys.extend(current_related_config_keys)
+
+        # prompt
+        config, current_related_config_keys = PromptTemplateConfigManager.validate_and_set_defaults(app_mode, config)
+        related_config_keys.extend(current_related_config_keys)
+
+        # dataset_query_variable
+        config, current_related_config_keys = DatasetConfigManager.validate_and_set_defaults(tenant_id, app_mode,
+                                                                                             config)
+        related_config_keys.extend(current_related_config_keys)
+
+        # text_to_speech
+        config, current_related_config_keys = TextToSpeechConfigManager.validate_and_set_defaults(config)
+        related_config_keys.extend(current_related_config_keys)
+
+        # more_like_this
+        config, current_related_config_keys = MoreLikeThisConfigManager.validate_and_set_defaults(config)
+        related_config_keys.extend(current_related_config_keys)
+
+        # moderation validation
+        config, current_related_config_keys = SensitiveWordAvoidanceConfigManager.validate_and_set_defaults(tenant_id,
+                                                                                                            config)
+        related_config_keys.extend(current_related_config_keys)
+
+        related_config_keys = list(set(related_config_keys))
+
+        # Filter out extra parameters
+        filtered_config = {key: config.get(key) for key in related_config_keys}
+
+        return filtered_config

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

@@ -0,0 +1,306 @@
+import logging
+import threading
+import uuid
+from collections.abc import Generator
+from typing import Any, Union
+
+from flask import Flask, current_app
+from pydantic import ValidationError
+
+from core.app.app_config.easy_ui_based_app.model_config.converter import ModelConfigConverter
+from core.app.app_config.features.file_upload.manager import FileUploadConfigManager
+from core.app.apps.base_app_queue_manager import AppQueueManager, GenerateTaskStoppedException, PublishFrom
+from core.app.apps.completion.app_config_manager import CompletionAppConfigManager
+from core.app.apps.completion.app_runner import CompletionAppRunner
+from core.app.apps.completion.generate_response_converter import CompletionAppGenerateResponseConverter
+from core.app.apps.message_based_app_generator import MessageBasedAppGenerator
+from core.app.apps.message_based_app_queue_manager import MessageBasedAppQueueManager
+from core.app.entities.app_invoke_entities import CompletionAppGenerateEntity, InvokeFrom
+from core.file.message_file_parser import MessageFileParser
+from core.model_runtime.errors.invoke import InvokeAuthorizationError, InvokeError
+from extensions.ext_database import db
+from models.account import Account
+from models.model import App, EndUser, Message
+from services.errors.app import MoreLikeThisDisabledError
+from services.errors.message import MessageNotExistsError
+
+logger = logging.getLogger(__name__)
+
+
+class CompletionAppGenerator(MessageBasedAppGenerator):
+    def generate(self, app_model: App,
+                 user: Union[Account, EndUser],
+                 args: Any,
+                 invoke_from: InvokeFrom,
+                 stream: bool = True) \
+            -> Union[dict, Generator[dict, None, None]]:
+        """
+        Generate App response.
+
+        :param app_model: App
+        :param user: account or end user
+        :param args: request args
+        :param invoke_from: invoke from source
+        :param stream: is stream
+        """
+        query = args['query']
+        if not isinstance(query, str):
+            raise ValueError('query must be a string')
+
+        query = query.replace('\x00', '')
+        inputs = args['inputs']
+
+        extras = {}
+
+        # get conversation
+        conversation = None
+
+        # get app model config
+        app_model_config = self._get_app_model_config(
+            app_model=app_model,
+            conversation=conversation
+        )
+
+        # validate override model config
+        override_model_config_dict = None
+        if args.get('model_config'):
+            if invoke_from != InvokeFrom.DEBUGGER:
+                raise ValueError('Only in App debug mode can override model config')
+
+            # validate config
+            override_model_config_dict = CompletionAppConfigManager.config_validate(
+                tenant_id=app_model.tenant_id,
+                config=args.get('model_config')
+            )
+
+        # parse files
+        files = args['files'] if 'files' in args and args['files'] else []
+        message_file_parser = MessageFileParser(tenant_id=app_model.tenant_id, app_id=app_model.id)
+        file_extra_config = FileUploadConfigManager.convert(override_model_config_dict or app_model_config.to_dict())
+        if file_extra_config:
+            file_objs = message_file_parser.validate_and_transform_files_arg(
+                files,
+                file_extra_config,
+                user
+            )
+        else:
+            file_objs = []
+
+        # convert to app config
+        app_config = CompletionAppConfigManager.get_app_config(
+            app_model=app_model,
+            app_model_config=app_model_config,
+            override_config_dict=override_model_config_dict
+        )
+
+        # init application generate entity
+        application_generate_entity = CompletionAppGenerateEntity(
+            task_id=str(uuid.uuid4()),
+            app_config=app_config,
+            model_config=ModelConfigConverter.convert(app_config),
+            inputs=self._get_cleaned_inputs(inputs, app_config),
+            query=query,
+            files=file_objs,
+            user_id=user.id,
+            stream=stream,
+            invoke_from=invoke_from,
+            extras=extras
+        )
+
+        # init generate records
+        (
+            conversation,
+            message
+        ) = self._init_generate_records(application_generate_entity)
+
+        # init queue manager
+        queue_manager = MessageBasedAppQueueManager(
+            task_id=application_generate_entity.task_id,
+            user_id=application_generate_entity.user_id,
+            invoke_from=application_generate_entity.invoke_from,
+            conversation_id=conversation.id,
+            app_mode=conversation.mode,
+            message_id=message.id
+        )
+
+        # new thread
+        worker_thread = threading.Thread(target=self._generate_worker, kwargs={
+            'flask_app': current_app._get_current_object(),
+            'application_generate_entity': application_generate_entity,
+            'queue_manager': queue_manager,
+            'message_id': message.id,
+        })
+
+        worker_thread.start()
+
+        # return response or stream generator
+        response = self._handle_response(
+            application_generate_entity=application_generate_entity,
+            queue_manager=queue_manager,
+            conversation=conversation,
+            message=message,
+            user=user,
+            stream=stream
+        )
+
+        return CompletionAppGenerateResponseConverter.convert(
+            response=response,
+            invoke_from=invoke_from
+        )
+
+    def _generate_worker(self, flask_app: Flask,
+                         application_generate_entity: CompletionAppGenerateEntity,
+                         queue_manager: AppQueueManager,
+                         message_id: str) -> None:
+        """
+        Generate worker in a new thread.
+        :param flask_app: Flask app
+        :param application_generate_entity: application generate entity
+        :param queue_manager: queue manager
+        :param conversation_id: conversation ID
+        :param message_id: message ID
+        :return:
+        """
+        with flask_app.app_context():
+            try:
+                # get message
+                message = self._get_message(message_id)
+
+                # chatbot app
+                runner = CompletionAppRunner()
+                runner.run(
+                    application_generate_entity=application_generate_entity,
+                    queue_manager=queue_manager,
+                    message=message
+                )
+            except GenerateTaskStoppedException:
+                pass
+            except InvokeAuthorizationError:
+                queue_manager.publish_error(
+                    InvokeAuthorizationError('Incorrect API key provided'),
+                    PublishFrom.APPLICATION_MANAGER
+                )
+            except ValidationError as e:
+                logger.exception("Validation Error when generating")
+                queue_manager.publish_error(e, PublishFrom.APPLICATION_MANAGER)
+            except (ValueError, InvokeError) as e:
+                queue_manager.publish_error(e, PublishFrom.APPLICATION_MANAGER)
+            except Exception as e:
+                logger.exception("Unknown Error when generating")
+                queue_manager.publish_error(e, PublishFrom.APPLICATION_MANAGER)
+            finally:
+                db.session.close()
+
+    def generate_more_like_this(self, app_model: App,
+                                message_id: str,
+                                user: Union[Account, EndUser],
+                                invoke_from: InvokeFrom,
+                                stream: bool = True) \
+            -> Union[dict, Generator[dict, None, None]]:
+        """
+        Generate App response.
+
+        :param app_model: App
+        :param message_id: message ID
+        :param user: account or end user
+        :param invoke_from: invoke from source
+        :param stream: is stream
+        """
+        message = db.session.query(Message).filter(
+            Message.id == message_id,
+            Message.app_id == app_model.id,
+            Message.from_source == ('api' if isinstance(user, EndUser) else 'console'),
+            Message.from_end_user_id == (user.id if isinstance(user, EndUser) else None),
+            Message.from_account_id == (user.id if isinstance(user, Account) else None),
+        ).first()
+
+        if not message:
+            raise MessageNotExistsError()
+
+        current_app_model_config = app_model.app_model_config
+        more_like_this = current_app_model_config.more_like_this_dict
+
+        if not current_app_model_config.more_like_this or more_like_this.get("enabled", False) is False:
+            raise MoreLikeThisDisabledError()
+
+        app_model_config = message.app_model_config
+        override_model_config_dict = app_model_config.to_dict()
+        model_dict = override_model_config_dict['model']
+        completion_params = model_dict.get('completion_params')
+        completion_params['temperature'] = 0.9
+        model_dict['completion_params'] = completion_params
+        override_model_config_dict['model'] = model_dict
+
+        # parse files
+        message_file_parser = MessageFileParser(tenant_id=app_model.tenant_id, app_id=app_model.id)
+        file_extra_config = FileUploadConfigManager.convert(override_model_config_dict or app_model_config.to_dict())
+        if file_extra_config:
+            file_objs = message_file_parser.validate_and_transform_files_arg(
+                message.files,
+                file_extra_config,
+                user
+            )
+        else:
+            file_objs = []
+
+        # convert to app config
+        app_config = CompletionAppConfigManager.get_app_config(
+            app_model=app_model,
+            app_model_config=app_model_config,
+            override_config_dict=override_model_config_dict
+        )
+
+        # init application generate entity
+        application_generate_entity = CompletionAppGenerateEntity(
+            task_id=str(uuid.uuid4()),
+            app_config=app_config,
+            model_config=ModelConfigConverter.convert(app_config),
+            inputs=message.inputs,
+            query=message.query,
+            files=file_objs,
+            user_id=user.id,
+            stream=stream,
+            invoke_from=invoke_from,
+            extras={}
+        )
+
+        # init generate records
+        (
+            conversation,
+            message
+        ) = self._init_generate_records(application_generate_entity)
+
+        # init queue manager
+        queue_manager = MessageBasedAppQueueManager(
+            task_id=application_generate_entity.task_id,
+            user_id=application_generate_entity.user_id,
+            invoke_from=application_generate_entity.invoke_from,
+            conversation_id=conversation.id,
+            app_mode=conversation.mode,
+            message_id=message.id
+        )
+
+        # new thread
+        worker_thread = threading.Thread(target=self._generate_worker, kwargs={
+            'flask_app': current_app._get_current_object(),
+            'application_generate_entity': application_generate_entity,
+            'queue_manager': queue_manager,
+            'message_id': message.id,
+        })
+
+        worker_thread.start()
+
+        # return response or stream generator
+        response = self._handle_response(
+            application_generate_entity=application_generate_entity,
+            queue_manager=queue_manager,
+            conversation=conversation,
+            message=message,
+            user=user,
+            stream=stream
+        )
+
+        return CompletionAppGenerateResponseConverter.convert(
+            response=response,
+            invoke_from=invoke_from
+        )

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

@@ -0,0 +1,179 @@
+import logging
+from typing import cast
+
+from core.app.apps.base_app_queue_manager import AppQueueManager
+from core.app.apps.base_app_runner import AppRunner
+from core.app.apps.completion.app_config_manager import CompletionAppConfig
+from core.app.entities.app_invoke_entities import (
+    CompletionAppGenerateEntity,
+)
+from core.callback_handler.index_tool_callback_handler import DatasetIndexToolCallbackHandler
+from core.model_manager import ModelInstance
+from core.moderation.base import ModerationException
+from core.rag.retrieval.dataset_retrieval import DatasetRetrieval
+from extensions.ext_database import db
+from models.model import App, Message
+
+logger = logging.getLogger(__name__)
+
+
+class CompletionAppRunner(AppRunner):
+    """
+    Completion Application Runner
+    """
+
+    def run(self, application_generate_entity: CompletionAppGenerateEntity,
+            queue_manager: AppQueueManager,
+            message: Message) -> None:
+        """
+        Run application
+        :param application_generate_entity: application generate entity
+        :param queue_manager: application queue manager
+        :param message: message
+        :return:
+        """
+        app_config = application_generate_entity.app_config
+        app_config = cast(CompletionAppConfig, app_config)
+
+        app_record = db.session.query(App).filter(App.id == app_config.app_id).first()
+        if not app_record:
+            raise ValueError("App not found")
+
+        inputs = application_generate_entity.inputs
+        query = application_generate_entity.query
+        files = application_generate_entity.files
+
+        # Pre-calculate the number of tokens of the prompt messages,
+        # and return the rest number of tokens by model context token size limit and max token size limit.
+        # If the rest number of tokens is not enough, raise exception.
+        # Include: prompt template, inputs, query(optional), files(optional)
+        # Not Include: memory, external data, dataset context
+        self.get_pre_calculate_rest_tokens(
+            app_record=app_record,
+            model_config=application_generate_entity.model_config,
+            prompt_template_entity=app_config.prompt_template,
+            inputs=inputs,
+            files=files,
+            query=query
+        )
+
+        # organize all inputs and template to prompt messages
+        # Include: prompt template, inputs, query(optional), files(optional)
+        prompt_messages, stop = self.organize_prompt_messages(
+            app_record=app_record,
+            model_config=application_generate_entity.model_config,
+            prompt_template_entity=app_config.prompt_template,
+            inputs=inputs,
+            files=files,
+            query=query
+        )
+
+        # moderation
+        try:
+            # process sensitive_word_avoidance
+            _, inputs, query = self.moderation_for_inputs(
+                app_id=app_record.id,
+                tenant_id=app_config.tenant_id,
+                app_generate_entity=application_generate_entity,
+                inputs=inputs,
+                query=query,
+            )
+        except ModerationException as e:
+            self.direct_output(
+                queue_manager=queue_manager,
+                app_generate_entity=application_generate_entity,
+                prompt_messages=prompt_messages,
+                text=str(e),
+                stream=application_generate_entity.stream
+            )
+            return
+
+        # fill in variable inputs from external data tools if exists
+        external_data_tools = app_config.external_data_variables
+        if external_data_tools:
+            inputs = self.fill_in_inputs_from_external_data_tools(
+                tenant_id=app_record.tenant_id,
+                app_id=app_record.id,
+                external_data_tools=external_data_tools,
+                inputs=inputs,
+                query=query
+            )
+
+        # get context from datasets
+        context = None
+        if app_config.dataset and app_config.dataset.dataset_ids:
+            hit_callback = DatasetIndexToolCallbackHandler(
+                queue_manager,
+                app_record.id,
+                message.id,
+                application_generate_entity.user_id,
+                application_generate_entity.invoke_from
+            )
+
+            dataset_config = app_config.dataset
+            if dataset_config and dataset_config.retrieve_config.query_variable:
+                query = inputs.get(dataset_config.retrieve_config.query_variable, "")
+
+            dataset_retrieval = DatasetRetrieval()
+            context = dataset_retrieval.retrieve(
+                tenant_id=app_record.tenant_id,
+                model_config=application_generate_entity.model_config,
+                config=dataset_config,
+                query=query,
+                invoke_from=application_generate_entity.invoke_from,
+                show_retrieve_source=app_config.additional_features.show_retrieve_source,
+                hit_callback=hit_callback
+            )
+
+        # reorganize all inputs and template to prompt messages
+        # Include: prompt template, inputs, query(optional), files(optional)
+        #          memory(optional), external data, dataset context(optional)
+        prompt_messages, stop = self.organize_prompt_messages(
+            app_record=app_record,
+            model_config=application_generate_entity.model_config,
+            prompt_template_entity=app_config.prompt_template,
+            inputs=inputs,
+            files=files,
+            query=query,
+            context=context
+        )
+
+        # check hosting moderation
+        hosting_moderation_result = self.check_hosting_moderation(
+            application_generate_entity=application_generate_entity,
+            queue_manager=queue_manager,
+            prompt_messages=prompt_messages
+        )
+
+        if hosting_moderation_result:
+            return
+
+        # Re-calculate the max tokens if sum(prompt_token +  max_tokens) over model token limit
+        self.recalc_llm_max_tokens(
+            model_config=application_generate_entity.model_config,
+            prompt_messages=prompt_messages
+        )
+
+        # Invoke model
+        model_instance = ModelInstance(
+            provider_model_bundle=application_generate_entity.model_config.provider_model_bundle,
+            model=application_generate_entity.model_config.model
+        )
+
+        db.session.close()
+
+        invoke_result = model_instance.invoke_llm(
+            prompt_messages=prompt_messages,
+            model_parameters=application_generate_entity.model_config.parameters,
+            stop=stop,
+            stream=application_generate_entity.stream,
+            user=application_generate_entity.user_id,
+        )
+
+        # handle invoke result
+        self._handle_invoke_result(
+            invoke_result=invoke_result,
+            queue_manager=queue_manager,
+            stream=application_generate_entity.stream
+        )
+    

api/core/app/apps/completion/generate_response_converter.py

@@ -0,0 +1,114 @@
+import json
+from collections.abc import Generator
+from typing import cast
+
+from core.app.apps.base_app_generate_response_converter import AppGenerateResponseConverter
+from core.app.entities.task_entities import (
+    CompletionAppBlockingResponse,
+    CompletionAppStreamResponse,
+    ErrorStreamResponse,
+    MessageEndStreamResponse,
+    PingStreamResponse,
+)
+
+
+class CompletionAppGenerateResponseConverter(AppGenerateResponseConverter):
+    _blocking_response_type = CompletionAppBlockingResponse
+
+    @classmethod
+    def convert_blocking_full_response(cls, blocking_response: CompletionAppBlockingResponse) -> dict:
+        """
+        Convert blocking full response.
+        :param blocking_response: blocking response
+        :return:
+        """
+        response = {
+            'event': 'message',
+            'task_id': blocking_response.task_id,
+            'id': blocking_response.data.id,
+            'message_id': blocking_response.data.message_id,
+            'mode': blocking_response.data.mode,
+            'answer': blocking_response.data.answer,
+            'metadata': blocking_response.data.metadata,
+            'created_at': blocking_response.data.created_at
+        }
+
+        return response
+
+    @classmethod
+    def convert_blocking_simple_response(cls, blocking_response: CompletionAppBlockingResponse) -> dict:
+        """
+        Convert blocking simple response.
+        :param blocking_response: blocking response
+        :return:
+        """
+        response = cls.convert_blocking_full_response(blocking_response)
+
+        metadata = response.get('metadata', {})
+        response['metadata'] = cls._get_simple_metadata(metadata)
+
+        return response
+
+    @classmethod
+    def convert_stream_full_response(cls, stream_response: Generator[CompletionAppStreamResponse, None, None]) \
+            -> Generator[str, None, None]:
+        """
+        Convert stream full response.
+        :param stream_response: stream response
+        :return:
+        """
+        for chunk in stream_response:
+            chunk = cast(CompletionAppStreamResponse, chunk)
+            sub_stream_response = chunk.stream_response
+
+            if isinstance(sub_stream_response, PingStreamResponse):
+                yield 'ping'
+                continue
+
+            response_chunk = {
+                'event': sub_stream_response.event.value,
+                'message_id': chunk.message_id,
+                'created_at': chunk.created_at
+            }
+
+            if isinstance(sub_stream_response, ErrorStreamResponse):
+                data = cls._error_to_stream_response(sub_stream_response.err)
+                response_chunk.update(data)
+            else:
+                response_chunk.update(sub_stream_response.to_dict())
+            yield json.dumps(response_chunk)
+
+    @classmethod
+    def convert_stream_simple_response(cls, stream_response: Generator[CompletionAppStreamResponse, None, None]) \
+            -> Generator[str, None, None]:
+        """
+        Convert stream simple response.
+        :param stream_response: stream response
+        :return:
+        """
+        for chunk in stream_response:
+            chunk = cast(CompletionAppStreamResponse, chunk)
+            sub_stream_response = chunk.stream_response
+
+            if isinstance(sub_stream_response, PingStreamResponse):
+                yield 'ping'
+                continue
+
+            response_chunk = {
+                'event': sub_stream_response.event.value,
+                'message_id': chunk.message_id,
+                'created_at': chunk.created_at
+            }
+
+            if isinstance(sub_stream_response, MessageEndStreamResponse):
+                sub_stream_response_dict = sub_stream_response.to_dict()
+                metadata = sub_stream_response_dict.get('metadata', {})
+                sub_stream_response_dict['metadata'] = cls._get_simple_metadata(metadata)
+                response_chunk.update(sub_stream_response_dict)
+            if isinstance(sub_stream_response, ErrorStreamResponse):
+                data = cls._error_to_stream_response(sub_stream_response.err)
+                response_chunk.update(data)
+            else:
+                response_chunk.update(sub_stream_response.to_dict())
+
+            yield json.dumps(response_chunk)

api/core/app/apps/message_based_app_generator.py

@@ -0,0 +1,286 @@
+import json
+import logging
+from collections.abc import Generator
+from typing import Optional, Union
+
+from sqlalchemy import and_
+
+from core.app.app_config.entities import EasyUIBasedAppModelConfigFrom
+from core.app.apps.base_app_generator import BaseAppGenerator
+from core.app.apps.base_app_queue_manager import AppQueueManager, GenerateTaskStoppedException
+from core.app.entities.app_invoke_entities import (
+    AdvancedChatAppGenerateEntity,
+    AgentChatAppGenerateEntity,
+    AppGenerateEntity,
+    ChatAppGenerateEntity,
+    CompletionAppGenerateEntity,
+    InvokeFrom,
+)
+from core.app.entities.task_entities import (
+    ChatbotAppBlockingResponse,
+    ChatbotAppStreamResponse,
+    CompletionAppBlockingResponse,
+    CompletionAppStreamResponse,
+)
+from core.app.task_pipeline.easy_ui_based_generate_task_pipeline import EasyUIBasedGenerateTaskPipeline
+from core.prompt.utils.prompt_template_parser import PromptTemplateParser
+from extensions.ext_database import db
+from models.account import Account
+from models.model import App, AppMode, AppModelConfig, Conversation, EndUser, Message, MessageFile
+from services.errors.app_model_config import AppModelConfigBrokenError
+from services.errors.conversation import ConversationCompletedError, ConversationNotExistsError
+
+logger = logging.getLogger(__name__)
+
+
+class MessageBasedAppGenerator(BaseAppGenerator):
+
+    def _handle_response(self, application_generate_entity: Union[
+        ChatAppGenerateEntity,
+        CompletionAppGenerateEntity,
+        AgentChatAppGenerateEntity,
+        AdvancedChatAppGenerateEntity
+    ],
+                         queue_manager: AppQueueManager,
+                         conversation: Conversation,
+                         message: Message,
+                         user: Union[Account, EndUser],
+                         stream: bool = False) \
+            -> Union[
+                ChatbotAppBlockingResponse,
+                CompletionAppBlockingResponse,
+                Generator[Union[ChatbotAppStreamResponse, CompletionAppStreamResponse], None, None]
+            ]:
+        """
+        Handle response.
+        :param application_generate_entity: application generate entity
+        :param queue_manager: queue manager
+        :param conversation: conversation
+        :param message: message
+        :param user: user
+        :param stream: is stream
+        :return:
+        """
+        # init generate task pipeline
+        generate_task_pipeline = EasyUIBasedGenerateTaskPipeline(
+            application_generate_entity=application_generate_entity,
+            queue_manager=queue_manager,
+            conversation=conversation,
+            message=message,
+            user=user,
+            stream=stream
+        )
+
+        try:
+            return generate_task_pipeline.process()
+        except ValueError as e:
+            if e.args[0] == "I/O operation on closed file.":  # ignore this error
+                raise GenerateTaskStoppedException()
+            else:
+                logger.exception(e)
+                raise e
+
+    def _get_conversation_by_user(self, app_model: App, conversation_id: str,
+                                  user: Union[Account, EndUser]) -> Conversation:
+        conversation_filter = [
+            Conversation.id == conversation_id,
+            Conversation.app_id == app_model.id,
+            Conversation.status == 'normal'
+        ]
+
+        if isinstance(user, Account):
+            conversation_filter.append(Conversation.from_account_id == user.id)
+        else:
+            conversation_filter.append(Conversation.from_end_user_id == user.id if user else None)
+
+        conversation = db.session.query(Conversation).filter(and_(*conversation_filter)).first()
+
+        if not conversation:
+            raise ConversationNotExistsError()
+
+        if conversation.status != 'normal':
+            raise ConversationCompletedError()
+
+        return conversation
+
+    def _get_app_model_config(self, app_model: App,
+                              conversation: Optional[Conversation] = None) \
+            -> AppModelConfig:
+        if conversation:
+            app_model_config = db.session.query(AppModelConfig).filter(
+                AppModelConfig.id == conversation.app_model_config_id,
+                AppModelConfig.app_id == app_model.id
+            ).first()
+
+            if not app_model_config:
+                raise AppModelConfigBrokenError()
+        else:
+            if app_model.app_model_config_id is None:
+                raise AppModelConfigBrokenError()
+
+            app_model_config = app_model.app_model_config
+
+            if not app_model_config:
+                raise AppModelConfigBrokenError()
+
+        return app_model_config
+
+    def _init_generate_records(self,
+                               application_generate_entity: Union[
+                                   ChatAppGenerateEntity,
+                                   CompletionAppGenerateEntity,
+                                   AgentChatAppGenerateEntity,
+                                   AdvancedChatAppGenerateEntity
+                               ],
+                               conversation: Optional[Conversation] = None) \
+            -> tuple[Conversation, Message]:
+        """
+        Initialize generate records
+        :param application_generate_entity: application generate entity
+        :return:
+        """
+        app_config = application_generate_entity.app_config
+
+        # get from source
+        end_user_id = None
+        account_id = None
+        if application_generate_entity.invoke_from in [InvokeFrom.WEB_APP, InvokeFrom.SERVICE_API]:
+            from_source = 'api'
+            end_user_id = application_generate_entity.user_id
+        else:
+            from_source = 'console'
+            account_id = application_generate_entity.user_id
+
+        if isinstance(application_generate_entity, AdvancedChatAppGenerateEntity):
+            app_model_config_id = None
+            override_model_configs = None
+            model_provider = None
+            model_id = None
+        else:
+            app_model_config_id = app_config.app_model_config_id
+            model_provider = application_generate_entity.model_config.provider
+            model_id = application_generate_entity.model_config.model
+            override_model_configs = None
+            if app_config.app_model_config_from == EasyUIBasedAppModelConfigFrom.ARGS \
+                    and app_config.app_mode in [AppMode.AGENT_CHAT, AppMode.CHAT, AppMode.COMPLETION]:
+                override_model_configs = app_config.app_model_config_dict
+
+        # get conversation introduction
+        introduction = self._get_conversation_introduction(application_generate_entity)
+
+        if not conversation:
+            conversation = Conversation(
+                app_id=app_config.app_id,
+                app_model_config_id=app_model_config_id,
+                model_provider=model_provider,
+                model_id=model_id,
+                override_model_configs=json.dumps(override_model_configs) if override_model_configs else None,
+                mode=app_config.app_mode.value,
+                name='New conversation',
+                inputs=application_generate_entity.inputs,
+                introduction=introduction,
+                system_instruction="",
+                system_instruction_tokens=0,
+                status='normal',
+                invoke_from=application_generate_entity.invoke_from.value,
+                from_source=from_source,
+                from_end_user_id=end_user_id,
+                from_account_id=account_id,
+            )
+
+            db.session.add(conversation)
+            db.session.commit()
+            db.session.refresh(conversation)
+
+        message = Message(
+            app_id=app_config.app_id,
+            model_provider=model_provider,
+            model_id=model_id,
+            override_model_configs=json.dumps(override_model_configs) if override_model_configs else None,
+            conversation_id=conversation.id,
+            inputs=application_generate_entity.inputs,
+            query=application_generate_entity.query or "",
+            message="",
+            message_tokens=0,
+            message_unit_price=0,
+            message_price_unit=0,
+            answer="",
+            answer_tokens=0,
+            answer_unit_price=0,
+            answer_price_unit=0,
+            provider_response_latency=0,
+            total_price=0,
+            currency='USD',
+            invoke_from=application_generate_entity.invoke_from.value,
+            from_source=from_source,
+            from_end_user_id=end_user_id,
+            from_account_id=account_id
+        )
+
+        db.session.add(message)
+        db.session.commit()
+        db.session.refresh(message)
+
+        for file in application_generate_entity.files:
+            message_file = MessageFile(
+                message_id=message.id,
+                type=file.type.value,
+                transfer_method=file.transfer_method.value,
+                belongs_to='user',
+                url=file.url,
+                upload_file_id=file.related_id,
+                created_by_role=('account' if account_id else 'end_user'),
+                created_by=account_id or end_user_id,
+            )
+            db.session.add(message_file)
+            db.session.commit()
+
+        return conversation, message
+
+    def _get_conversation_introduction(self, application_generate_entity: AppGenerateEntity) -> str:
+        """
+        Get conversation introduction
+        :param application_generate_entity: application generate entity
+        :return: conversation introduction
+        """
+        app_config = application_generate_entity.app_config
+        introduction = app_config.additional_features.opening_statement
+
+        if introduction:
+            try:
+                inputs = application_generate_entity.inputs
+                prompt_template = PromptTemplateParser(template=introduction)
+                prompt_inputs = {k: inputs[k] for k in prompt_template.variable_keys if k in inputs}
+                introduction = prompt_template.format(prompt_inputs)
+            except KeyError:
+                pass
+
+        return introduction
+
+    def _get_conversation(self, conversation_id: str) -> Conversation:
+        """
+        Get conversation by conversation id
+        :param conversation_id: conversation id
+        :return: conversation
+        """
+        conversation = (
+            db.session.query(Conversation)
+            .filter(Conversation.id == conversation_id)
+            .first()
+        )
+
+        return conversation
+
+    def _get_message(self, message_id: str) -> Message:
+        """
+        Get message by message id
+        :param message_id: message id
+        :return: message
+        """
+        message = (
+            db.session.query(Message)
+            .filter(Message.id == message_id)
+            .first()
+        )
+
+        return message

api/core/app/apps/message_based_app_queue_manager.py

@@ -0,0 +1,61 @@
+from core.app.apps.base_app_queue_manager import AppQueueManager, GenerateTaskStoppedException, PublishFrom
+from core.app.entities.app_invoke_entities import InvokeFrom
+from core.app.entities.queue_entities import (
+    AppQueueEvent,
+    MessageQueueMessage,
+    QueueAdvancedChatMessageEndEvent,
+    QueueErrorEvent,
+    QueueMessage,
+    QueueMessageEndEvent,
+    QueueStopEvent,
+)
+
+
+class MessageBasedAppQueueManager(AppQueueManager):
+    def __init__(self, task_id: str,
+                 user_id: str,
+                 invoke_from: InvokeFrom,
+                 conversation_id: str,
+                 app_mode: str,
+                 message_id: str) -> None:
+        super().__init__(task_id, user_id, invoke_from)
+
+        self._conversation_id = str(conversation_id)
+        self._app_mode = app_mode
+        self._message_id = str(message_id)
+
+    def construct_queue_message(self, event: AppQueueEvent) -> QueueMessage:
+        return MessageQueueMessage(
+            task_id=self._task_id,
+            message_id=self._message_id,
+            conversation_id=self._conversation_id,
+            app_mode=self._app_mode,
+            event=event
+        )
+
+    def _publish(self, event: AppQueueEvent, pub_from: PublishFrom) -> None:
+        """
+        Publish event to queue
+        :param event:
+        :param pub_from:
+        :return:
+        """
+        message = MessageQueueMessage(
+            task_id=self._task_id,
+            message_id=self._message_id,
+            conversation_id=self._conversation_id,
+            app_mode=self._app_mode,
+            event=event
+        )
+
+        self._q.put(message)
+
+        if isinstance(event, QueueStopEvent
+                             | QueueErrorEvent
+                             | QueueMessageEndEvent
+                             | QueueAdvancedChatMessageEndEvent):
+            self.stop_listen()
+
+        if pub_from == PublishFrom.APPLICATION_MANAGER and self._is_stopped():
+            raise GenerateTaskStoppedException()
+

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

@@ -0,0 +1,75 @@
+from core.app.app_config.base_app_config_manager import BaseAppConfigManager
+from core.app.app_config.common.sensitive_word_avoidance.manager import SensitiveWordAvoidanceConfigManager
+from core.app.app_config.entities import WorkflowUIBasedAppConfig
+from core.app.app_config.features.file_upload.manager import FileUploadConfigManager
+from core.app.app_config.features.text_to_speech.manager import TextToSpeechConfigManager
+from core.app.app_config.workflow_ui_based_app.variables.manager import WorkflowVariablesConfigManager
+from models.model import App, AppMode
+from models.workflow import Workflow
+
+
+class WorkflowAppConfig(WorkflowUIBasedAppConfig):
+    """
+    Workflow App Config Entity.
+    """
+    pass
+
+
+class WorkflowAppConfigManager(BaseAppConfigManager):
+    @classmethod
+    def get_app_config(cls, app_model: App, workflow: Workflow) -> WorkflowAppConfig:
+        features_dict = workflow.features_dict
+
+        app_mode = AppMode.value_of(app_model.mode)
+        app_config = WorkflowAppConfig(
+            tenant_id=app_model.tenant_id,
+            app_id=app_model.id,
+            app_mode=app_mode,
+            workflow_id=workflow.id,
+            sensitive_word_avoidance=SensitiveWordAvoidanceConfigManager.convert(
+                config=features_dict
+            ),
+            variables=WorkflowVariablesConfigManager.convert(
+                workflow=workflow
+            ),
+            additional_features=cls.convert_features(features_dict, app_mode)
+        )
+
+        return app_config
+
+    @classmethod
+    def config_validate(cls, tenant_id: str, config: dict, only_structure_validate: bool = False) -> dict:
+        """
+        Validate for workflow app model config
+
+        :param tenant_id: tenant id
+        :param config: app model config args
+        :param only_structure_validate: only validate the structure of the config
+        """
+        related_config_keys = []
+
+        # file upload validation
+        config, current_related_config_keys = FileUploadConfigManager.validate_and_set_defaults(
+            config=config,
+            is_vision=False
+        )
+        related_config_keys.extend(current_related_config_keys)
+
+        # text_to_speech
+        config, current_related_config_keys = TextToSpeechConfigManager.validate_and_set_defaults(config)
+        related_config_keys.extend(current_related_config_keys)
+
+        # moderation validation
+        config, current_related_config_keys = SensitiveWordAvoidanceConfigManager.validate_and_set_defaults(
+            tenant_id=tenant_id,
+            config=config,
+            only_structure_validate=only_structure_validate
+        )
+        related_config_keys.extend(current_related_config_keys)
+
+        related_config_keys = list(set(related_config_keys))
+
+        # Filter out extra parameters
+        filtered_config = {key: config.get(key) for key in related_config_keys}
+
+        return filtered_config

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

@@ -0,0 +1,180 @@
+import logging
+import threading
+import uuid
+from collections.abc import Generator
+from typing import Union
+
+from flask import Flask, current_app
+from pydantic import ValidationError
+
+from core.app.app_config.features.file_upload.manager import FileUploadConfigManager
+from core.app.apps.base_app_generator import BaseAppGenerator
+from core.app.apps.base_app_queue_manager import AppQueueManager, GenerateTaskStoppedException, PublishFrom
+from core.app.apps.workflow.app_config_manager import WorkflowAppConfigManager
+from core.app.apps.workflow.app_queue_manager import WorkflowAppQueueManager
+from core.app.apps.workflow.app_runner import WorkflowAppRunner
+from core.app.apps.workflow.generate_response_converter import WorkflowAppGenerateResponseConverter
+from core.app.apps.workflow.generate_task_pipeline import WorkflowAppGenerateTaskPipeline
+from core.app.entities.app_invoke_entities import InvokeFrom, WorkflowAppGenerateEntity
+from core.app.entities.task_entities import WorkflowAppBlockingResponse, WorkflowAppStreamResponse
+from core.file.message_file_parser import MessageFileParser
+from core.model_runtime.errors.invoke import InvokeAuthorizationError, InvokeError
+from extensions.ext_database import db
+from models.account import Account
+from models.model import App, EndUser
+from models.workflow import Workflow
+
+logger = logging.getLogger(__name__)
+
+
+class WorkflowAppGenerator(BaseAppGenerator):
+    def generate(self, app_model: App,
+                 workflow: Workflow,
+                 user: Union[Account, EndUser],
+                 args: dict,
+                 invoke_from: InvokeFrom,
+                 stream: bool = True) \
+            -> Union[dict, Generator[dict, None, None]]:
+        """
+        Generate App response.
+
+        :param app_model: App
+        :param workflow: Workflow
+        :param user: account or end user
+        :param args: request args
+        :param invoke_from: invoke from source
+        :param stream: is stream
+        """
+        inputs = args['inputs']
+
+        # parse files
+        files = args['files'] if 'files' in args and args['files'] else []
+        message_file_parser = MessageFileParser(tenant_id=app_model.tenant_id, app_id=app_model.id)
+        file_extra_config = FileUploadConfigManager.convert(workflow.features_dict, is_vision=False)
+        if file_extra_config:
+            file_objs = message_file_parser.validate_and_transform_files_arg(
+                files,
+                file_extra_config,
+                user
+            )
+        else:
+            file_objs = []
+
+        # convert to app config
+        app_config = WorkflowAppConfigManager.get_app_config(
+            app_model=app_model,
+            workflow=workflow
+        )
+
+        # init application generate entity
+        application_generate_entity = WorkflowAppGenerateEntity(
+            task_id=str(uuid.uuid4()),
+            app_config=app_config,
+            inputs=self._get_cleaned_inputs(inputs, app_config),
+            files=file_objs,
+            user_id=user.id,
+            stream=stream,
+            invoke_from=invoke_from
+        )
+
+        # init queue manager
+        queue_manager = WorkflowAppQueueManager(
+            task_id=application_generate_entity.task_id,
+            user_id=application_generate_entity.user_id,
+            invoke_from=application_generate_entity.invoke_from,
+            app_mode=app_model.mode
+        )
+
+        # new thread
+        worker_thread = threading.Thread(target=self._generate_worker, kwargs={
+            'flask_app': current_app._get_current_object(),
+            'application_generate_entity': application_generate_entity,
+            'queue_manager': queue_manager
+        })
+
+        worker_thread.start()
+
+        # return response or stream generator
+        response = self._handle_response(
+            application_generate_entity=application_generate_entity,
+            workflow=workflow,
+            queue_manager=queue_manager,
+            user=user,
+            stream=stream
+        )
+
+        return WorkflowAppGenerateResponseConverter.convert(
+            response=response,
+            invoke_from=invoke_from
+        )
+
+    def _generate_worker(self, flask_app: Flask,
+                         application_generate_entity: WorkflowAppGenerateEntity,
+                         queue_manager: AppQueueManager) -> None:
+        """
+        Generate worker in a new thread.
+        :param flask_app: Flask app
+        :param application_generate_entity: application generate entity
+        :param queue_manager: queue manager
+        :return:
+        """
+        with flask_app.app_context():
+            try:
+                # workflow app
+                runner = WorkflowAppRunner()
+                runner.run(
+                    application_generate_entity=application_generate_entity,
+                    queue_manager=queue_manager
+                )
+            except GenerateTaskStoppedException:
+                pass
+            except InvokeAuthorizationError:
+                queue_manager.publish_error(
+                    InvokeAuthorizationError('Incorrect API key provided'),
+                    PublishFrom.APPLICATION_MANAGER
+                )
+            except ValidationError as e:
+                logger.exception("Validation Error when generating")
+                queue_manager.publish_error(e, PublishFrom.APPLICATION_MANAGER)
+            except (ValueError, InvokeError) as e:
+                queue_manager.publish_error(e, PublishFrom.APPLICATION_MANAGER)
+            except Exception as e:
+                logger.exception("Unknown Error when generating")
+                queue_manager.publish_error(e, PublishFrom.APPLICATION_MANAGER)
+            finally:
+                db.session.remove()
+
+    def _handle_response(self, application_generate_entity: WorkflowAppGenerateEntity,
+                         workflow: Workflow,
+                         queue_manager: AppQueueManager,
+                         user: Union[Account, EndUser],
+                         stream: bool = False) -> Union[
+        WorkflowAppBlockingResponse,
+        Generator[WorkflowAppStreamResponse, None, None]
+    ]:
+        """
+        Handle response.
+        :param application_generate_entity: application generate entity
+        :param workflow: workflow
+        :param queue_manager: queue manager
+        :param user: account or end user
+        :param stream: is stream
+        :return:
+        """
+        # init generate task pipeline
+        generate_task_pipeline = WorkflowAppGenerateTaskPipeline(
+            application_generate_entity=application_generate_entity,
+            workflow=workflow,
+            queue_manager=queue_manager,
+            user=user,
+            stream=stream
+        )
+
+        try:
+            return generate_task_pipeline.process()
+        except ValueError as e:
+            if e.args[0] == "I/O operation on closed file.":  # ignore this error
+                raise GenerateTaskStoppedException()
+            else:
+                logger.exception(e)
+                raise e

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

@@ -0,0 +1,46 @@
+from core.app.apps.base_app_queue_manager import AppQueueManager, GenerateTaskStoppedException, PublishFrom
+from core.app.entities.app_invoke_entities import InvokeFrom
+from core.app.entities.queue_entities import (
+    AppQueueEvent,
+    QueueErrorEvent,
+    QueueMessageEndEvent,
+    QueueStopEvent,
+    QueueWorkflowFailedEvent,
+    QueueWorkflowSucceededEvent,
+    WorkflowQueueMessage,
+)
+
+
+class WorkflowAppQueueManager(AppQueueManager):
+    def __init__(self, task_id: str,
+                 user_id: str,
+                 invoke_from: InvokeFrom,
+                 app_mode: str) -> None:
+        super().__init__(task_id, user_id, invoke_from)
+
+        self._app_mode = app_mode
+
+    def _publish(self, event: AppQueueEvent, pub_from: PublishFrom) -> None:
+        """
+        Publish event to queue
+        :param event:
+        :param pub_from:
+        :return:
+        """
+        message = WorkflowQueueMessage(
+            task_id=self._task_id,
+            app_mode=self._app_mode,
+            event=event
+        )
+
+        self._q.put(message)
+
+        if isinstance(event, QueueStopEvent
+                             | QueueErrorEvent
+                             | QueueMessageEndEvent
+                             | QueueWorkflowSucceededEvent
+                             | QueueWorkflowFailedEvent):
+            self.stop_listen()
+
+        if pub_from == PublishFrom.APPLICATION_MANAGER and self._is_stopped():
+            raise GenerateTaskStoppedException()

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

@@ -0,0 +1,87 @@
+import logging
+import os
+from typing import Optional, cast
+
+from core.app.apps.base_app_queue_manager import AppQueueManager
+from core.app.apps.workflow.app_config_manager import WorkflowAppConfig
+from core.app.apps.workflow.workflow_event_trigger_callback import WorkflowEventTriggerCallback
+from core.app.apps.workflow_logging_callback import WorkflowLoggingCallback
+from core.app.entities.app_invoke_entities import (
+    InvokeFrom,
+    WorkflowAppGenerateEntity,
+)
+from core.workflow.entities.node_entities import SystemVariable
+from core.workflow.nodes.base_node import UserFrom
+from core.workflow.workflow_engine_manager import WorkflowEngineManager
+from extensions.ext_database import db
+from models.model import App
+from models.workflow import Workflow
+
+logger = logging.getLogger(__name__)
+
+
+class WorkflowAppRunner:
+    """
+    Workflow Application Runner
+    """
+
+    def run(self, application_generate_entity: WorkflowAppGenerateEntity,
+            queue_manager: AppQueueManager) -> None:
+        """
+        Run application
+        :param application_generate_entity: application generate entity
+        :param queue_manager: application queue manager
+        :return:
+        """
+        app_config = application_generate_entity.app_config
+        app_config = cast(WorkflowAppConfig, app_config)
+
+        app_record = db.session.query(App).filter(App.id == app_config.app_id).first()
+        if not app_record:
+            raise ValueError("App not found")
+
+        workflow = self.get_workflow(app_model=app_record, workflow_id=app_config.workflow_id)
+        if not workflow:
+            raise ValueError("Workflow not initialized")
+
+        inputs = application_generate_entity.inputs
+        files = application_generate_entity.files
+
+        db.session.close()
+
+        workflow_callbacks = [WorkflowEventTriggerCallback(
+            queue_manager=queue_manager,
+            workflow=workflow
+        )]
+
+        if bool(os.environ.get("DEBUG", 'False').lower() == 'true'):
+            workflow_callbacks.append(WorkflowLoggingCallback())
+
+        # RUN WORKFLOW
+        workflow_engine_manager = WorkflowEngineManager()
+        workflow_engine_manager.run_workflow(
+            workflow=workflow,
+            user_id=application_generate_entity.user_id,
+            user_from=UserFrom.ACCOUNT
+            if application_generate_entity.invoke_from in [InvokeFrom.EXPLORE, InvokeFrom.DEBUGGER]
+            else UserFrom.END_USER,
+            user_inputs=inputs,
+            system_inputs={
+                SystemVariable.FILES: files
+            },
+            callbacks=workflow_callbacks
+        )
+
+    def get_workflow(self, app_model: App, workflow_id: str) -> Optional[Workflow]:
+        """
+        Get workflow
+        """
+        # fetch workflow by workflow_id
+        workflow = db.session.query(Workflow).filter(
+            Workflow.tenant_id == app_model.tenant_id,
+            Workflow.app_id == app_model.id,
+            Workflow.id == workflow_id
+        ).first()
+
+        # return workflow
+        return workflow

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

@@ -0,0 +1,71 @@
+import json
+from collections.abc import Generator
+from typing import cast
+
+from core.app.apps.base_app_generate_response_converter import AppGenerateResponseConverter
+from core.app.entities.task_entities import (
+    ErrorStreamResponse,
+    PingStreamResponse,
+    WorkflowAppBlockingResponse,
+    WorkflowAppStreamResponse,
+)
+
+
+class WorkflowAppGenerateResponseConverter(AppGenerateResponseConverter):
+    _blocking_response_type = WorkflowAppBlockingResponse
+
+    @classmethod
+    def convert_blocking_full_response(cls, blocking_response: WorkflowAppBlockingResponse) -> dict:
+        """
+        Convert blocking full response.
+        :param blocking_response: blocking response
+        :return:
+        """
+        return blocking_response.to_dict()
+
+    @classmethod
+    def convert_blocking_simple_response(cls, blocking_response: WorkflowAppBlockingResponse) -> dict:
+        """
+        Convert blocking simple response.
+        :param blocking_response: blocking response
+        :return:
+        """
+        return cls.convert_blocking_full_response(blocking_response)
+
+    @classmethod
+    def convert_stream_full_response(cls, stream_response: Generator[WorkflowAppStreamResponse, None, None]) \
+            -> Generator[str, None, None]:
+        """
+        Convert stream full response.
+        :param stream_response: stream response
+        :return:
+        """
+        for chunk in stream_response:
+            chunk = cast(WorkflowAppStreamResponse, chunk)
+            sub_stream_response = chunk.stream_response
+
+            if isinstance(sub_stream_response, PingStreamResponse):
+                yield 'ping'
+                continue
+
+            response_chunk = {
+                'event': sub_stream_response.event.value,
+                'workflow_run_id': chunk.workflow_run_id,
+            }
+
+            if isinstance(sub_stream_response, ErrorStreamResponse):
+                data = cls._error_to_stream_response(sub_stream_response.err)
+                response_chunk.update(data)
+            else:
+                response_chunk.update(sub_stream_response.to_dict())
+            yield json.dumps(response_chunk)
+
+    @classmethod
+    def convert_stream_simple_response(cls, stream_response: Generator[WorkflowAppStreamResponse, None, None]) \
+            -> Generator[str, None, None]:
+        """
+        Convert stream simple response.
+        :param stream_response: stream response
+        :return:
+        """
+        return cls.convert_stream_full_response(stream_response)

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

@@ -0,0 +1,250 @@
+import logging
+from collections.abc import Generator
+from typing import Any, Union
+
+from core.app.apps.base_app_queue_manager import AppQueueManager
+from core.app.entities.app_invoke_entities import (
+    InvokeFrom,
+    WorkflowAppGenerateEntity,
+)
+from core.app.entities.queue_entities import (
+    QueueErrorEvent,
+    QueueMessageReplaceEvent,
+    QueueNodeFailedEvent,
+    QueueNodeStartedEvent,
+    QueueNodeSucceededEvent,
+    QueuePingEvent,
+    QueueStopEvent,
+    QueueTextChunkEvent,
+    QueueWorkflowFailedEvent,
+    QueueWorkflowStartedEvent,
+    QueueWorkflowSucceededEvent,
+)
+from core.app.entities.task_entities import (
+    ErrorStreamResponse,
+    StreamResponse,
+    TextChunkStreamResponse,
+    TextReplaceStreamResponse,
+    WorkflowAppBlockingResponse,
+    WorkflowAppStreamResponse,
+    WorkflowFinishStreamResponse,
+    WorkflowTaskState,
+)
+from core.app.task_pipeline.based_generate_task_pipeline import BasedGenerateTaskPipeline
+from core.app.task_pipeline.workflow_cycle_manage import WorkflowCycleManage
+from core.workflow.entities.node_entities import SystemVariable
+from extensions.ext_database import db
+from models.account import Account
+from models.model import EndUser
+from models.workflow import (
+    Workflow,
+    WorkflowAppLog,
+    WorkflowAppLogCreatedFrom,
+    WorkflowRun,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class WorkflowAppGenerateTaskPipeline(BasedGenerateTaskPipeline, WorkflowCycleManage):
+    """
+    WorkflowAppGenerateTaskPipeline is a class that generate stream output and state management for Application.
+    """
+    _workflow: Workflow
+    _user: Union[Account, EndUser]
+    _task_state: WorkflowTaskState
+    _application_generate_entity: WorkflowAppGenerateEntity
+    _workflow_system_variables: dict[SystemVariable, Any]
+
+    def __init__(self, application_generate_entity: WorkflowAppGenerateEntity,
+                 workflow: Workflow,
+                 queue_manager: AppQueueManager,
+                 user: Union[Account, EndUser],
+                 stream: bool) -> None:
+        """
+        Initialize GenerateTaskPipeline.
+        :param application_generate_entity: application generate entity
+        :param workflow: workflow
+        :param queue_manager: queue manager
+        :param user: user
+        :param stream: is streamed
+        """
+        super().__init__(application_generate_entity, queue_manager, user, stream)
+
+        self._workflow = workflow
+        self._workflow_system_variables = {
+            SystemVariable.FILES: application_generate_entity.files,
+        }
+
+        self._task_state = WorkflowTaskState()
+
+    def process(self) -> Union[WorkflowAppBlockingResponse, Generator[WorkflowAppStreamResponse, None, None]]:
+        """
+        Process generate task pipeline.
+        :return:
+        """
+        db.session.refresh(self._workflow)
+        db.session.refresh(self._user)
+        db.session.close()
+
+        generator = self._process_stream_response()
+        if self._stream:
+            return self._to_stream_response(generator)
+        else:
+            return self._to_blocking_response(generator)
+
+    def _to_blocking_response(self, generator: Generator[StreamResponse, None, None]) \
+            -> WorkflowAppBlockingResponse:
+        """
+        To blocking response.
+        :return:
+        """
+        for stream_response in generator:
+            if isinstance(stream_response, ErrorStreamResponse):
+                raise stream_response.err
+            elif isinstance(stream_response, WorkflowFinishStreamResponse):
+                workflow_run = db.session.query(WorkflowRun).filter(
+                    WorkflowRun.id == self._task_state.workflow_run_id).first()
+
+                response = WorkflowAppBlockingResponse(
+                    task_id=self._application_generate_entity.task_id,
+                    workflow_run_id=workflow_run.id,
+                    data=WorkflowAppBlockingResponse.Data(
+                        id=workflow_run.id,
+                        workflow_id=workflow_run.workflow_id,
+                        status=workflow_run.status,
+                        outputs=workflow_run.outputs_dict,
+                        error=workflow_run.error,
+                        elapsed_time=workflow_run.elapsed_time,
+                        total_tokens=workflow_run.total_tokens,
+                        total_steps=workflow_run.total_steps,
+                        created_at=int(workflow_run.created_at.timestamp()),
+                        finished_at=int(workflow_run.finished_at.timestamp())
+                    )
+                )
+
+                return response
+            else:
+                continue
+
+        raise Exception('Queue listening stopped unexpectedly.')
+
+    def _to_stream_response(self, generator: Generator[StreamResponse, None, None]) \
+            -> Generator[WorkflowAppStreamResponse, None, None]:
+        """
+        To stream response.
+        :return:
+        """
+        for stream_response in generator:
+            yield WorkflowAppStreamResponse(
+                workflow_run_id=self._task_state.workflow_run_id,
+                stream_response=stream_response
+            )
+
+    def _process_stream_response(self) -> Generator[StreamResponse, None, None]:
+        """
+        Process stream response.
+        :return:
+        """
+        for message in self._queue_manager.listen():
+            event = message.event
+
+            if isinstance(event, QueueErrorEvent):
+                err = self._handle_error(event)
+                yield self._error_to_stream_response(err)
+                break
+            elif isinstance(event, QueueWorkflowStartedEvent):
+                workflow_run = self._handle_workflow_start()
+                yield self._workflow_start_to_stream_response(
+                    task_id=self._application_generate_entity.task_id,
+                    workflow_run=workflow_run
+                )
+            elif isinstance(event, QueueNodeStartedEvent):
+                workflow_node_execution = self._handle_node_start(event)
+                yield self._workflow_node_start_to_stream_response(
+                    event=event,
+                    task_id=self._application_generate_entity.task_id,
+                    workflow_node_execution=workflow_node_execution
+                )
+            elif isinstance(event, QueueNodeSucceededEvent | QueueNodeFailedEvent):
+                workflow_node_execution = self._handle_node_finished(event)
+                yield self._workflow_node_finish_to_stream_response(
+                    task_id=self._application_generate_entity.task_id,
+                    workflow_node_execution=workflow_node_execution
+                )
+            elif isinstance(event, QueueStopEvent | QueueWorkflowSucceededEvent | QueueWorkflowFailedEvent):
+                workflow_run = self._handle_workflow_finished(event)
+
+                # save workflow app log
+                self._save_workflow_app_log(workflow_run)
+
+                yield self._workflow_finish_to_stream_response(
+                    task_id=self._application_generate_entity.task_id,
+                    workflow_run=workflow_run
+                )
+            elif isinstance(event, QueueTextChunkEvent):
+                delta_text = event.text
+                if delta_text is None:
+                    continue
+
+                self._task_state.answer += delta_text
+                yield self._text_chunk_to_stream_response(delta_text)
+            elif isinstance(event, QueueMessageReplaceEvent):
+                yield self._text_replace_to_stream_response(event.text)
+            elif isinstance(event, QueuePingEvent):
+                yield self._ping_stream_response()
+            else:
+                continue
+
+    def _save_workflow_app_log(self, workflow_run: WorkflowRun) -> None:
+        """
+        Save workflow app log.
+        :return:
+        """
+        invoke_from = self._application_generate_entity.invoke_from
+        if invoke_from == InvokeFrom.SERVICE_API:
+            created_from = WorkflowAppLogCreatedFrom.SERVICE_API
+        elif invoke_from == InvokeFrom.EXPLORE:
+            created_from = WorkflowAppLogCreatedFrom.INSTALLED_APP
+        elif invoke_from == InvokeFrom.WEB_APP:
+            created_from = WorkflowAppLogCreatedFrom.WEB_APP
+        else:
+            # not save log for debugging
+            return
+
+        workflow_app_log = WorkflowAppLog(
+            tenant_id=workflow_run.tenant_id,
+            app_id=workflow_run.app_id,
+            workflow_id=workflow_run.workflow_id,
+            workflow_run_id=workflow_run.id,
+            created_from=created_from.value,
+            created_by_role=('account' if isinstance(self._user, Account) else 'end_user'),
+            created_by=self._user.id,
+        )
+        db.session.add(workflow_app_log)
+        db.session.commit()
+        db.session.close()
+
+    def _text_chunk_to_stream_response(self, text: str) -> TextChunkStreamResponse:
+        """
+        Handle completed event.
+        :param text: text
+        :return:
+        """
+        response = TextChunkStreamResponse(
+            task_id=self._application_generate_entity.task_id,
+            data=TextChunkStreamResponse.Data(text=text)
+        )
+
+        return response
+
+    def _text_replace_to_stream_response(self, text: str) -> TextReplaceStreamResponse:
+        """
+        Text replace to stream response.
+        :param text: text
+        :return:
+        """
+        return TextReplaceStreamResponse(
+            task_id=self._application_generate_entity.task_id,
+            text=TextReplaceStreamResponse.Data(text=text)
+        )

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

@@ -0,0 +1,128 @@
+from typing import Optional
+
+from core.app.apps.base_app_queue_manager import AppQueueManager, PublishFrom
+from core.app.entities.queue_entities import (
+    AppQueueEvent,
+    QueueNodeFailedEvent,
+    QueueNodeStartedEvent,
+    QueueNodeSucceededEvent,
+    QueueWorkflowFailedEvent,
+    QueueWorkflowStartedEvent,
+    QueueWorkflowSucceededEvent,
+)
+from core.workflow.callbacks.base_workflow_callback import BaseWorkflowCallback
+from core.workflow.entities.base_node_data_entities import BaseNodeData
+from core.workflow.entities.node_entities import NodeType
+from models.workflow import Workflow
+
+
+class WorkflowEventTriggerCallback(BaseWorkflowCallback):
+
+    def __init__(self, queue_manager: AppQueueManager, workflow: Workflow):
+        self._queue_manager = queue_manager
+
+    def on_workflow_run_started(self) -> None:
+        """
+        Workflow run started
+        """
+        self._queue_manager.publish(
+            QueueWorkflowStartedEvent(),
+            PublishFrom.APPLICATION_MANAGER
+        )
+
+    def on_workflow_run_succeeded(self) -> None:
+        """
+        Workflow run succeeded
+        """
+        self._queue_manager.publish(
+            QueueWorkflowSucceededEvent(),
+            PublishFrom.APPLICATION_MANAGER
+        )
+
+    def on_workflow_run_failed(self, error: str) -> None:
+        """
+        Workflow run failed
+        """
+        self._queue_manager.publish(
+            QueueWorkflowFailedEvent(
+                error=error
+            ),
+            PublishFrom.APPLICATION_MANAGER
+        )
+
+    def on_workflow_node_execute_started(self, node_id: str,
+                                         node_type: NodeType,
+                                         node_data: BaseNodeData,
+                                         node_run_index: int = 1,
+                                         predecessor_node_id: Optional[str] = None) -> None:
+        """
+        Workflow node execute started
+        """
+        self._queue_manager.publish(
+            QueueNodeStartedEvent(
+                node_id=node_id,
+                node_type=node_type,
+                node_data=node_data,
+                node_run_index=node_run_index,
+                predecessor_node_id=predecessor_node_id
+            ),
+            PublishFrom.APPLICATION_MANAGER
+        )
+
+    def on_workflow_node_execute_succeeded(self, node_id: str,
+                                           node_type: NodeType,
+                                           node_data: BaseNodeData,
+                                           inputs: Optional[dict] = None,
+                                           process_data: Optional[dict] = None,
+                                           outputs: Optional[dict] = None,
+                                           execution_metadata: Optional[dict] = None) -> None:
+        """
+        Workflow node execute succeeded
+        """
+        self._queue_manager.publish(
+            QueueNodeSucceededEvent(
+                node_id=node_id,
+                node_type=node_type,
+                node_data=node_data,
+                inputs=inputs,
+                process_data=process_data,
+                outputs=outputs,
+                execution_metadata=execution_metadata
+            ),
+            PublishFrom.APPLICATION_MANAGER
+        )
+
+    def on_workflow_node_execute_failed(self, node_id: str,
+                                        node_type: NodeType,
+                                        node_data: BaseNodeData,
+                                        error: str,
+                                        inputs: Optional[dict] = None,
+                                        outputs: Optional[dict] = None,
+                                        process_data: Optional[dict] = None) -> None:
+        """
+        Workflow node execute failed
+        """
+        self._queue_manager.publish(
+            QueueNodeFailedEvent(
+                node_id=node_id,
+                node_type=node_type,
+                node_data=node_data,
+                inputs=inputs,
+                outputs=outputs,
+                process_data=process_data,
+                error=error
+            ),
+            PublishFrom.APPLICATION_MANAGER
+        )
+
+    def on_node_text_chunk(self, node_id: str, text: str, metadata: Optional[dict] = None) -> None:
+        """
+        Publish text chunk
+        """
+        pass
+
+    def on_event(self, event: AppQueueEvent) -> None:
+        """
+        Publish event
+        """
+        pass

api/core/app/apps/workflow_logging_callback.py

@@ -0,0 +1,122 @@
+from typing import Optional
+
+from core.app.entities.queue_entities import AppQueueEvent
+from core.model_runtime.utils.encoders import jsonable_encoder
+from core.workflow.callbacks.base_workflow_callback import BaseWorkflowCallback
+from core.workflow.entities.base_node_data_entities import BaseNodeData
+from core.workflow.entities.node_entities import NodeType
+
+_TEXT_COLOR_MAPPING = {
+    "blue": "36;1",
+    "yellow": "33;1",
+    "pink": "38;5;200",
+    "green": "32;1",
+    "red": "31;1",
+}
+
+
+class WorkflowLoggingCallback(BaseWorkflowCallback):
+
+    def __init__(self) -> None:
+        self.current_node_id = None
+
+    def on_workflow_run_started(self) -> None:
+        """
+        Workflow run started
+        """
+        self.print_text("\n[on_workflow_run_started]", color='pink')
+
+    def on_workflow_run_succeeded(self) -> None:
+        """
+        Workflow run succeeded
+        """
+        self.print_text("\n[on_workflow_run_succeeded]", color='green')
+
+    def on_workflow_run_failed(self, error: str) -> None:
+        """
+        Workflow run failed
+        """
+        self.print_text("\n[on_workflow_run_failed]", color='red')
+
+    def on_workflow_node_execute_started(self, node_id: str,
+                                         node_type: NodeType,
+                                         node_data: BaseNodeData,
+                                         node_run_index: int = 1,
+                                         predecessor_node_id: Optional[str] = None) -> None:
+        """
+        Workflow node execute started
+        """
+        self.print_text("\n[on_workflow_node_execute_started]", color='yellow')
+        self.print_text(f"Node ID: {node_id}", color='yellow')
+        self.print_text(f"Type: {node_type.value}", color='yellow')
+        self.print_text(f"Index: {node_run_index}", color='yellow')
+        if predecessor_node_id:
+            self.print_text(f"Predecessor Node ID: {predecessor_node_id}", color='yellow')
+
+    def on_workflow_node_execute_succeeded(self, node_id: str,
+                                           node_type: NodeType,
+                                           node_data: BaseNodeData,
+                                           inputs: Optional[dict] = None,
+                                           process_data: Optional[dict] = None,
+                                           outputs: Optional[dict] = None,
+                                           execution_metadata: Optional[dict] = None) -> None:
+        """
+        Workflow node execute succeeded
+        """
+        self.print_text("\n[on_workflow_node_execute_succeeded]", color='green')
+        self.print_text(f"Node ID: {node_id}", color='green')
+        self.print_text(f"Type: {node_type.value}", color='green')
+        self.print_text(f"Inputs: {jsonable_encoder(inputs) if inputs else ''}", color='green')
+        self.print_text(f"Process Data: {jsonable_encoder(process_data) if process_data else ''}", color='green')
+        self.print_text(f"Outputs: {jsonable_encoder(outputs) if outputs else ''}", color='green')
+        self.print_text(f"Metadata: {jsonable_encoder(execution_metadata) if execution_metadata else ''}",
+                        color='green')
+
+    def on_workflow_node_execute_failed(self, node_id: str,
+                                        node_type: NodeType,
+                                        node_data: BaseNodeData,
+                                        error: str,
+                                        inputs: Optional[dict] = None,
+                                        outputs: Optional[dict] = None,
+                                        process_data: Optional[dict] = None) -> None:
+        """
+        Workflow node execute failed
+        """
+        self.print_text("\n[on_workflow_node_execute_failed]", color='red')
+        self.print_text(f"Node ID: {node_id}", color='red')
+        self.print_text(f"Type: {node_type.value}", color='red')
+        self.print_text(f"Error: {error}", color='red')
+        self.print_text(f"Inputs: {jsonable_encoder(inputs) if inputs else ''}", color='red')
+        self.print_text(f"Process Data: {jsonable_encoder(process_data) if process_data else ''}", color='red')
+        self.print_text(f"Outputs: {jsonable_encoder(outputs) if outputs else ''}", color='red')
+
+    def on_node_text_chunk(self, node_id: str, text: str, metadata: Optional[dict] = None) -> None:
+        """
+        Publish text chunk
+        """
+        if not self.current_node_id or self.current_node_id != node_id:
+            self.current_node_id = node_id
+            self.print_text('\n[on_node_text_chunk]')
+            self.print_text(f"Node ID: {node_id}")
+            self.print_text(f"Metadata: {jsonable_encoder(metadata) if metadata else ''}")
+
+        self.print_text(text, color="pink", end="")
+
+    def on_event(self, event: AppQueueEvent) -> None:
+        """
+        Publish event
+        """
+        self.print_text("\n[on_workflow_event]", color='blue')
+        self.print_text(f"Event: {jsonable_encoder(event)}", color='blue')
+
+    def print_text(
+            self, text: str, color: Optional[str] = None, end: str = "\n"
+    ) -> None:
+        """Print text with highlighting and no end characters."""
+        text_to_print = self._get_colored_text(text, color) if color else text
+        print(f'{text_to_print}', end=end)
+
+    def _get_colored_text(self, text: str, color: str) -> str:
+        """Get colored text."""
+        color_str = _TEXT_COLOR_MAPPING[color]
+        return f"\u001b[{color_str}m\033[1;3m{text}\u001b[0m"