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/workflow/callbacks/base_workflow_callback.py

@@ -0,0 +1,80 @@
+from abc import ABC, abstractmethod
+from typing import Optional
+
+from core.app.entities.queue_entities import AppQueueEvent
+from core.workflow.entities.base_node_data_entities import BaseNodeData
+from core.workflow.entities.node_entities import NodeType
+
+
+class BaseWorkflowCallback(ABC):
+    @abstractmethod
+    def on_workflow_run_started(self) -> None:
+        """
+        Workflow run started
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def on_workflow_run_succeeded(self) -> None:
+        """
+        Workflow run succeeded
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def on_workflow_run_failed(self, error: str) -> None:
+        """
+        Workflow run failed
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    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
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    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
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    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
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def on_node_text_chunk(self, node_id: str, text: str, metadata: Optional[dict] = None) -> None:
+        """
+        Publish text chunk
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def on_event(self, event: AppQueueEvent) -> None:
+        """
+        Publish event
+        """
+        raise NotImplementedError

api/core/workflow/entities/base_node_data_entities.py

@@ -0,0 +1,9 @@
+from abc import ABC
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class BaseNodeData(ABC, BaseModel):
+    title: str
+    desc: Optional[str] = None

api/core/workflow/entities/node_entities.py

@@ -0,0 +1,85 @@
+from enum import Enum
+from typing import Any, Optional
+
+from pydantic import BaseModel
+
+from models.workflow import WorkflowNodeExecutionStatus
+
+
+class NodeType(Enum):
+    """
+    Node Types.
+    """
+    START = 'start'
+    END = 'end'
+    ANSWER = 'answer'
+    LLM = 'llm'
+    KNOWLEDGE_RETRIEVAL = 'knowledge-retrieval'
+    IF_ELSE = 'if-else'
+    CODE = 'code'
+    TEMPLATE_TRANSFORM = 'template-transform'
+    QUESTION_CLASSIFIER = 'question-classifier'
+    HTTP_REQUEST = 'http-request'
+    TOOL = 'tool'
+    VARIABLE_ASSIGNER = 'variable-assigner'
+
+    @classmethod
+    def value_of(cls, value: str) -> 'NodeType':
+        """
+        Get value of given node type.
+
+        :param value: node type value
+        :return: node type
+        """
+        for node_type in cls:
+            if node_type.value == value:
+                return node_type
+        raise ValueError(f'invalid node type value {value}')
+
+
+class SystemVariable(Enum):
+    """
+    System Variables.
+    """
+    QUERY = 'query'
+    FILES = 'files'
+    CONVERSATION = 'conversation'
+
+    @classmethod
+    def value_of(cls, value: str) -> 'SystemVariable':
+        """
+        Get value of given system variable.
+
+        :param value: system variable value
+        :return: system variable
+        """
+        for system_variable in cls:
+            if system_variable.value == value:
+                return system_variable
+        raise ValueError(f'invalid system variable value {value}')
+
+
+class NodeRunMetadataKey(Enum):
+    """
+    Node Run Metadata Key.
+    """
+    TOTAL_TOKENS = 'total_tokens'
+    TOTAL_PRICE = 'total_price'
+    CURRENCY = 'currency'
+    TOOL_INFO = 'tool_info'
+
+
+class NodeRunResult(BaseModel):
+    """
+    Node Run Result.
+    """
+    status: WorkflowNodeExecutionStatus = WorkflowNodeExecutionStatus.RUNNING
+
+    inputs: Optional[dict] = None  # node inputs
+    process_data: Optional[dict] = None  # process data
+    outputs: Optional[dict] = None  # node outputs
+    metadata: Optional[dict[NodeRunMetadataKey, Any]] = None  # node metadata
+
+    edge_source_handle: Optional[str] = None  # source handle id of node with multiple branches
+
+    error: Optional[str] = None  # error message if status is failed

api/core/workflow/entities/variable_entities.py

@@ -0,0 +1,9 @@
+from pydantic import BaseModel
+
+
+class VariableSelector(BaseModel):
+    """
+    Variable Selector.
+    """
+    variable: str
+    value_selector: list[str]

api/core/workflow/entities/variable_pool.py

