refactor app generate

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

@@ -1,3 +1,5 @@
+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.entities import WorkflowUIBasedAppConfig
@@ -10,7 +12,7 @@ from core.app.app_config.features.suggested_questions_after_answer.manager impor
 )
 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.model import App, AppMode, Conversation
 from models.workflow import Workflow
 
 
@@ -23,7 +25,9 @@ class AdvancedChatAppConfig(WorkflowUIBasedAppConfig):
 
 class AdvancedChatAppConfigManager(BaseAppConfigManager):
     @classmethod
-    def config_convert(cls, app_model: App, workflow: Workflow) -> AdvancedChatAppConfig:
+    def get_app_config(cls, app_model: App,
+                       workflow: Workflow,
+                       conversation: Optional[Conversation] = None) -> AdvancedChatAppConfig:
         features_dict = workflow.features_dict
 
         app_config = AdvancedChatAppConfig(

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

@@ -19,7 +19,7 @@ from core.app.app_config.features.suggested_questions_after_answer.manager impor
 )
 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
+from models.model import App, AppMode, AppModelConfig, Conversation
 
 OLD_TOOLS = ["dataset", "google_search", "web_reader", "wikipedia", "current_datetime"]
 
@@ -33,19 +33,30 @@ class AgentChatAppConfig(EasyUIBasedAppConfig):
 
 class AgentChatAppConfigManager(BaseAppConfigManager):
     @classmethod
