Merge branch 'feat/workflow-backend' into deploy/dev

api/.env.example

@@ -135,4 +135,4 @@ BATCH_UPLOAD_LIMIT=10
 
 # CODE EXECUTION CONFIGURATION
 CODE_EXECUTION_ENDPOINT=
-CODE_EXECUTINO_API_KEY=
+CODE_EXECUTION_API_KEY=

api/core/app/apps/base_app_runner.py

@@ -23,7 +23,8 @@
 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.simple_prompt_transform import SimplePromptTransform
+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
 
 
@@ -155,13 +156,39 @@ def organize_prompt_messages(self, app_record: App,
                 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
+                )
+
+                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_entity=prompt_template_entity,
+                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
             )

api/core/app/apps/easy_ui_based_generate_task_pipeline.py

@@ -30,17 +30,12 @@
 from core.model_runtime.entities.llm_entities import LLMResult, LLMResultChunk, LLMResultChunkDelta, LLMUsage
 from core.model_runtime.entities.message_entities import (
     AssistantPromptMessage,
-    ImagePromptMessageContent,
-    PromptMessage,
-    PromptMessageContentType,
-    PromptMessageRole,
-    TextPromptMessageContent,
 )
 from core.model_runtime.errors.invoke import InvokeAuthorizationError, InvokeError
 from core.model_runtime.model_providers.__base.large_language_model import LargeLanguageModel
 from core.model_runtime.utils.encoders import jsonable_encoder
 from core.moderation.output_moderation import ModerationRule, OutputModeration
-from core.prompt.simple_prompt_transform import ModelMode
+from core.prompt.utils.prompt_message_util import PromptMessageUtil
 from core.prompt.utils.prompt_template_parser import PromptTemplateParser
 from core.tools.tool_file_manager import ToolFileManager
 from events.message_event import message_was_created
@@ -438,7 +433,10 @@ def _save_message(self, llm_result: LLMResult) -> None:
         self._message = db.session.query(Message).filter(Message.id == self._message.id).first()
         self._conversation = db.session.query(Conversation).filter(Conversation.id == self._conversation.id).first()
 
-        self._message.message = self._prompt_messages_to_prompt_for_saving(self._task_state.llm_result.prompt_messages)
+        self._message.message = PromptMessageUtil.prompt_messages_to_prompt_for_saving(
+            self._model_config.mode,
+            self._task_state.llm_result.prompt_messages
+        )
         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
@@ -582,77 +580,6 @@ def _yield_response(self, response: dict) -> str:
         """
         return "data: " + json.dumps(response) + "\n\n"
 
-    def _prompt_messages_to_prompt_for_saving(self, prompt_messages: list[PromptMessage]) -> list[dict]:
-        """
-        Prompt messages to prompt for saving.
-        :param prompt_messages: prompt messages
-        :return:
-        """
-        prompts = []
-        if self._model_config.mode == ModelMode.CHAT.value:
-            for prompt_message in prompt_messages:
-                if prompt_message.role == PromptMessageRole.USER:
-                    role = 'user'
-                elif prompt_message.role == PromptMessageRole.ASSISTANT:
-                    role = 'assistant'
-                elif prompt_message.role == PromptMessageRole.SYSTEM:
-                    role = 'system'
-                else:
-                    continue
-
-                text = ''
-                files = []
-                if isinstance(prompt_message.content, list):
-                    for content in prompt_message.content:
-                        if content.type == PromptMessageContentType.TEXT:
-                            content = cast(TextPromptMessageContent, content)
-                            text += content.data
-                        else:
-                            content = cast(ImagePromptMessageContent, content)
-                            files.append({
-                                "type": 'image',
-                                "data": content.data[:10] + '...[TRUNCATED]...' + content.data[-10:],
-                                "detail": content.detail.value
-                            })
-                else:
-                    text = prompt_message.content
-
-                prompts.append({
-                    "role": role,
-                    "text": text,
-                    "files": files
-                })
-        else:
-            prompt_message = prompt_messages[0]
-            text = ''
-            files = []
-            if isinstance(prompt_message.content, list):
-                for content in prompt_message.content:
-                    if content.type == PromptMessageContentType.TEXT:
-                        content = cast(TextPromptMessageContent, content)
-                        text += content.data
-                    else:
-                        content = cast(ImagePromptMessageContent, content)
-                        files.append({
-                            "type": 'image',
-                            "data": content.data[:10] + '...[TRUNCATED]...' + content.data[-10:],
-                            "detail": content.detail.value
-                        })
-            else:
-                text = prompt_message.content
-
-            params = {
-                "role": 'user',
-                "text": text,
-            }
-
-            if files:
-                params['files'] = files
-
-            prompts.append(params)
-
-        return prompts
-
     def _init_output_moderation(self) -> Optional[OutputModeration]:
         """
         Init output moderation.

