vellum-ai 0.9.16rc2__py3-none-any.whl → 0.9.16rc4__py3-none-any.whl

vellum_ee/workflows/display/nodes/vellum/api_node.py

@@ -0,0 +1,205 @@
+from uuid import UUID
+from typing import Any, ClassVar, Dict, Generic, Optional, TypeVar, cast
+
+from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
+from vellum_ee.workflows.display.nodes.utils import raise_if_descriptor
+from vellum_ee.workflows.display.nodes.vellum.utils import create_node_input
+from vellum_ee.workflows.display.types import WorkflowDisplayContext
+from vellum.workflows.nodes.displayable import APINode
+from vellum.workflows.references.output import OutputReference
+from vellum.workflows.types.core import JsonArray, JsonObject
+
+_APINodeType = TypeVar("_APINodeType", bound=APINode)
+
+
+class BaseAPINodeDisplay(BaseNodeVellumDisplay[_APINodeType], Generic[_APINodeType]):
+    url_input_id: ClassVar[Optional[UUID]] = None
+    method_input_id: ClassVar[Optional[UUID]] = None
+    body_input_id: ClassVar[Optional[UUID]] = None
+
+    authorization_type_input_id: ClassVar[Optional[UUID]] = None
+    bearer_token_value_input_id: ClassVar[Optional[UUID]] = None
+    api_key_header_key_input_id: ClassVar[Optional[UUID]] = None
+    api_key_header_value_input_id: ClassVar[Optional[UUID]] = None
+
+    text_output_id: ClassVar[Optional[UUID]] = None
+    json_output_id: ClassVar[Optional[UUID]] = None
+    status_code_output_id: ClassVar[Optional[UUID]] = None
+
+    # A mapping between node input keys and their ids for inputs representing additional header keys
+    additional_header_key_input_ids: ClassVar[Optional[Dict[str, UUID]]] = None
+
+    # A mapping between node input keys and their ids for inputs representing additional header values
+    additional_header_value_input_ids: ClassVar[Optional[Dict[str, UUID]]] = None
+
+    def serialize(
+        self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs: Any
+    ) -> JsonObject:
+        node = self._node
+        node_id = self.node_id
+
+        node_url = raise_if_descriptor(node.url)
+        url_node_input = create_node_input(
+            node_id=node_id,
+            input_name="url",
+            value=node_url,
+            display_context=display_context,
+            input_id=self.url_input_id,
+        )
+
+        node_method = raise_if_descriptor(node.method)
+        method_node_input = create_node_input(
+            node_id=node_id,
+            input_name="method",
+            value=node_method,
+            display_context=display_context,
+            input_id=self.method_input_id,
+        )
+
+        node_data = raise_if_descriptor(node.data)
+        node_json = raise_if_descriptor(node.json)
+        body_node_input = create_node_input(
+            node_id=node_id,
+            input_name="body",
+            value=node_data if node_data else node_json,
+            display_context=display_context,
+            input_id=self.body_input_id,
+        )
+
+        headers = raise_if_descriptor(node.headers)
+        api_key_header_key = raise_if_descriptor(node.api_key_header_key)
+        authorization_type = raise_if_descriptor(node.authorization_type)
+        bearer_token_value = raise_if_descriptor(node.bearer_token_value)
+
+        authorization_type_node_input = (
+            create_node_input(
+                node_id=node_id,
+                input_name="authorization_type",
+                value=authorization_type,
+                display_context=display_context,
+                input_id=self.authorization_type_input_id,
+            )
+            if authorization_type
+            else None
+        )
+        bearer_token_value_node_input = (
+            create_node_input(
+                node_id=node_id,
+                input_name="bearer_token_value",
+                value=bearer_token_value,
+                display_context=display_context,
+                input_id=self.bearer_token_value_input_id,
+            )
+            if bearer_token_value
+            else None
+        )
+        api_key_header_key_node_input = (
+            create_node_input(
+                node_id=node_id,
+                input_name="api_key_header_key",
+                value=api_key_header_key,
+                display_context=display_context,
+                input_id=self.api_key_header_key_input_id,
+            )
+            if api_key_header_key
+            else None
+        )
+        api_key_header_value_node_input = (
+            create_node_input(
+                node_id=node_id,
+                input_name="api_key_header_value",
+                value=node.api_key_header_value,
+                display_context=display_context,
+                input_id=self.api_key_header_value_input_id,
+            )
+            if headers and api_key_header_key
+            else None
+        )
+
+        # TODO: Add stable IDs for additional headers
+        # https://app.shortcut.com/vellum/story/5083
+        additional_headers: JsonArray = (
+            [
+                {
+                    "header_key_input_id": create_node_input(
+                        node_id=node_id,
+                        input_name=f"additional_header_key_{key}",
+                        value=key,
+                        display_context=display_context,
+                        input_id=(
+                            self.additional_header_key_input_ids.get(key)
+                            if self.additional_header_key_input_ids
+                            else None
+                        ),
+                    ).id,
+                    "header_value_input_id": create_node_input(
+                        node_id=node_id,
+                        input_name=f"additional_header_value_{key}",
+                        value=value,
+                        display_context=display_context,
+                        input_id=(
+                            self.additional_header_value_input_ids.get(key)
+                            if self.additional_header_value_input_ids
+                            else None
+                        ),
+                    ).id,
+                }
+                for key, value in headers.items()
+                if key not in {api_key_header_key, "Authorization"}
+            ]
+            if headers
+            else []
+        )
+
+        inputs = [
+            input
+            for input in [
+                url_node_input,
+                method_node_input,
+                body_node_input,
+                authorization_type_node_input,
+                bearer_token_value_node_input,
+                api_key_header_key_node_input,
+                api_key_header_value_node_input,
+            ]
+            if input is not None
+        ]
+
+        _, text_output_display = display_context.node_output_displays[cast(OutputReference, node.Outputs.text)]
+        _, json_output_display = display_context.node_output_displays[cast(OutputReference, node.Outputs.json)]
+        _, status_code_output_display = display_context.node_output_displays[
+            cast(OutputReference, node.Outputs.status_code)
+        ]
+
+        return {
+            "id": str(node_id),
+            "type": "API",
+            "inputs": [input.dict() for input in inputs],
+            "data": {
+                "label": self.label,
+                "error_output_id": str(error_output_id) if error_output_id else None,
+                "source_handle_id": str(self.get_source_handle_id(display_context.port_displays)),
+                "target_handle_id": str(self.get_target_handle_id()),
+                "url_input_id": url_node_input.id,
+                "method_input_id": method_node_input.id,
+                "body_input_id": body_node_input.id,
+                "authorization_type_input_id": (
+                    authorization_type_node_input.id if authorization_type_node_input else None
+                ),
+                "bearer_token_value_input_id": (
+                    bearer_token_value_node_input.id if bearer_token_value_node_input else None
+                ),
+                "api_key_header_key_input_id": (
+                    api_key_header_key_node_input.id if api_key_header_key_node_input else None
+                ),
+                "api_key_header_value_input_id": (
+                    api_key_header_value_node_input.id if api_key_header_value_node_input else None
+                ),
+                "additional_headers": additional_headers,
+                "text_output_id": str(text_output_display.id),
+                "json_output_id": str(json_output_display.id),
+                "status_code_output_id": str(status_code_output_display.id),
+            },
+            "display_data": self.get_display_data().dict(),
+            "definition": self.get_definition().dict(),
+        }