@@ -0,0 +1,94 @@
+from enum import Enum
+from typing import Any, Optional, Union
+
+from core.file.file_obj import FileVar
+from core.workflow.entities.node_entities import SystemVariable
+
+VariableValue = Union[str, int, float, dict, list, FileVar]
+
+
+class ValueType(Enum):
+    """
+    Value Type Enum
+    """
+    STRING = "string"
+    NUMBER = "number"
+    OBJECT = "object"
+    ARRAY_STRING = "array[string]"
+    ARRAY_NUMBER = "array[number]"
+    ARRAY_OBJECT = "array[object]"
+    ARRAY_FILE = "array[file]"
+    FILE = "file"
+
+
+class VariablePool:
+    variables_mapping = {}
+    user_inputs: dict
+    system_variables: dict[SystemVariable, Any]
+
+    def __init__(self, system_variables: dict[SystemVariable, Any],
+                 user_inputs: dict) -> None:
+        # system variables
+        # for example:
+        # {
+        #     'query': 'abc',
+        #     'files': []
+        # }
+        self.user_inputs = user_inputs
+        self.system_variables = system_variables
+        for system_variable, value in system_variables.items():
+            self.append_variable('sys', [system_variable.value], value)
+
+    def append_variable(self, node_id: str, variable_key_list: list[str], value: VariableValue) -> None:
+        """
+        Append variable
+        :param node_id: node id
+        :param variable_key_list: variable key list, like: ['result', 'text']
+        :param value: value
+        :return:
+        """
+        if node_id not in self.variables_mapping:
+            self.variables_mapping[node_id] = {}
+
+        variable_key_list_hash = hash(tuple(variable_key_list))
+
+        self.variables_mapping[node_id][variable_key_list_hash] = value
+
+    def get_variable_value(self, variable_selector: list[str],
+                           target_value_type: Optional[ValueType] = None) -> Optional[VariableValue]:
+        """
+        Get variable
+        :param variable_selector: include node_id and variables
+        :param target_value_type: target value type
+        :return:
+        """
+        if len(variable_selector) < 2:
+            raise ValueError('Invalid value selector')
+
+        node_id = variable_selector[0]
+        if node_id not in self.variables_mapping:
+            return None
+
+        # fetch variable keys, pop node_id
+        variable_key_list = variable_selector[1:]
+
+        variable_key_list_hash = hash(tuple(variable_key_list))
+
+        value = self.variables_mapping[node_id].get(variable_key_list_hash)
+
+        if target_value_type:
+            if target_value_type == ValueType.STRING:
+                return str(value)
+            elif target_value_type == ValueType.NUMBER:
+                return int(value)
+            elif target_value_type == ValueType.OBJECT:
+                if not isinstance(value, dict):
+                    raise ValueError('Invalid value type: object')
+            elif target_value_type in [ValueType.ARRAY_STRING,
+                                       ValueType.ARRAY_NUMBER,
+                                       ValueType.ARRAY_OBJECT,
+                                       ValueType.ARRAY_FILE]:
+                if not isinstance(value, list):
+                    raise ValueError(f'Invalid value type: {target_value_type.value}')
+
+        return value

api/core/workflow/entities/workflow_entities.py

@@ -0,0 +1,49 @@
+from typing import Optional
+
+from core.workflow.entities.node_entities import NodeRunResult
+from core.workflow.entities.variable_pool import VariablePool
+from core.workflow.nodes.base_node import BaseNode, UserFrom
+from models.workflow import Workflow, WorkflowType
+
+
+class WorkflowNodeAndResult:
+    node: BaseNode
+    result: Optional[NodeRunResult] = None
+
+    def __init__(self, node: BaseNode, result: Optional[NodeRunResult] = None):
+        self.node = node
+        self.result = result
+
+
+class WorkflowRunState:
+    tenant_id: str
+    app_id: str
+    workflow_id: str
+    workflow_type: WorkflowType
+    user_id: str
+    user_from: UserFrom
+
+    start_at: float
+    variable_pool: VariablePool
+
+    total_tokens: int = 0
+
+    workflow_nodes_and_results: list[WorkflowNodeAndResult]
+
+    def __init__(self, workflow: Workflow,
+                 start_at: float,
+                 variable_pool: VariablePool,
+                 user_id: str,
+                 user_from: UserFrom):
+        self.workflow_id = workflow.id
+        self.tenant_id = workflow.tenant_id
+        self.app_id = workflow.app_id
+        self.workflow_type = WorkflowType.value_of(workflow.type)
+        self.user_id = user_id
+        self.user_from = user_from
+
+        self.start_at = start_at
+        self.variable_pool = variable_pool
+
+        self.total_tokens = 0
+        self.workflow_nodes_and_results = []