api/core/helper/code_executor/code_executor.py

@@ -5,6 +5,7 @@
 from pydantic import BaseModel
 from yarl import URL
 
+from core.helper.code_executor.javascript_transformer import NodeJsTemplateTransformer
 from core.helper.code_executor.jina2_transformer import Jinja2TemplateTransformer
 from core.helper.code_executor.python_transformer import PythonTemplateTransformer
 
@@ -39,17 +40,20 @@ def execute_code(cls, language: Literal['python3', 'javascript', 'jinja2'], code
             template_transformer = PythonTemplateTransformer
         elif language == 'jinja2':
             template_transformer = Jinja2TemplateTransformer
+        elif language == 'javascript':
+            template_transformer = NodeJsTemplateTransformer
         else:
             raise CodeExecutionException('Unsupported language')
 
         runner = template_transformer.transform_caller(code, inputs)
-
         url = URL(CODE_EXECUTION_ENDPOINT) / 'v1' / 'sandbox' / 'run'
         headers = {
             'X-Api-Key': CODE_EXECUTION_API_KEY
         }
         data = {
-            'language': language if language != 'jinja2' else 'python3',
+            'language': 'python3' if language == 'jinja2' else
+                        'nodejs' if language == 'javascript' else
+                        'python3' if language == 'python3' else None,
             'code': runner,
         }
 

api/core/helper/code_executor/javascript_transformer.py

@@ -1 +1,53 @@
-# TODO
+import json
+import re
+
+from core.helper.code_executor.template_transformer import TemplateTransformer
+
+NODEJS_RUNNER = """// declare main function here
+{{code}}
+
+// execute main function, and return the result
+// inputs is a dict, unstructured inputs
+output = main({{inputs}})
+
+// convert output to json and print
+output = JSON.stringify(output)
+
+result = `<<RESULT>>${output}<<RESULT>>`
+
+console.log(result)
+"""
+
+
+class NodeJsTemplateTransformer(TemplateTransformer):
+    @classmethod
+    def transform_caller(cls, code: str, inputs: dict) -> str:
+        """
+        Transform code to python runner
+        :param code: code
+        :param inputs: inputs
+        :return:
+        """
+
+        # transform inputs to json string
+        inputs_str = json.dumps(inputs, indent=4)
+
+        # replace code and inputs
+        runner = NODEJS_RUNNER.replace('{{code}}', code)
+        runner = runner.replace('{{inputs}}', inputs_str)
+
+        return runner
+
+    @classmethod
+    def transform_response(cls, response: str) -> dict:
+        """
+        Transform response to dict
+        :param response: response
+        :return:
+        """
+        # extract result
+        result = re.search(r'<<RESULT>>(.*)<<RESULT>>', response, re.DOTALL)
+        if not result:
+            raise ValueError('Failed to parse result')
+        result = result.group(1)
+        return json.loads(result)

api/core/model_manager.py

@@ -24,11 +24,11 @@ class ModelInstance:
     """
 
     def __init__(self, provider_model_bundle: ProviderModelBundle, model: str) -> None:
-        self._provider_model_bundle = provider_model_bundle
+        self.provider_model_bundle = provider_model_bundle
         self.model = model
         self.provider = provider_model_bundle.configuration.provider.provider
         self.credentials = self._fetch_credentials_from_bundle(provider_model_bundle, model)
-        self.model_type_instance = self._provider_model_bundle.model_type_instance
+        self.model_type_instance = self.provider_model_bundle.model_type_instance
 
     def _fetch_credentials_from_bundle(self, provider_model_bundle: ProviderModelBundle, model: str) -> dict:
         """