vellum_ee/workflows/display/nodes/vellum/code_execution_node.py

@@ -0,0 +1,71 @@
+from uuid import UUID
+from typing import ClassVar, Generic, Optional, TypeVar
+
+from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
+from vellum_ee.workflows.display.nodes.utils import raise_if_descriptor
+from vellum_ee.workflows.display.nodes.vellum.utils import create_node_input
+from vellum_ee.workflows.display.types import WorkflowDisplayContext
+from vellum.workflows.nodes.displayable.code_execution_node import CodeExecutionNode
+from vellum.workflows.nodes.displayable.code_execution_node.utils import read_file_from_path
+from vellum.workflows.types.core import JsonObject
+from vellum.workflows.utils.vellum_variables import primitive_type_to_vellum_variable_type
+
+_CodeExecutionNodeType = TypeVar("_CodeExecutionNodeType", bound=CodeExecutionNode)
+
+
+class BaseCodeExecutionNodeDisplay(BaseNodeVellumDisplay[_CodeExecutionNodeType], Generic[_CodeExecutionNodeType]):
+    code_input_id: ClassVar[Optional[UUID]] = None
+    runtime_input_id: ClassVar[Optional[UUID]] = None
+
+    output_id: ClassVar[Optional[UUID]] = None
+    log_output_id: ClassVar[Optional[UUID]] = None
+
+    def serialize(
+        self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
+    ) -> JsonObject:
+        node = self._node
+        node_id = self.node_id
+
+        code = read_file_from_path(raise_if_descriptor(node.filepath))
+        code_node_input = create_node_input(
+            node_id=node_id,
+            input_name="code",
+            value=code,
+            display_context=display_context,
+            input_id=self.code_input_id,
+        )
+        runtime_node_input = create_node_input(
+            node_id=node_id,
+            input_name="runtime",
+            value=node.runtime,
+            display_context=display_context,
+            input_id=self.runtime_input_id,
+        )
+        inputs = [code_node_input, runtime_node_input]
+
+        packages = raise_if_descriptor(node.packages)
+
+        _, output_display = display_context.node_output_displays[node.Outputs.result]
+        _, log_output_display = display_context.node_output_displays[node.Outputs.log]
+
+        output_type = primitive_type_to_vellum_variable_type(node.get_output_type())
+
+        return {
+            "id": str(node_id),
+            "type": "CODE_EXECUTION",
+            "inputs": [input.dict() for input in inputs],
+            "data": {
+                "label": self.label,
+                "error_output_id": str(error_output_id) if error_output_id else None,
+                "source_handle_id": str(self.get_source_handle_id(display_context.port_displays)),
+                "target_handle_id": str(self.get_target_handle_id()),
+                "code_input_id": str(self.code_input_id) if self.code_input_id else code_node_input.id,
+                "runtime_input_id": str(self.runtime_input_id) if self.runtime_input_id else runtime_node_input.id,
+                "output_type": output_type,
+                "packages": [package.dict() for package in packages] if packages is not None else [],
+                "output_id": str(self.output_id) if self.output_id else str(output_display.id),
+                "log_output_id": str(self.log_output_id) if self.log_output_id else str(log_output_display.id),
+            },
+            "display_data": self.get_display_data().dict(),
+            "definition": self.get_definition().dict(),
+        }