api/core/workflow/errors.py

@@ -0,0 +1,10 @@
+from core.workflow.entities.node_entities import NodeType
+
+
+class WorkflowNodeRunFailedError(Exception):
+    def __init__(self, node_id: str, node_type: NodeType, node_title: str, error: str):
+        self.node_id = node_id
+        self.node_type = node_type
+        self.node_title = node_title
+        self.error = error
+        super().__init__(f"Node {node_title} run failed: {error}")

api/core/workflow/nodes/answer/answer_node.py

@@ -0,0 +1,155 @@
+import json
+from typing import cast
+
+from core.file.file_obj import FileVar
+from core.prompt.utils.prompt_template_parser import PromptTemplateParser
+from core.workflow.entities.base_node_data_entities import BaseNodeData
+from core.workflow.entities.node_entities import NodeRunResult, NodeType
+from core.workflow.entities.variable_pool import VariablePool
+from core.workflow.nodes.answer.entities import (
+    AnswerNodeData,
+    GenerateRouteChunk,
+    TextGenerateRouteChunk,
+    VarGenerateRouteChunk,
+)
+from core.workflow.nodes.base_node import BaseNode
+from core.workflow.utils.variable_template_parser import VariableTemplateParser
+from models.workflow import WorkflowNodeExecutionStatus
+
+
+class AnswerNode(BaseNode):
+    _node_data_cls = AnswerNodeData
+    node_type = NodeType.ANSWER
+
+    def _run(self, variable_pool: VariablePool) -> NodeRunResult:
+        """
+        Run node
+        :param variable_pool: variable pool
+        :return:
+        """
+        node_data = self.node_data
+        node_data = cast(self._node_data_cls, node_data)
+
+        # generate routes
+        generate_routes = self.extract_generate_route_from_node_data(node_data)
+
+        answer = ''
+        for part in generate_routes:
+            if part.type == "var":
+                part = cast(VarGenerateRouteChunk, part)
+                value_selector = part.value_selector
+                value = variable_pool.get_variable_value(
+                    variable_selector=value_selector
+                )
+
+                text = ''
+                if isinstance(value, str | int | float):
+                    text = str(value)
+                elif isinstance(value, dict):
+                    # other types
+                    text = json.dumps(value, ensure_ascii=False)
+                elif isinstance(value, FileVar):
+                    # convert file to markdown
+                    text = value.to_markdown()
+                elif isinstance(value, list):
+                    for item in value:
+                        if isinstance(item, FileVar):
+                            text += item.to_markdown() + ' '
+
+                    text = text.strip()
+
+                    if not text and value:
+                        # other types
+                        text = json.dumps(value, ensure_ascii=False)
+
+                answer += text
+            else:
+                part = cast(TextGenerateRouteChunk, part)
+                answer += part.text
+
+        return NodeRunResult(
+            status=WorkflowNodeExecutionStatus.SUCCEEDED,
+            outputs={
+                "answer": answer
+            }
+        )
+
+    @classmethod
+    def extract_generate_route_selectors(cls, config: dict) -> list[GenerateRouteChunk]:
+        """
+        Extract generate route selectors
+        :param config: node config
+        :return:
+        """
+        node_data = cls._node_data_cls(**config.get("data", {}))
+        node_data = cast(cls._node_data_cls, node_data)
+
+        return cls.extract_generate_route_from_node_data(node_data)
+
+    @classmethod
+    def extract_generate_route_from_node_data(cls, node_data: AnswerNodeData) -> list[GenerateRouteChunk]:
+        """
+        Extract generate route from node data
+        :param node_data: node data object
+        :return:
+        """
+        variable_template_parser = VariableTemplateParser(template=node_data.answer)
+        variable_selectors = variable_template_parser.extract_variable_selectors()
+
+        value_selector_mapping = {
+            variable_selector.variable: variable_selector.value_selector
+            for variable_selector in variable_selectors
+        }
+
+        variable_keys = list(value_selector_mapping.keys())
+
+        # format answer template
+        template_parser = PromptTemplateParser(template=node_data.answer, with_variable_tmpl=True)
+        template_variable_keys = template_parser.variable_keys
+
+        # Take the intersection of variable_keys and template_variable_keys
+        variable_keys = list(set(variable_keys) & set(template_variable_keys))
+
+        template = node_data.answer
+        for var in variable_keys:
+            template = template.replace(f'{{{{{var}}}}}', f'Ω{{{{{var}}}}}Ω')
+
+        generate_routes = []
+        for part in template.split('Ω'):
+            if part:
+                if cls._is_variable(part, variable_keys):
+                    var_key = part.replace('Ω', '').replace('{{', '').replace('}}', '')
+                    value_selector = value_selector_mapping[var_key]
+                    generate_routes.append(VarGenerateRouteChunk(
+                        value_selector=value_selector
+                    ))
+                else:
+                    generate_routes.append(TextGenerateRouteChunk(
+                        text=part
+                    ))
+
+        return generate_routes
+
+    @classmethod
+    def _is_variable(cls, part, variable_keys):
+        cleaned_part = part.replace('{{', '').replace('}}', '')
+        return part.startswith('{{') and cleaned_part in variable_keys
+
+    @classmethod
+    def _extract_variable_selector_to_variable_mapping(cls, node_data: BaseNodeData) -> dict[str, list[str]]:
+        """
+        Extract variable selector to variable mapping
+        :param node_data: node data
+        :return:
+        """
+        node_data = node_data
+        node_data = cast(cls._node_data_cls, node_data)
+
+        variable_template_parser = VariableTemplateParser(template=node_data.answer)
+        variable_selectors = variable_template_parser.extract_variable_selectors()
+
+        variable_mapping = {}
+        for variable_selector in variable_selectors:
+            variable_mapping[variable_selector.variable] = variable_selector.value_selector
+
+        return variable_mapping