-    def config_convert(cls, app_model: App,
-                       config_from: EasyUIBasedAppModelConfigFrom,
+    def get_app_config(cls, app_model: App,
                        app_model_config: AppModelConfig,
-                       config_dict: Optional[dict] = None) -> AgentChatAppConfig:
+                       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 config_from: app model config from
         :param app_model_config: app model config
-        :param config_dict: app model config dict
+        :param conversation: conversation
+        :param override_config_dict: app model config dict
         :return:
         """
-        config_dict = cls.convert_to_config_dict(config_from, app_model_config, config_dict)
+        if override_config_dict:
+            config_from = EasyUIBasedAppModelConfigFrom.ARGS
+        elif conversation:
+            config_from = EasyUIBasedAppModelConfigFrom.CONVERSATION_SPECIFIC_CONFIG
+        else:
+            config_from = EasyUIBasedAppModelConfigFrom.APP_LATEST_CONFIG
+
+        if override_config_dict != 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_config = AgentChatAppConfig(
             tenant_id=app_model.tenant_id,

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

@@ -0,0 +1,194 @@
+import logging
+import threading
+import uuid
+from typing import Union, Any, Generator
+
+from flask import current_app, Flask
+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.app_queue_manager import ConversationTaskStoppedException, PublishFrom, AppQueueManager
+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.message_based_app_generator import MessageBasedAppGenerator
+from core.app.entities.app_invoke_entities import InvokeFrom, AgentChatAppGenerateEntity
+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]:
+        """
+        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 = 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_upload_entity = FileUploadConfigManager.convert(override_model_config_dict or app_model_config.to_dict())
+        if file_upload_entity:
+            file_objs = message_file_parser.validate_and_transform_files_arg(
+                files,
+                file_upload_entity,
+                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 = AppQueueManager(
+            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
+        return self._handle_response(
+            application_generate_entity=application_generate_entity,
+            queue_manager=queue_manager,
+            conversation=conversation,
+            message=message,
+            stream=stream
+        )
+
+    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 ConversationTaskStoppedException:
+                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()

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

@@ -7,7 +7,8 @@ from core.agent.fc_agent_runner import FunctionCallAgentRunner
 from core.app.app_queue_manager import AppQueueManager, PublishFrom
 from core.app.apps.agent_chat.app_config_manager import AgentChatAppConfig
 from core.app.apps.base_app_runner import AppRunner
-from core.app.entities.app_invoke_entities import EasyUIBasedAppGenerateEntity, EasyUIBasedModelConfigEntity
+from core.app.entities.app_invoke_entities import ModelConfigWithCredentialsEntity, \
+    AgentChatAppGenerateEntity
 from core.memory.token_buffer_memory import TokenBufferMemory
 from core.model_manager import ModelInstance
 from core.model_runtime.entities.llm_entities import LLMUsage
@@ -26,7 +27,7 @@ class AgentChatAppRunner(AppRunner):
     """
     Agent Application Runner
     """
-    def run(self, application_generate_entity: EasyUIBasedAppGenerateEntity,
+    def run(self, application_generate_entity: AgentChatAppGenerateEntity,
             queue_manager: AppQueueManager,
             conversation: Conversation,
             message: Message) -> None:
@@ -292,7 +293,7 @@ class AgentChatAppRunner(AppRunner):
             'pool': db_variables.variables
         })
 
-    def _get_usage_of_all_agent_thoughts(self, model_config: EasyUIBasedModelConfigEntity,
+    def _get_usage_of_all_agent_thoughts(self, model_config: ModelConfigWithCredentialsEntity,
                                          message: Message) -> LLMUsage:
         """
         Get usage of all agent thoughts

api/core/app/apps/base_app_generator.py

@@ -0,0 +1,42 @@
+from core.app.app_config.entities import VariableEntity, AppConfig
+
+
+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_runner.py

@@ -5,9 +5,8 @@ from typing import Optional, Union, cast
 from core.app.app_config.entities import ExternalDataVariableEntity, PromptTemplateEntity
 from core.app.app_queue_manager import AppQueueManager, PublishFrom
 from core.app.entities.app_invoke_entities import (
-    EasyUIBasedAppGenerateEntity,
-    EasyUIBasedModelConfigEntity,
-    InvokeFrom,
+    ModelConfigWithCredentialsEntity,
+    InvokeFrom, AppGenerateEntity, EasyUIBasedAppGenerateEntity,
 )
 from core.app.features.annotation_reply.annotation_reply import AnnotationReplyFeature
 from core.app.features.hosting_moderation.hosting_moderation import HostingModerationFeature
@@ -27,7 +26,7 @@ from models.model import App, AppMode, Message, MessageAnnotation
 
 class AppRunner:
     def get_pre_calculate_rest_tokens(self, app_record: App,
-                                      model_config: EasyUIBasedModelConfigEntity,
+                                      model_config: ModelConfigWithCredentialsEntity,
                                       prompt_template_entity: PromptTemplateEntity,
                                       inputs: dict[str, str],
                                       files: list[FileObj],
@@ -83,7 +82,7 @@ class AppRunner:
 
         return rest_tokens
 
-    def recale_llm_max_tokens(self, model_config: EasyUIBasedModelConfigEntity,
+    def recale_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
@@ -119,7 +118,7 @@ class AppRunner:
                     model_config.parameters[parameter_rule.name] = max_tokens
 
     def organize_prompt_messages(self, app_record: App,
-                                 model_config: EasyUIBasedModelConfigEntity,
+                                 model_config: ModelConfigWithCredentialsEntity,
                                  prompt_template_entity: PromptTemplateEntity,
                                  inputs: dict[str, str],
                                  files: list[FileObj],
@@ -292,7 +291,7 @@ class AppRunner:
 
     def moderation_for_inputs(self, app_id: str,
                               tenant_id: str,
-                              app_generate_entity: EasyUIBasedAppGenerateEntity,
+                              app_generate_entity: AppGenerateEntity,
                               inputs: dict,
                               query: str) -> tuple[bool, dict, str]:
         """

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

@@ -15,7 +15,7 @@ from core.app.app_config.features.suggested_questions_after_answer.manager impor
     SuggestedQuestionsAfterAnswerConfigManager,
 )
 from core.app.app_config.features.text_to_speech.manager import TextToSpeechConfigManager
-from models.model import App, AppMode, AppModelConfig
+from models.model import App, AppMode, AppModelConfig, Conversation
 
 
 class ChatAppConfig(EasyUIBasedAppConfig):
@@ -27,19 +27,30 @@ class ChatAppConfig(EasyUIBasedAppConfig):
 
 class ChatAppConfigManager(BaseAppConfigManager):
     @classmethod
-    def config_convert(cls, app_model: App,
-                       config_from: EasyUIBasedAppModelConfigFrom,
+    def get_app_config(cls, app_model: App,
                        app_model_config: AppModelConfig,
-                       config_dict: Optional[dict] = None) -> ChatAppConfig:
+                       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 config_from: app model config from
         :param app_model_config: app model config
-        :param config_dict: app model config dict
+        :param conversation: conversation
+        :param override_config_dict: app model config dict
         :return:
         """
-        config_dict = cls.convert_to_config_dict(config_from, app_model_config, config_dict)
+        if override_config_dict:
+            config_from = EasyUIBasedAppModelConfigFrom.ARGS
+        elif conversation:
+            config_from = EasyUIBasedAppModelConfigFrom.CONVERSATION_SPECIFIC_CONFIG
+        else:
+            config_from = EasyUIBasedAppModelConfigFrom.APP_LATEST_CONFIG
+
+        if override_config_dict != 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_config = ChatAppConfig(
             tenant_id=app_model.tenant_id,

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

@@ -0,0 +1,194 @@
+import logging
+import threading
+import uuid
+from typing import Union, Any, Generator
+
+from flask import current_app, Flask
+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.app_queue_manager import ConversationTaskStoppedException, PublishFrom, AppQueueManager
+from core.app.apps.chat.app_config_manager import ChatAppConfigManager
+from core.app.apps.chat.app_runner import ChatAppRunner
+from core.app.apps.message_based_app_generator import MessageBasedAppGenerator
+from core.app.entities.app_invoke_entities import InvokeFrom, ChatAppGenerateEntity
+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]:
+        """
+        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_upload_entity = FileUploadConfigManager.convert(override_model_config_dict or app_model_config.to_dict())
+        if file_upload_entity:
+            file_objs = message_file_parser.validate_and_transform_files_arg(
+                files,
+                file_upload_entity,
+                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 = AppQueueManager(
+            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
+        return self._handle_response(
+            application_generate_entity=application_generate_entity,
+            queue_manager=queue_manager,
+            conversation=conversation,
+            message=message,
+            stream=stream
+        )
+
+    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 ConversationTaskStoppedException:
+                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()

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

@@ -5,7 +5,7 @@ from core.app.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 (
-    EasyUIBasedAppGenerateEntity,
+    ChatAppGenerateEntity,
 )
 from core.callback_handler.index_tool_callback_handler import DatasetIndexToolCallbackHandler
 from core.memory.token_buffer_memory import TokenBufferMemory
@@ -23,7 +23,7 @@ class ChatAppRunner(AppRunner):
     Chat Application Runner
     """
 
-    def run(self, application_generate_entity: EasyUIBasedAppGenerateEntity,
+    def run(self, application_generate_entity: ChatAppGenerateEntity,
             queue_manager: AppQueueManager,
             conversation: Conversation,
             message: Message) -> None:

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

@@ -10,7 +10,7 @@ from core.app.app_config.entities import EasyUIBasedAppConfig, EasyUIBasedAppMod
 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
+from models.model import App, AppMode, AppModelConfig, Conversation
 
 
 class CompletionAppConfig(EasyUIBasedAppConfig):
@@ -22,19 +22,26 @@ class CompletionAppConfig(EasyUIBasedAppConfig):
 
 class CompletionAppConfigManager(BaseAppConfigManager):
     @classmethod
-    def config_convert(cls, app_model: App,
-                       config_from: EasyUIBasedAppModelConfigFrom,
+    def get_app_config(cls, app_model: App,
                        app_model_config: AppModelConfig,
-                       config_dict: Optional[dict] = None) -> CompletionAppConfig:
+                       override_config_dict: Optional[dict] = None) -> CompletionAppConfig:
         """
         Convert app model config to completion app config
         :param app_model: app model
-        :param config_from: app model config from
         :param app_model_config: app model config
-        :param config_dict: app model config dict
+        :param override_config_dict: app model config dict
         :return:
         """
-        config_dict = cls.convert_to_config_dict(config_from, app_model_config, config_dict)
+        if override_config_dict:
+            config_from = EasyUIBasedAppModelConfigFrom.ARGS
+        else:
+            config_from = EasyUIBasedAppModelConfigFrom.APP_LATEST_CONFIG
+
+        if override_config_dict != 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_config = CompletionAppConfig(
             tenant_id=app_model.tenant_id,

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

@@ -0,0 +1,292 @@
+import json
+import logging
+import threading
+import uuid
+from typing import Union, Any, Generator
+
+from flask import current_app, Flask
+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.app_queue_manager import ConversationTaskStoppedException, PublishFrom, AppQueueManager
+from core.app.apps.completion.app_config_manager import CompletionAppConfigManager
+from core.app.apps.completion.app_runner import CompletionAppRunner
+from core.app.apps.message_based_app_generator import MessageBasedAppGenerator
+from core.app.entities.app_invoke_entities import InvokeFrom, CompletionAppGenerateEntity
+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]:
+        """
+        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_upload_entity = FileUploadConfigManager.convert(override_model_config_dict or app_model_config.to_dict())
+        if file_upload_entity:
+            file_objs = message_file_parser.validate_and_transform_files_arg(
+                files,
+                file_upload_entity,
+                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 = AppQueueManager(
+            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
+        return self._handle_response(
+            application_generate_entity=application_generate_entity,
+            queue_manager=queue_manager,
+            conversation=conversation,
+            message=message,
+            stream=stream
+        )
+
+    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 ConversationTaskStoppedException:
+                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 generate_more_like_this(self, app_model: App,
+                                message_id: str,
+                                user: Union[Account, EndUser],
+                                invoke_from: InvokeFrom,
+                                stream: bool = True) \
+            -> Union[dict, Generator]:
+        """
+        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_upload_entity = FileUploadConfigManager.convert(override_model_config_dict or app_model_config.to_dict())
+        if file_upload_entity:
+            file_objs = message_file_parser.validate_and_transform_files_arg(
+                message.files,
+                file_upload_entity,
+                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 = AppQueueManager(
+            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
+        return self._handle_response(
+            application_generate_entity=application_generate_entity,
+            queue_manager=queue_manager,
+            conversation=conversation,
+            message=message,
+            stream=stream
+        )

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

@@ -5,7 +5,7 @@ from core.app.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 (
-    EasyUIBasedAppGenerateEntity,
+    CompletionAppGenerateEntity,
 )
 from core.callback_handler.index_tool_callback_handler import DatasetIndexToolCallbackHandler
 from core.model_manager import ModelInstance
@@ -22,7 +22,7 @@ class CompletionAppRunner(AppRunner):
     Completion Application Runner
     """
 
-    def run(self, application_generate_entity: EasyUIBasedAppGenerateEntity,
+    def run(self, application_generate_entity: CompletionAppGenerateEntity,
             queue_manager: AppQueueManager,
             message: Message) -> None:
         """

api/core/app/apps/message_based_app_generator.py

@@ -0,0 +1,251 @@
+import json
+import logging
+from typing import Union, Generator, Optional
+
+from sqlalchemy import and_
+
+from core.app.app_config.entities import EasyUIBasedAppModelConfigFrom
+from core.app.app_queue_manager import ConversationTaskStoppedException, AppQueueManager
+from core.app.apps.base_app_generator import BaseAppGenerator
+from core.app.entities.app_invoke_entities import InvokeFrom, ChatAppGenerateEntity, AppGenerateEntity, \
+    CompletionAppGenerateEntity, AgentChatAppGenerateEntity, AdvancedChatAppGenerateEntity
+from core.app.generate_task_pipeline import GenerateTaskPipeline
+from core.prompt.utils.prompt_template_parser import PromptTemplateParser
+from extensions.ext_database import db
+from models.account import Account
+from models.model import Conversation, Message, AppMode, MessageFile, App, EndUser, AppModelConfig
+from services.errors.app_model_config import AppModelConfigBrokenError
+from services.errors.conversation import ConversationNotExistsError, ConversationCompletedError
+
+logger = logging.getLogger(__name__)
+
+
+class MessageBasedAppGenerator(BaseAppGenerator):
+
+    def _handle_response(self, application_generate_entity: Union[
+                                   ChatAppGenerateEntity,
+                                   CompletionAppGenerateEntity,
+                                   AgentChatAppGenerateEntity
+                               ],
+                         queue_manager: AppQueueManager,
+                         conversation: Conversation,
+                         message: Message,
+                         stream: bool = False) -> Union[dict, Generator]:
+        """
+        Handle response.
+        :param application_generate_entity: application generate entity
+        :param queue_manager: queue manager
+        :param conversation: conversation
+        :param message: message
+        :param stream: is stream
+        :return:
+        """
+        # init generate task pipeline
+        generate_task_pipeline = GenerateTaskPipeline(
+            application_generate_entity=application_generate_entity,
+            queue_manager=queue_manager,
+            conversation=conversation,
+            message=message
+        )
+
+        try:
+            return generate_task_pipeline.process(stream=stream)
+        except ValueError as e:
+            if e.args[0] == "I/O operation on closed file.":  # ignore this error
+                raise ConversationTaskStoppedException()
+            else:
+                logger.exception(e)
+                raise e
+        finally:
+            db.session.remove()
+
+    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
+                               ],
+                               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
+
+        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_config.app_model_config_id,
+                model_provider=application_generate_entity.model_config.provider,
+                model_id=application_generate_entity.model_config.model,
+                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',
+                from_source=from_source,
+                from_end_user_id=end_user_id,
+                from_account_id=account_id,
+            )
+
+            db.session.add(conversation)
+            db.session.commit()
+
+        message = Message(
+            app_id=app_config.app_id,
+            model_provider=application_generate_entity.model_config.provider,
+            model_id=application_generate_entity.model_config.model,
+            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',
+            from_source=from_source,
+            from_end_user_id=end_user_id,
+            from_account_id=account_id
+        )
+
+        db.session.add(message)
+        db.session.commit()
+
+        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.upload_file_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/workflow/app_config_manager.py

@@ -17,7 +17,7 @@ class WorkflowAppConfig(WorkflowUIBasedAppConfig):
 
 class WorkflowAppConfigManager(BaseAppConfigManager):
     @classmethod
-    def config_convert(cls, app_model: App, workflow: Workflow) -> WorkflowAppConfig:
+    def get_app_config(cls, app_model: App, workflow: Workflow) -> WorkflowAppConfig:
         features_dict = workflow.features_dict
 
         app_config = WorkflowAppConfig(