vellum_ee/workflows/display/nodes/vellum/conditional_node.py

@@ -0,0 +1,217 @@
+from dataclasses import dataclass
+from uuid import UUID
+from typing import Any, ClassVar, Dict, Generic, List, Optional, TypeVar
+
+from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
+from vellum_ee.workflows.display.nodes.vellum.utils import create_node_input
+from vellum_ee.workflows.display.types import WorkflowDisplayContext
+from vellum_ee.workflows.display.utils.uuids import uuid4_from_hash
+from vellum_ee.workflows.display.vellum import NodeInput
+from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.expressions.and_ import AndExpression
+from vellum.workflows.expressions.begins_with import BeginsWithExpression
+from vellum.workflows.expressions.between import BetweenExpression
+from vellum.workflows.expressions.contains import ContainsExpression
+from vellum.workflows.expressions.does_not_begin_with import DoesNotBeginWithExpression
+from vellum.workflows.expressions.does_not_contain import DoesNotContainExpression
+from vellum.workflows.expressions.does_not_end_with import DoesNotEndWithExpression
+from vellum.workflows.expressions.does_not_equal import DoesNotEqualExpression
+from vellum.workflows.expressions.ends_with import EndsWithExpression
+from vellum.workflows.expressions.equals import EqualsExpression
+from vellum.workflows.expressions.greater_than import GreaterThanExpression
+from vellum.workflows.expressions.greater_than_or_equal_to import GreaterThanOrEqualToExpression
+from vellum.workflows.expressions.in_ import InExpression
+from vellum.workflows.expressions.is_not_null import IsNotNullExpression
+from vellum.workflows.expressions.is_null import IsNullExpression
+from vellum.workflows.expressions.less_than import LessThanExpression
+from vellum.workflows.expressions.less_than_or_equal_to import LessThanOrEqualToExpression
+from vellum.workflows.expressions.not_between import NotBetweenExpression
+from vellum.workflows.expressions.not_in import NotInExpression
+from vellum.workflows.expressions.or_ import OrExpression
+from vellum.workflows.nodes.displayable import ConditionalNode
+from vellum.workflows.types.core import JsonObject
+
+_ConditionalNodeType = TypeVar("_ConditionalNodeType", bound=ConditionalNode)
+
+
+@dataclass
+class RuleIdMap:
+    id: UUID
+    lhs: Optional["RuleIdMap"]
+    rhs: Optional["RuleIdMap"]
+
+
+class BaseConditionalNodeDisplay(BaseNodeVellumDisplay[_ConditionalNodeType], Generic[_ConditionalNodeType]):
+    source_handle_ids: ClassVar[Dict[int, UUID]]
+    rule_ids: ClassVar[List[RuleIdMap]]
+
+    def serialize(self, display_context: WorkflowDisplayContext, **kwargs: Any) -> JsonObject:
+        node = self._node
+        node_id = self.node_id
+
+        node_inputs: List[NodeInput] = []
+        source_handle_ids = self._get_source_handle_ids() or {}
+
+        def serialize_rule(
+            descriptor: BaseDescriptor, path: List[int], rule_id_map: Optional[RuleIdMap]
+        ) -> Dict[str, Any]:
+            rule_id = (
+                str(rule_id_map.id)
+                if rule_id_map is not None
+                else str(uuid4_from_hash(f"{node_id}|rule|{','.join(str(p) for p in path)}"))
+            )
+            field_node_input_id = None
+            value_node_input_id = None
+
+            # Recursive step: Keep recursing until we hit the other descriptors
+            if isinstance(descriptor, (AndExpression, OrExpression)):
+                combinator = "AND" if isinstance(descriptor, AndExpression) else "OR"
+
+                lhs = serialize_rule(descriptor._lhs, path + [0], rule_id_map.lhs if rule_id_map else None)
+                rhs = serialize_rule(descriptor._rhs, path + [1], rule_id_map.rhs if rule_id_map else None)
+                rules = [lhs, rhs]
+
+                return {
+                    "id": rule_id,
+                    "rules": rules,
+                    "combinator": combinator,
+                    "negated": False,
+                    "field_node_input_id": None,
+                    "operator": None,
+                    "value_node_input_id": None,
+                }
+
+            # Base cases for other descriptors
+            elif isinstance(descriptor, (IsNullExpression, IsNotNullExpression)):
+                expression_node_input = create_node_input(
+                    node_id, f"{rule_id}.field", descriptor._expression, display_context, None
+                )
+                node_inputs.append(expression_node_input)
+                field_node_input_id = expression_node_input.id
+                operator = self._convert_descriptor_to_operator(descriptor)
+
+            elif isinstance(descriptor, (BetweenExpression, NotBetweenExpression)):
+                field_node_input = create_node_input(
+                    node_id, f"{rule_id}.field", descriptor._value, display_context, None
+                )
+                value_node_input = create_node_input(
+                    node_id, f"{rule_id}.value", f"{descriptor._start},{descriptor._end}", display_context, None
+                )
+                node_inputs.extend([field_node_input, value_node_input])
+                operator = self._convert_descriptor_to_operator(descriptor)
+                field_node_input_id = field_node_input.id
+                value_node_input_id = value_node_input.id
+
+            else:
+                lhs = descriptor._lhs  # type: ignore[attr-defined]
+                rhs = descriptor._rhs  # type: ignore[attr-defined]
+
+                lhs_node_input = create_node_input(node_id, f"{rule_id}.field", lhs, display_context, None)
+                node_inputs.append(lhs_node_input)
+
+                if descriptor._rhs is not None:  # type: ignore[attr-defined]
+                    rhs_node_input = create_node_input(node_id, f"{rule_id}.value", rhs, display_context, None)
+                    node_inputs.append(rhs_node_input)
+                    value_node_input_id = rhs_node_input.id
+
+                operator = self._convert_descriptor_to_operator(descriptor)
+                field_node_input_id = lhs_node_input.id
+
+            return {
+                "id": rule_id,
+                "rules": None,
+                "combinator": None,
+                "negated": False,
+                "field_node_input_id": field_node_input_id,
+                "operator": operator,
+                "value_node_input_id": value_node_input_id,
+            }
+
+        conditions = []
+        for idx, port in enumerate(node.Ports):
+            if port._condition is None or port._condition_type is None:
+                continue
+
+            condition_id = str(uuid4_from_hash(f"{node_id}|conditions|{idx}"))
+            source_handle_id = str(source_handle_ids.get(idx) or uuid4_from_hash(f"{node_id}|handles|{idx}"))
+
+            rule_ids = self._get_rule_ids()
+            condition_rule = serialize_rule(port._condition, [idx], rule_ids[idx] if len(rule_ids) > idx else None)
+            rules = condition_rule["rules"] if condition_rule["rules"] else [condition_rule]
+
+            conditions.append(
+                {
+                    "id": condition_id,
+                    "type": port._condition_type.value,
+                    "source_handle_id": source_handle_id,
+                    "data": {
+                        "id": str(uuid4_from_hash(f"{condition_id}|rule_group")),
+                        "rules": rules,
+                        "combinator": "AND",
+                        "negated": False,
+                        "field_node_input_id": None,
+                        "operator": None,
+                        "value_node_input_id": None,
+                    },
+                }
+            )
+
+        return {
+            "id": str(node_id),
+            "type": "CONDITIONAL",
+            "inputs": [node_input.dict() for node_input in node_inputs],
+            "data": {
+                "label": self.label,
+                "target_handle_id": str(self.get_target_handle_id()),
+                "conditions": conditions,  # type: ignore
+                "version": "2",
+            },
+            "display_data": self.get_display_data().dict(),
+            "definition": self.get_definition().dict(),
+        }
+
+    def _convert_descriptor_to_operator(self, descriptor: BaseDescriptor) -> str:
+        if isinstance(descriptor, EqualsExpression):
+            return "="
+        elif isinstance(descriptor, DoesNotEqualExpression):
+            return "!="
+        elif isinstance(descriptor, LessThanExpression):
+            return "<"
+        elif isinstance(descriptor, GreaterThanExpression):
+            return ">"
+        elif isinstance(descriptor, LessThanOrEqualToExpression):
+            return "<="
+        elif isinstance(descriptor, GreaterThanOrEqualToExpression):
+            return ">="
+        elif isinstance(descriptor, ContainsExpression):
+            return "contains"
+        elif isinstance(descriptor, BeginsWithExpression):
+            return "beginsWith"
+        elif isinstance(descriptor, EndsWithExpression):
+            return "endsWith"
+        elif isinstance(descriptor, DoesNotContainExpression):
+            return "doesNotContain"
+        elif isinstance(descriptor, DoesNotBeginWithExpression):
+            return "doesNotBeginWith"
+        elif isinstance(descriptor, DoesNotEndWithExpression):
+            return "doesNotEndWith"
+        elif isinstance(descriptor, IsNullExpression):
+            return "null"
+        elif isinstance(descriptor, IsNotNullExpression):
+            return "notNull"
+        elif isinstance(descriptor, InExpression):
+            return "in"
+        elif isinstance(descriptor, NotInExpression):
+            return "notIn"
+        elif isinstance(descriptor, BetweenExpression):
+            return "between"
+        elif isinstance(descriptor, NotBetweenExpression):
+            return "notBetween"
+        else:
+            raise ValueError(f"Unsupported descriptor type: {descriptor}")
+
+    def _get_source_handle_ids(self) -> Dict[int, UUID]:
+        return self._get_explicit_node_display_attr("source_handle_ids", Dict[int, UUID]) or {}
+
+    def _get_rule_ids(self) -> List[RuleIdMap]:
+        return self._get_explicit_node_display_attr("rule_ids", List[RuleIdMap]) or []