api/core/workflow/nodes/answer/entities.py

@@ -0,0 +1,34 @@
+
+from pydantic import BaseModel
+
+from core.workflow.entities.base_node_data_entities import BaseNodeData
+
+
+class AnswerNodeData(BaseNodeData):
+    """
+    Answer Node Data.
+    """
+    answer: str
+
+
+class GenerateRouteChunk(BaseModel):
+    """
+    Generate Route Chunk.
+    """
+    type: str
+
+
+class VarGenerateRouteChunk(GenerateRouteChunk):
+    """
+    Var Generate Route Chunk.
+    """
+    type: str = "var"
+    value_selector: list[str]
+
+
+class TextGenerateRouteChunk(GenerateRouteChunk):
+    """
+    Text Generate Route Chunk.
+    """
+    type: str = "text"
+    text: str

api/core/workflow/nodes/base_node.py

@@ -0,0 +1,142 @@
+from abc import ABC, abstractmethod
+from enum import Enum
+from typing import Optional
+
+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 NodeRunResult, NodeType
+from core.workflow.entities.variable_pool import VariablePool
+
+
+class UserFrom(Enum):
+    """
+    User from
+    """
+    ACCOUNT = "account"
+    END_USER = "end-user"
+
+    @classmethod
+    def value_of(cls, value: str) -> "UserFrom":
+        """
+        Value of
+        :param value: value
+        :return:
+        """
+        for item in cls:
+            if item.value == value:
+                return item
+        raise ValueError(f"Invalid value: {value}")
+
+
+class BaseNode(ABC):
+    _node_data_cls: type[BaseNodeData]
+    _node_type: NodeType
+
+    tenant_id: str
+    app_id: str
+    workflow_id: str
+    user_id: str
+    user_from: UserFrom
+
+    node_id: str
+    node_data: BaseNodeData
+    node_run_result: Optional[NodeRunResult] = None
+
+    callbacks: list[BaseWorkflowCallback]
+
+    def __init__(self, tenant_id: str,
+                 app_id: str,
+                 workflow_id: str,
+                 user_id: str,
+                 user_from: UserFrom,
+                 config: dict,
+                 callbacks: list[BaseWorkflowCallback] = None) -> None:
+        self.tenant_id = tenant_id
+        self.app_id = app_id
+        self.workflow_id = workflow_id
+        self.user_id = user_id
+        self.user_from = user_from
+
+        self.node_id = config.get("id")
+        if not self.node_id:
+            raise ValueError("Node ID is required.")
+
+        self.node_data = self._node_data_cls(**config.get("data", {}))
+        self.callbacks = callbacks or []
+
+    @abstractmethod
+    def _run(self, variable_pool: VariablePool) -> NodeRunResult:
+        """
+        Run node
+        :param variable_pool: variable pool
+        :return:
+        """
+        raise NotImplementedError
+
+    def run(self, variable_pool: VariablePool) -> NodeRunResult:
+        """
+        Run node entry
+        :param variable_pool: variable pool
+        :return:
+        """
+        result = self._run(
+            variable_pool=variable_pool
+        )
+
+        self.node_run_result = result
+        return result
+
+    def publish_text_chunk(self, text: str, value_selector: list[str] = None) -> None:
+        """
+        Publish text chunk
+        :param text: chunk text
+        :param value_selector: value selector
+        :return:
+        """
+        if self.callbacks:
+            for callback in self.callbacks:
+                callback.on_node_text_chunk(
+                    node_id=self.node_id,
+                    text=text,
+                    metadata={
+                        "node_type": self.node_type,
+                        "value_selector": value_selector
+                    }
+                )
+
+    @classmethod
+    def extract_variable_selector_to_variable_mapping(cls, config: dict) -> dict[str, list[str]]:
+        """
+        Extract variable selector to variable mapping
+        :param config: node config
+        :return:
+        """
+        node_data = cls._node_data_cls(**config.get("data", {}))
+        return cls._extract_variable_selector_to_variable_mapping(node_data)
+
+    @classmethod
+    @abstractmethod
+    def _extract_variable_selector_to_variable_mapping(cls, node_data: BaseNodeData) -> dict[str, list[str]]:
+        """
+        Extract variable selector to variable mapping
+        :param node_data: node data
+        :return:
+        """
+        raise NotImplementedError
+
+    @classmethod
+    def get_default_config(cls, filters: Optional[dict] = None) -> dict:
+        """
+        Get default config of node.
+        :param filters: filter by node config parameters.
+        :return:
+        """
+        return {}
+
+    @property
+    def node_type(self) -> NodeType:
+        """
+        Get node type
+        :return:
+        """
+        return self._node_type

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

@@ -0,0 +1,348 @@
+import os
+from typing import Optional, Union, cast
+
+from core.helper.code_executor.code_executor import CodeExecutionException, CodeExecutor
+from core.workflow.entities.node_entities import NodeRunResult, NodeType
+from core.workflow.entities.variable_pool import VariablePool
+from core.workflow.nodes.base_node import BaseNode
+from core.workflow.nodes.code.entities import CodeNodeData
+from models.workflow import WorkflowNodeExecutionStatus
+
+MAX_NUMBER = int(os.environ.get('CODE_MAX_NUMBER', '9223372036854775807'))
+MIN_NUMBER = int(os.environ.get('CODE_MIN_NUMBER', '-9223372036854775808'))
+MAX_PRECISION = 20
+MAX_DEPTH = 5
+MAX_STRING_LENGTH = int(os.environ.get('CODE_MAX_STRING_LENGTH', '80000'))
+MAX_STRING_ARRAY_LENGTH = int(os.environ.get('CODE_MAX_STRING_ARRAY_LENGTH', '30'))
+MAX_OBJECT_ARRAY_LENGTH = int(os.environ.get('CODE_MAX_OBJECT_ARRAY_LENGTH', '30'))
+MAX_NUMBER_ARRAY_LENGTH = int(os.environ.get('CODE_MAX_NUMBER_ARRAY_LENGTH', '1000'))
+
+JAVASCRIPT_DEFAULT_CODE = """function main({arg1, arg2}) {
+    return {
+        result: arg1 + arg2
+    }
+}"""
+
+PYTHON_DEFAULT_CODE = """def main(arg1: int, arg2: int) -> dict:
+    return {
+        "result": arg1 + arg2,
+    }"""
+
+class CodeNode(BaseNode):
+    _node_data_cls = CodeNodeData
+    node_type = NodeType.CODE
+
+    @classmethod
+    def get_default_config(cls, filters: Optional[dict] = None) -> dict:
+        """
+        Get default config of node.
+        :param filters: filter by node config parameters.
+        :return:
+        """
+        if filters and filters.get("code_language") == "javascript":
+            return {
+                "type": "code",
+                "config": {
+                    "variables": [
+                        {
+                            "variable": "arg1",
+                            "value_selector": []
+                        },
+                        {
+                            "variable": "arg2",
+                            "value_selector": []
+                        }
+                    ],
+                    "code_language": "javascript",
+                    "code": JAVASCRIPT_DEFAULT_CODE,
+                    "outputs": {
+                        "result": {
+                            "type": "string",
+                            "children": None
+                        }
+                    }
+                }
+            }
+
+        return {
+            "type": "code",
+            "config": {
+                "variables": [
+                    {
+                        "variable": "arg1",
+                        "value_selector": []
+                    },
+                    {
+                        "variable": "arg2",
+                        "value_selector": []
+                    }
+                ],
+                "code_language": "python3",
+                "code": PYTHON_DEFAULT_CODE,
+                "outputs": {
+                    "result": {
+                        "type": "string",
+                        "children": None
+                    }
+                }
+            }
+        }
+
+    def _run(self, variable_pool: VariablePool) -> NodeRunResult:
+        """
+        Run code
+        :param variable_pool: variable pool
+        :return:
+        """
+        node_data = self.node_data
+        node_data: CodeNodeData = cast(self._node_data_cls, node_data)
+
+        # Get code language
+        code_language = node_data.code_language
+        code = node_data.code
+
+        # Get variables
+        variables = {}
+        for variable_selector in node_data.variables:
+            variable = variable_selector.variable
+            value = variable_pool.get_variable_value(
+                variable_selector=variable_selector.value_selector
+            )
+
+            variables[variable] = value
+        # Run code
+        try:
+            result = CodeExecutor.execute_code(
+                language=code_language,
+                code=code,
+                inputs=variables
+            )
+
+            # Transform result
+            result = self._transform_result(result, node_data.outputs)
+        except (CodeExecutionException, ValueError) as e:
+            return NodeRunResult(
+                status=WorkflowNodeExecutionStatus.FAILED,
+                inputs=variables,
+                error=str(e)
+            )
+
+        return NodeRunResult(
+            status=WorkflowNodeExecutionStatus.SUCCEEDED,
+            inputs=variables,
+            outputs=result
+        )
+
+    def _check_string(self, value: str, variable: str) -> str:
+        """
+        Check string
+        :param value: value
+        :param variable: variable
+        :return:
+        """
+        if not isinstance(value, str):
+            raise ValueError(f"{variable} in output form must be a string")
+
+        if len(value) > MAX_STRING_LENGTH:
+            raise ValueError(f'{variable} in output form must be less than {MAX_STRING_LENGTH} characters')
+
+        return value.replace('\x00', '')
+
+    def _check_number(self, value: Union[int, float], variable: str) -> Union[int, float]:
+        """
+        Check number
+        :param value: value
+        :param variable: variable
+        :return:
+        """
+        if not isinstance(value, int | float):
+            raise ValueError(f"{variable} in output form must be a number")
+
+        if value > MAX_NUMBER or value < MIN_NUMBER:
+            raise ValueError(f'{variable} in input form is out of range.')
+
+        if isinstance(value, float):
+            # raise error if precision is too high
+            if len(str(value).split('.')[1]) > MAX_PRECISION:
+                raise ValueError(f'{variable} in output form has too high precision.')
+
+        return value
+
+    def _transform_result(self, result: dict, output_schema: Optional[dict[str, CodeNodeData.Output]],
+                          prefix: str = '',
+                          depth: int = 1) -> dict:
+        """
+        Transform result
+        :param result: result
+        :param output_schema: output schema
+        :return:
+        """
+        if depth > MAX_DEPTH:
+            raise ValueError("Depth limit reached, object too deep.")
+
+        transformed_result = {}
+        if output_schema is None:
+            # validate output thought instance type
+            for output_name, output_value in result.items():
+                if isinstance(output_value, dict):
+                    self._transform_result(
+                        result=output_value,
+                        output_schema=None,
+                        prefix=f'{prefix}.{output_name}' if prefix else output_name,
+                        depth=depth + 1
+                    )
+                elif isinstance(output_value, int | float):
+                    self._check_number(
+                        value=output_value,
+                        variable=f'{prefix}.{output_name}' if prefix else output_name
+                    )
+                elif isinstance(output_value, str):
+                    self._check_string(
+                        value=output_value,
+                        variable=f'{prefix}.{output_name}' if prefix else output_name
+                    )
+                elif isinstance(output_value, list):
+                    first_element = output_value[0] if len(output_value) > 0 else None
+                    if first_element is not None:
+                        if isinstance(first_element, int | float) and all(isinstance(value, int | float) for value in output_value):
+                            for i, value in enumerate(output_value):
+                                self._check_number(
+                                    value=value,
+                                    variable=f'{prefix}.{output_name}[{i}]' if prefix else f'{output_name}[{i}]'
+                                )
+                        elif isinstance(first_element, str) and all(isinstance(value, str) for value in output_value):
+                            for i, value in enumerate(output_value):
+                                self._check_string(
+                                    value=value,
+                                    variable=f'{prefix}.{output_name}[{i}]' if prefix else f'{output_name}[{i}]'
+                                )
+                        elif isinstance(first_element, dict) and all(isinstance(value, dict) for value in output_value):
+                            for i, value in enumerate(output_value):
+                                self._transform_result(
+                                    result=value,
+                                    output_schema=None,
+                                    prefix=f'{prefix}.{output_name}[{i}]' if prefix else f'{output_name}[{i}]',
+                                    depth=depth + 1
+                                )
+                        else:
+                            raise ValueError(f'Output {prefix}.{output_name} is not a valid array. make sure all elements are of the same type.')
+                else:
+                    raise ValueError(f'Output {prefix}.{output_name} is not a valid type.')
+                
+            return result
+
+        parameters_validated = {}
+        for output_name, output_config in output_schema.items():
+            dot = '.' if prefix else ''
+            if output_config.type == 'object':
+                # check if output is object
+                if not isinstance(result.get(output_name), dict):
+                    raise ValueError(
+                        f'Output {prefix}{dot}{output_name} is not an object, got {type(result.get(output_name))} instead.'
+                    )
+
+                transformed_result[output_name] = self._transform_result(
+                    result=result[output_name],
+                    output_schema=output_config.children,
+                    prefix=f'{prefix}.{output_name}',
+                    depth=depth + 1
+                )
+            elif output_config.type == 'number':
+                # check if number available
+                transformed_result[output_name] = self._check_number(
+                    value=result[output_name],
+                    variable=f'{prefix}{dot}{output_name}'
+                )
+            elif output_config.type == 'string':
+                # check if string available
+                transformed_result[output_name] = self._check_string(
+                    value=result[output_name],
+                    variable=f'{prefix}{dot}{output_name}',
+                )
+            elif output_config.type == 'array[number]':
+                # check if array of number available
+                if not isinstance(result[output_name], list):
+                    raise ValueError(
+                        f'Output {prefix}{dot}{output_name} is not an array, got {type(result.get(output_name))} instead.'
+                    )
+
+                if len(result[output_name]) > MAX_NUMBER_ARRAY_LENGTH:
+                    raise ValueError(
+                        f'{prefix}{dot}{output_name} in output form must be less than {MAX_NUMBER_ARRAY_LENGTH} characters.'
+                    )
+
+                transformed_result[output_name] = [
+                    self._check_number(
+                        value=value,
+                        variable=f'{prefix}{dot}{output_name}[{i}]'
+                    )
+                    for i, value in enumerate(result[output_name])
+                ]
+            elif output_config.type == 'array[string]':
+                # check if array of string available
+                if not isinstance(result[output_name], list):
+                    raise ValueError(
+                        f'Output {prefix}{dot}{output_name} is not an array, got {type(result.get(output_name))} instead.'
+                    )
+
+                if len(result[output_name]) > MAX_STRING_ARRAY_LENGTH:
+                    raise ValueError(
+                        f'{prefix}{dot}{output_name} in output form must be less than {MAX_STRING_ARRAY_LENGTH} characters.'
+                    )
+
+                transformed_result[output_name] = [
+                    self._check_string(
+                        value=value,
+                        variable=f'{prefix}{dot}{output_name}[{i}]'
+                    )
+                    for i, value in enumerate(result[output_name])
+                ]
+            elif output_config.type == 'array[object]':
+                # check if array of object available
+                if not isinstance(result[output_name], list):
+                    raise ValueError(
+                        f'Output {prefix}{dot}{output_name} is not an array, got {type(result.get(output_name))} instead.'
+                    )
+
+                if len(result[output_name]) > MAX_OBJECT_ARRAY_LENGTH:
+                    raise ValueError(
+                        f'{prefix}{dot}{output_name} in output form must be less than {MAX_OBJECT_ARRAY_LENGTH} characters.'
+                    )
+                
+                for i, value in enumerate(result[output_name]):
+                    if not isinstance(value, dict):
+                        raise ValueError(
+                            f'Output {prefix}{dot}{output_name}[{i}] is not an object, got {type(value)} instead at index {i}.'
+                        )
+
+                transformed_result[output_name] = [
+                    self._transform_result(
+                        result=value,
+                        output_schema=output_config.children,
+                        prefix=f'{prefix}{dot}{output_name}[{i}]',
+                        depth=depth + 1
+                    )
+                    for i, value in enumerate(result[output_name])
+                ]
+            else:
+                raise ValueError(f'Output type {output_config.type} is not supported.')
+            
+            parameters_validated[output_name] = True
+
+        # check if all output parameters are validated
+        if len(parameters_validated) != len(result):
+            raise ValueError('Not all output parameters are validated.')
+
+        return transformed_result
+
+    @classmethod
+    def _extract_variable_selector_to_variable_mapping(cls, node_data: CodeNodeData) -> dict[str, list[str]]:
+        """
+        Extract variable selector to variable mapping
+        :param node_data: node data
+        :return:
+        """
+
+        return {
+            variable_selector.variable: variable_selector.value_selector for variable_selector in node_data.variables
+        }

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