vellum_ee/workflows/display/nodes/vellum/final_output_node.py

@@ -0,0 +1,61 @@
+from uuid import UUID
+from typing import Any, ClassVar, Generic, Optional, TypeVar
+
+from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
+from vellum_ee.workflows.display.nodes.utils import to_kebab_case
+from vellum_ee.workflows.display.nodes.vellum.utils import create_node_input
+from vellum_ee.workflows.display.types import WorkflowDisplayContext
+from vellum_ee.workflows.display.utils.uuids import uuid4_from_hash
+from vellum_ee.workflows.display.utils.vellum import infer_vellum_variable_type
+from vellum.workflows.nodes.displayable.final_output_node import FinalOutputNode
+from vellum.workflows.types.core import JsonObject
+
+_FinalOutputNodeType = TypeVar("_FinalOutputNodeType", bound=FinalOutputNode)
+
+
+class BaseFinalOutputNodeDisplay(BaseNodeVellumDisplay[_FinalOutputNodeType], Generic[_FinalOutputNodeType]):
+    output_id: ClassVar[Optional[UUID]] = None
+    output_name: ClassVar[Optional[str]] = None
+    node_input_id: ClassVar[Optional[UUID]] = None
+
+    def serialize(self, display_context: WorkflowDisplayContext, **kwargs: Any) -> JsonObject:
+        node = self._node
+        node_id = self.node_id
+
+        node_input = create_node_input(
+            node_id,
+            "node_input",
+            # Get the pointer that the Terminal Node's output is referencing
+            node.Outputs.value.instance,
+            display_context,
+            self._get_node_input_id(),
+        )
+        inferred_type = infer_vellum_variable_type(node.Outputs.value)
+
+        return {
+            "id": str(node_id),
+            "type": "TERMINAL",
+            "data": {
+                "label": self.label,
+                "name": self._get_output_name(),
+                "target_handle_id": str(self.get_target_handle_id()),
+                "output_id": str(self._get_output_id()),
+                "output_type": inferred_type,
+                "node_input_id": str(node_input.id),
+            },
+            "inputs": [node_input.dict()],
+            "display_data": self.get_display_data().dict(),
+            "definition": self.get_definition().dict(),
+        }
+
+    def _get_output_id(self) -> UUID:
+        explicit_value = self._get_explicit_node_display_attr("output_id", UUID)
+        return explicit_value if explicit_value else uuid4_from_hash(f"{self.node_id}|output_id")
+
+    def _get_output_name(self) -> str:
+        explicit_value = self._get_explicit_node_display_attr("output_name", str)
+        return explicit_value if explicit_value else to_kebab_case(self._node.__name__)
+
+    def _get_node_input_id(self) -> UUID:
+        explicit_value = self._get_explicit_node_display_attr("node_input_id", UUID)
+        return explicit_value if explicit_value else uuid4_from_hash(f"{self.node_id}|node_input_id")

vellum_ee/workflows/display/nodes/vellum/guardrail_node.py

@@ -0,0 +1,49 @@
+from uuid import UUID
+from typing import Any, ClassVar, Dict, Generic, Optional, TypeVar
+
+from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
+from vellum_ee.workflows.display.nodes.utils import raise_if_descriptor
+from vellum_ee.workflows.display.nodes.vellum.utils import create_node_input
+from vellum_ee.workflows.display.types import WorkflowDisplayContext
+from vellum.workflows.nodes import GuardrailNode
+from vellum.workflows.types.core import JsonObject
+
+_GuardrailNodeType = TypeVar("_GuardrailNodeType", bound=GuardrailNode)
+
+
+class BaseGuardrailNodeDisplay(BaseNodeVellumDisplay[_GuardrailNodeType], Generic[_GuardrailNodeType]):
+    metric_input_ids_by_name: ClassVar[Dict[str, UUID]] = {}
+
+    def serialize(
+        self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs: Any
+    ) -> JsonObject:
+        node = self._node
+        node_id = self.node_id
+
+        metric_inputs = raise_if_descriptor(node.metric_inputs)
+        node_inputs = [
+            create_node_input(
+                node_id=node_id,
+                input_name=variable_name,
+                value=variable_value,
+                display_context=display_context,
+                input_id=self.metric_input_ids_by_name.get(variable_name),
+            )
+            for variable_name, variable_value in metric_inputs.items()
+        ]
+
+        return {
+            "id": str(node_id),
+            "type": "METRIC",
+            "inputs": [node_input.dict() for node_input in node_inputs],
+            "data": {
+                "label": self.label,
+                "source_handle_id": str(self.get_source_handle_id(display_context.port_displays)),
+                "target_handle_id": str(self.get_target_handle_id()),
+                "error_output_id": str(error_output_id) if error_output_id else None,
+                "metric_definition_id": str(raise_if_descriptor(node.metric_definition)),
+                "release_tag": raise_if_descriptor(node.release_tag),
+            },
+            "display_data": self.get_display_data().dict(),
+            "definition": self.get_definition().dict(),
+        }