@@ -0,0 +1,20 @@
+from typing import Literal, Optional
+
+from pydantic import BaseModel
+
+from core.workflow.entities.base_node_data_entities import BaseNodeData
+from core.workflow.entities.variable_entities import VariableSelector
+
+
+class CodeNodeData(BaseNodeData):
+    """
+    Code Node Data.
+    """
+    class Output(BaseModel):
+        type: Literal['string', 'number', 'object', 'array[string]', 'array[number]', 'array[object]']
+        children: Optional[dict[str, 'Output']]
+
+    variables: list[VariableSelector]
+    code_language: Literal['python3', 'javascript']
+    code: str
+    outputs: dict[str, Output]

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

@@ -0,0 +1,46 @@
+from typing import cast
+
+from core.workflow.entities.base_node_data_entities import BaseNodeData
+from core.workflow.entities.node_entities import NodeRunResult, NodeType
+from core.workflow.entities.variable_pool import VariablePool
+from core.workflow.nodes.base_node import BaseNode
+from core.workflow.nodes.end.entities import EndNodeData
+from models.workflow import WorkflowNodeExecutionStatus
+
+
+class EndNode(BaseNode):
+    _node_data_cls = EndNodeData
+    node_type = NodeType.END
+
+    def _run(self, variable_pool: VariablePool) -> NodeRunResult:
+        """
+        Run node
+        :param variable_pool: variable pool
+        :return:
+        """
+        node_data = self.node_data
+        node_data = cast(self._node_data_cls, node_data)
+        output_variables = node_data.outputs
+
+        outputs = {}
+        for variable_selector in output_variables:
+            value = variable_pool.get_variable_value(
+                variable_selector=variable_selector.value_selector
+            )
+
+            outputs[variable_selector.variable] = value
+
+        return NodeRunResult(
+            status=WorkflowNodeExecutionStatus.SUCCEEDED,
+            inputs=outputs,
+            outputs=outputs
+        )
+
+    @classmethod
+    def _extract_variable_selector_to_variable_mapping(cls, node_data: BaseNodeData) -> dict[str, list[str]]:
+        """
+        Extract variable selector to variable mapping
+        :param node_data: node data
+        :return:
+        """
+        return {}