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

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

@@ -0,0 +1,170 @@
+from uuid import UUID
+from typing import Any, ClassVar, Dict, Generic, List, Optional, Tuple, Type, TypeVar, Union, cast
+
+from vellum import PromptBlock, RichTextChildBlock, VellumVariable
+
+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_ee.workflows.display.utils.uuids import uuid4_from_hash
+from vellum_ee.workflows.display.utils.vellum import infer_vellum_variable_type
+from vellum_ee.workflows.display.vellum import NodeInput
+from vellum.workflows.nodes import InlinePromptNode
+from vellum.workflows.references import OutputReference
+from vellum.workflows.types.core import JsonObject
+
+_InlinePromptNodeType = TypeVar("_InlinePromptNodeType", bound=InlinePromptNode)
+
+
+class BaseInlinePromptNodeDisplay(BaseNodeVellumDisplay[_InlinePromptNodeType], Generic[_InlinePromptNodeType]):
+    output_id: ClassVar[Optional[UUID]] = None
+    array_output_id: ClassVar[Optional[UUID]] = None
+    prompt_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
+
+        node_inputs, prompt_inputs = self._generate_node_and_prompt_inputs(node_id, node, display_context)
+        input_variable_id_by_name = {prompt_input.key: prompt_input.id for prompt_input in prompt_inputs}
+
+        _, output_display = display_context.node_output_displays[cast(OutputReference, node.Outputs.text)]
+        _, array_display = display_context.node_output_displays[cast(OutputReference, node.Outputs.results)]
+        node_blocks = raise_if_descriptor(node.blocks)
+
+        return {
+            "id": str(node_id),
+            "type": "PROMPT",
+            "inputs": [node_input.dict() for node_input in node_inputs],
+            "data": {
+                "label": self.label,
+                "output_id": str(output_display.id),
+                "error_output_id": str(error_output_id) if error_output_id else None,
+                "array_output_id": str(array_display.id),
+                "source_handle_id": str(self.get_source_handle_id(display_context.port_displays)),
+                "target_handle_id": str(self.get_target_handle_id()),
+                "variant": "INLINE",
+                "exec_config": {
+                    "parameters": raise_if_descriptor(node.parameters).dict(),
+                    "input_variables": [prompt_input.dict() for prompt_input in prompt_inputs],
+                    "prompt_template_block_data": {
+                        "version": 1,
+                        "blocks": [
+                            self._generate_prompt_block(block, input_variable_id_by_name, [i])
+                            for i, block in enumerate(node_blocks)
+                        ],
+                    },
+                },
+                "ml_model_name": raise_if_descriptor(node.ml_model),
+            },
+            "display_data": self.get_display_data().dict(),
+            "definition": self.get_definition().dict(),
+        }
+
+    def _generate_node_and_prompt_inputs(
+        self,
+        node_id: UUID,
+        node: Type[InlinePromptNode],
+        display_context: WorkflowDisplayContext,
+    ) -> Tuple[List[NodeInput], List[VellumVariable]]:
+        value = raise_if_descriptor(node.prompt_inputs)
+
+        node_inputs: List[NodeInput] = []
+        prompt_inputs: List[VellumVariable] = []
+
+        for variable_name, variable_value in value.items():
+            node_input = create_node_input(
+                node_id=node_id,
+                input_name=variable_name,
+                value=variable_value,
+                display_context=display_context,
+                input_id=self.prompt_input_ids_by_name.get(variable_name),
+            )
+            vellum_variable_type = infer_vellum_variable_type(variable_value)
+            node_inputs.append(node_input)
+            prompt_inputs.append(VellumVariable(id=str(node_input.id), key=variable_name, type=vellum_variable_type))
+
+        return node_inputs, prompt_inputs
+
+    def _generate_prompt_block(
+        self,
+        prompt_block: Union[PromptBlock, RichTextChildBlock],
+        input_variable_id_by_name: Dict[str, str],
+        path: List[int],
+    ) -> JsonObject:
+        block: JsonObject
+        if prompt_block.block_type == "JINJA":
+            block = {
+                "block_type": "JINJA",
+                "properties": {"template": prompt_block.template, "template_type": "STRING"},
+            }
+
+        elif prompt_block.block_type == "CHAT_MESSAGE":
+            chat_properties: JsonObject = {
+                "chat_role": prompt_block.chat_role,
+                "chat_source": prompt_block.chat_source,
+                "blocks": [
+                    self._generate_prompt_block(block, input_variable_id_by_name, path + [i])
+                    for i, block in enumerate(prompt_block.blocks)
+                ],
+            }
+            if prompt_block.chat_message_unterminated is not None:
+                chat_properties["chat_message_unterminated"] = prompt_block.chat_message_unterminated
+
+            block = {
+                "block_type": "CHAT_MESSAGE",
+                "properties": chat_properties,
+            }
+
+        elif prompt_block.block_type == "FUNCTION_DEFINITION":
+            block = {
+                "block_type": "FUNCTION_DEFINITION",
+                "properties": {
+                    "function_name": prompt_block.function_name,
+                    "function_description": prompt_block.function_description,
+                    "function_parameters": prompt_block.function_parameters,
+                    "function_forced": prompt_block.function_forced,
+                    "function_strict": prompt_block.function_strict,
+                },
+            }
+
+        elif prompt_block.block_type == "VARIABLE":
+            block = {
+                "block_type": "VARIABLE",
+                "input_variable_id": input_variable_id_by_name[prompt_block.input_variable],
+            }
+
+        elif prompt_block.block_type == "PLAIN_TEXT":
+            block = {
+                "block_type": "PLAIN_TEXT",
+                "text": prompt_block.text,
+            }
+
+        elif prompt_block.block_type == "RICH_TEXT":
+            block = {
+                "block_type": "RICH_TEXT",
+                "blocks": [
+                    self._generate_prompt_block(child, input_variable_id_by_name, path + [i])
+                    for i, child in enumerate(prompt_block.blocks)
+                ],
+            }
+        else:
+            raise NotImplementedError(f"Serialization for prompt block type {prompt_block.block_type} not implemented")
+
+        block["id"] = str(
+            uuid4_from_hash(f"{self.node_id}-{prompt_block.block_type}-{'-'.join([str(i) for i in path])}")
+        )
+        if prompt_block.cache_config:
+            block["cache_config"] = prompt_block.cache_config.dict()
+        else:
+            block["cache_config"] = None
+
+        if prompt_block.state:
+            block["state"] = prompt_block.state
+        else:
+            block["state"] = "ENABLED"
+
+        return block

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

@@ -0,0 +1,99 @@
+from uuid import UUID
+from typing import Any, ClassVar, Dict, Generic, List, Optional, Tuple, Type, TypeVar
+
+from vellum import VellumVariable
+
+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_ee.workflows.display.utils.vellum import infer_vellum_variable_type
+from vellum_ee.workflows.display.vellum import NodeInput
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+from vellum.workflows.nodes import InlineSubworkflowNode
+from vellum.workflows.types.core import JsonObject
+
+_InlineSubworkflowNodeType = TypeVar("_InlineSubworkflowNodeType", bound=InlineSubworkflowNode)
+
+
+class BaseInlineSubworkflowNodeDisplay(
+    BaseNodeVellumDisplay[_InlineSubworkflowNodeType], Generic[_InlineSubworkflowNodeType]
+):
+    workflow_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
+
+        node_inputs, workflow_inputs = self._generate_node_and_workflow_inputs(node_id, node, display_context)
+        workflow_outputs = self._generate_workflow_outputs(node)
+
+        subworkflow_display = get_workflow_display(
+            base_display_class=display_context.workflow_display_class,
+            workflow_class=raise_if_descriptor(node.subworkflow),
+            parent_display_context=display_context,
+        )
+        serialized_subworkflow = subworkflow_display.serialize()
+
+        return {
+            "id": str(node_id),
+            "type": "SUBWORKFLOW",
+            "inputs": [node_input.dict() for node_input in node_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()),
+                "variant": "INLINE",
+                "workflow_raw_data": serialized_subworkflow["workflow_raw_data"],
+                "input_variables": [workflow_input.dict() for workflow_input in workflow_inputs],
+                "output_variables": [workflow_output.dict() for workflow_output in workflow_outputs],
+            },
+            "display_data": self.get_display_data().dict(),
+            "definition": self.get_definition().dict(),
+        }
+
+    def _generate_node_and_workflow_inputs(
+        self,
+        node_id: UUID,
+        node: Type[InlineSubworkflowNode],
+        display_context: WorkflowDisplayContext,
+    ) -> Tuple[List[NodeInput], List[VellumVariable]]:
+        subworkflow_inputs = raise_if_descriptor(node.subworkflow_inputs)
+        node_inputs = [
+            create_node_input(
+                node_id=node_id,
+                input_name=variable_name,
+                value=variable_value,
+                display_context=display_context,
+                input_id=self.workflow_input_ids_by_name.get(variable_name),
+            )
+            for variable_name, variable_value in subworkflow_inputs.items()
+        ]
+        node_inputs_by_key = {node_input.key: node_input for node_input in node_inputs}
+        workflow_inputs = [
+            VellumVariable(
+                id=node_inputs_by_key[descriptor.name].id,
+                key=descriptor.name,
+                type=infer_vellum_variable_type(descriptor),
+            )
+            for descriptor in raise_if_descriptor(node.subworkflow).get_inputs_class()
+        ]
+
+        return node_inputs, workflow_inputs
+
+    def _generate_workflow_outputs(
+        self,
+        node: Type[InlineSubworkflowNode],
+    ) -> List[VellumVariable]:
+        workflow_outputs: List[VellumVariable] = []
+        for output_descriptor in raise_if_descriptor(node.subworkflow).Outputs:  # type: ignore[union-attr]
+            node_output_display = self.get_node_output_display(output_descriptor)
+            output_type = infer_vellum_variable_type(output_descriptor)
+            workflow_outputs.append(
+                VellumVariable(id=str(node_output_display.id), key=node_output_display.name, type=output_type)
+            )
+
+        return workflow_outputs

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

@@ -0,0 +1,100 @@
+from uuid import UUID
+from typing import Any, ClassVar, Dict, Generic, List, Optional, Type, TypeVar
+
+from vellum import VellumVariable
+
+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_ee.workflows.display.utils.uuids import uuid4_from_hash
+from vellum_ee.workflows.display.utils.vellum import infer_vellum_variable_type
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+from vellum.workflows.nodes import MapNode
+from vellum.workflows.types.core import JsonObject
+
+_MapNodeType = TypeVar("_MapNodeType", bound=MapNode)
+
+
+class BaseMapNodeDisplay(BaseNodeVellumDisplay[_MapNodeType], Generic[_MapNodeType]):
+    workflow_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
+
+        workflow_inputs: List[VellumVariable] = []
+        subworkflow = raise_if_descriptor(node.subworkflow)
+        for descriptor in subworkflow.get_inputs_class():
+            # In WaC it's always 'all_items'
+            # In Vellum it's always 'items'
+            variable_name = descriptor.name if descriptor.name != "all_items" else "items"
+            variable_id = str(
+                self.workflow_input_ids_by_name.get(variable_name) or uuid4_from_hash(f"{self.node_id}|{variable_name}")
+            )
+            workflow_inputs.append(
+                VellumVariable(
+                    id=variable_id,
+                    key=variable_name,
+                    type=infer_vellum_variable_type(descriptor),
+                )
+            )
+
+        items_workflow_input = next(input for input in workflow_inputs if input.key == "items")
+        item_workflow_input = next(input for input in workflow_inputs if input.key == "item")
+        index_workflow_input = next(input for input in workflow_inputs if input.key == "index")
+
+        workflow_outputs = self._generate_workflow_outputs(node)
+
+        items_node_input = create_node_input(
+            node_id=node_id,
+            input_name="items",
+            value=node.items,
+            display_context=display_context,
+            input_id=UUID(items_workflow_input.id),
+        )
+        node_inputs = [items_node_input]
+
+        subworkflow_display = get_workflow_display(
+            base_display_class=display_context.workflow_display_class,
+            workflow_class=subworkflow,
+        )
+        serialized_subworkflow = subworkflow_display.serialize()
+
+        return {
+            "id": str(node_id),
+            "type": "MAP",
+            "inputs": [node_input.dict() for node_input in node_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()),
+                "variant": "INLINE",
+                "workflow_raw_data": serialized_subworkflow["workflow_raw_data"],
+                "input_variables": [workflow_input.dict() for workflow_input in workflow_inputs],
+                "output_variables": [workflow_output.dict() for workflow_output in workflow_outputs],
+                "concurrency": raise_if_descriptor(node.concurrency),
+                "items_input_id": str(items_workflow_input.id),
+                "item_input_id": str(item_workflow_input.id),
+                "index_input_id": str(index_workflow_input.id),
+            },
+            "display_data": self.get_display_data().dict(),
+            "definition": self.get_definition().dict(),
+        }
+
+    def _generate_workflow_outputs(
+        self,
+        node: Type[MapNode],
+    ) -> List[VellumVariable]:
+        workflow_outputs: List[VellumVariable] = []
+        for output_descriptor in raise_if_descriptor(node.subworkflow).Outputs:  # type: ignore[union-attr]
+            node_output_display = self.get_node_output_display(output_descriptor)
+            output_type = infer_vellum_variable_type(output_descriptor)
+            workflow_outputs.append(
+                VellumVariable(id=str(node_output_display.id), key=node_output_display.name, type=output_type)
+            )
+
+        return workflow_outputs

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

@@ -0,0 +1,48 @@
+from uuid import UUID
+from typing import Any, ClassVar, Generic, List, Optional, TypeVar
+
+from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
+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 EdgeVellumDisplay
+from vellum.workflows.nodes.displayable import MergeNode
+from vellum.workflows.types.core import JsonObject
+
+_MergeNodeType = TypeVar("_MergeNodeType", bound=MergeNode)
+
+
+class BaseMergeNodeDisplay(BaseNodeVellumDisplay[_MergeNodeType], Generic[_MergeNodeType]):
+    target_handle_ids: ClassVar[List[UUID]]
+
+    def serialize(self, display_context: WorkflowDisplayContext, **kwargs: Any) -> JsonObject:
+        node = self._node
+        node_id = self.node_id
+
+        all_edges: List[EdgeVellumDisplay] = [edge_display for _, edge_display in display_context.edge_displays.items()]
+        merged_edges = [edge for edge in all_edges if edge.target_node_id == self.node_id]
+
+        target_handle_ids = self.get_target_handle_ids()
+
+        if target_handle_ids is None:
+            target_handle_ids = [
+                uuid4_from_hash(f"{node_id}|target_handle|{edge.source_node_id}") for edge in merged_edges
+            ]
+        elif len(target_handle_ids) != len(merged_edges):
+            raise ValueError("If you explicitly specify target_handle_ids, you must specify one for each incoming edge")
+
+        return {
+            "id": str(node_id),
+            "type": "MERGE",
+            "inputs": [],
+            "data": {
+                "label": self.label,
+                "merge_strategy": node.Trigger.merge_behavior.value,
+                "target_handles": [{"id": str(target_handle_id)} for target_handle_id in target_handle_ids],
+                "source_handle_id": str(self.get_source_handle_id(display_context.port_displays)),
+            },
+            "display_data": self.get_display_data().dict(),
+            "definition": self.get_definition().dict(),
+        }
+
+    def get_target_handle_ids(self) -> Optional[List[UUID]]:
+        return self._get_explicit_node_display_attr("target_handle_ids", List[UUID])

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

@@ -0,0 +1,68 @@
+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.prompt_deployment_node import PromptDeploymentNode
+from vellum.workflows.references import OutputReference
+from vellum.workflows.types.core import JsonObject
+from vellum.workflows.vellum_client import create_vellum_client
+
+_PromptDeploymentNodeType = TypeVar("_PromptDeploymentNodeType", bound=PromptDeploymentNode)
+
+
+class BasePromptDeploymentNodeDisplay(
+    BaseNodeVellumDisplay[_PromptDeploymentNodeType], Generic[_PromptDeploymentNodeType]
+):
+    output_id: ClassVar[Optional[UUID]] = None
+    array_output_id: ClassVar[Optional[UUID]] = None
+    prompt_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
+
+        prompt_inputs = raise_if_descriptor(node.prompt_inputs)
+        node_inputs = [
+            create_node_input(
+                node_id=node_id,
+                input_name=variable_name,
+                value=variable_value,
+                display_context=display_context,
+                input_id=self.prompt_input_ids_by_name.get(variable_name),
+            )
+            for variable_name, variable_value in prompt_inputs.items()
+        ]
+
+        _, output_display = display_context.node_output_displays[cast(OutputReference, node.Outputs.text)]
+        _, array_display = display_context.node_output_displays[cast(OutputReference, node.Outputs.results)]
+
+        # TODO: Pass through the name instead of retrieving the ID
+        # https://app.shortcut.com/vellum/story/4702
+        vellum_client = create_vellum_client()
+        deployment = vellum_client.deployments.retrieve(
+            id=str(raise_if_descriptor(node.deployment)),
+        )
+
+        return {
+            "id": str(node_id),
+            "type": "PROMPT",
+            "inputs": [node_input.dict() for node_input in node_inputs],
+            "data": {
+                "label": self.label,
+                "output_id": str(output_display.id),
+                "error_output_id": str(error_output_id) if error_output_id else None,
+                "array_output_id": str(array_display.id),
+                "source_handle_id": str(self.get_source_handle_id(display_context.port_displays)),
+                "target_handle_id": str(self.get_target_handle_id()),
+                "variant": "DEPLOYMENT",
+                "prompt_deployment_id": str(deployment.id),
+                "release_tag": raise_if_descriptor(node.release_tag),
+            },
+            "display_data": self.get_display_data().dict(),
+            "definition": self.get_definition().dict(),
+        }

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

@@ -0,0 +1,193 @@
+from dataclasses import dataclass
+from uuid import UUID
+from typing import Any, Dict, Generic, List, Optional, Tuple, Type, TypeVar, Union, cast
+
+from vellum import (
+    MetadataFilterConfigRequest,
+    VellumValueLogicalConditionGroupRequest,
+    VellumValueLogicalConditionRequest,
+)
+
+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_ee.workflows.display.utils.uuids import uuid4_from_hash
+from vellum_ee.workflows.display.vellum import NodeInput
+from vellum.workflows.nodes.displayable.search_node import SearchNode
+from vellum.workflows.references import OutputReference
+from vellum.workflows.types.core import JsonArray, JsonObject
+
+_SearchNodeType = TypeVar("_SearchNodeType", bound=SearchNode)
+
+
+@dataclass
+class VariableIdMap:
+    id: Optional[UUID]
+    lhs: Optional["VariableIdMap"]
+    rhs: Optional["VariableIdMap"]
+
+
+class BaseSearchNodeDisplay(BaseNodeVellumDisplay[_SearchNodeType], Generic[_SearchNodeType]):
+    variable_ids: Optional[VariableIdMap] = 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_inputs = self._generate_search_node_inputs(node_id, node, display_context)
+
+        _, results_output_display = display_context.node_output_displays[cast(OutputReference, node.Outputs.results)]
+        _, text_output_display = display_context.node_output_displays[cast(OutputReference, node.Outputs.text)]
+
+        return {
+            "id": str(node_id),
+            "type": "SEARCH",
+            "inputs": [node_input.dict() for node_input in node_inputs.values()],
+            "data": {
+                "label": self.label,
+                "results_output_id": str(results_output_display.id),
+                "text_output_id": str(text_output_display.id),
+                "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()),
+                "query_node_input_id": str(node_inputs["query"].id),
+                "document_index_node_input_id": str(node_inputs["document_index_id"].id),
+                "weights_node_input_id": str(node_inputs["weights"].id),
+                "limit_node_input_id": str(node_inputs["limit"].id),
+                "separator_node_input_id": str(node_inputs["separator"].id),
+                "result_merging_enabled_node_input_id": str(node_inputs["result_merging_enabled"].id),
+                "external_id_filters_node_input_id": str(node_inputs["external_id_filters"].id),
+                "metadata_filters_node_input_id": str(node_inputs["metadata_filters"].id),
+            },
+            "display_data": self.get_display_data().dict(),
+            "definition": self.get_definition().dict(),
+        }
+
+    def _generate_search_node_inputs(
+        self,
+        node_id: UUID,
+        node: Type[SearchNode],
+        display_context: WorkflowDisplayContext,
+    ) -> Dict[str, NodeInput]:
+        node_inputs: Dict[str, NodeInput] = {}
+
+        options = raise_if_descriptor(node.options)
+        filters = options.filters if options else None
+
+        if filters and filters.external_ids:
+            # TODO: Add support for serializing external ID filters
+            # https://app.shortcut.com/vellum/story/5563/add-support-for-serializing-external-id-in-text-search-nodes
+            raise NotImplementedError("Serializing External ID filters is not yet supported")
+
+        raw_metadata_filters = filters.metadata if filters else None
+        metadata_filters = None
+        metadata_filters_node_inputs: list[NodeInput] = []
+        if raw_metadata_filters:
+            if isinstance(raw_metadata_filters, MetadataFilterConfigRequest):
+                raise ValueError(
+                    "MetadataFilterConfigRequest is deprecated. Please use VellumValueLogicalExpressionRequest instead."
+                )
+            metadata_filters, metadata_filters_node_inputs = self._serialize_logical_expression(
+                raw_metadata_filters, display_context=display_context
+            )
+
+        result_merging = options.result_merging if options else None
+        result_merging_enabled = True if result_merging and result_merging.enabled else False
+
+        weights = options.weights if options else None
+
+        node_input_names_and_values = [
+            ("query", node.query),
+            ("document_index_id", node.document_index),
+            ("weights", weights.dict() if weights else None),
+            ("limit", options.limit if options else None),
+            ("separator", raise_if_descriptor(node.chunk_separator)),
+            (
+                "result_merging_enabled",
+                ("True" if result_merging_enabled else "False"),
+            ),
+            ("external_id_filters", None),
+            ("metadata_filters", metadata_filters),
+        ]
+
+        for node_input_name, node_input_value in node_input_names_and_values:
+            node_input = create_node_input(
+                node_id,
+                node_input_name,
+                node_input_value,
+                display_context,
+                input_id=self.node_input_ids_by_name.get(node_input_name),
+            )
+            node_inputs[node_input_name] = node_input
+
+        for node_input in metadata_filters_node_inputs:
+            node_inputs[node_input.key] = node_input
+
+        return node_inputs
+
+    def _serialize_logical_expression(
+        self,
+        logical_expression: Union[VellumValueLogicalConditionGroupRequest, VellumValueLogicalConditionRequest],
+        display_context: WorkflowDisplayContext,
+        path: List[int] = [],
+        variable_id_map: Optional[VariableIdMap] = None,
+    ) -> Tuple[JsonObject, List[NodeInput]]:
+        if isinstance(logical_expression, VellumValueLogicalConditionGroupRequest):
+            conditions: JsonArray = []
+            variables = []
+            for idx, condition in enumerate(logical_expression.conditions):
+                serialized_condition, serialized_variables = self._serialize_logical_expression(
+                    condition, display_context=display_context, path=path + [idx]
+                )
+                conditions.append(serialized_condition)
+                variables.extend(serialized_variables)
+
+            return (
+                {
+                    "type": "LOGICAL_CONDITION_GROUP",
+                    "combinator": logical_expression.combinator,
+                    "conditions": conditions,
+                    "negated": logical_expression.negated,
+                },
+                variables,
+            )
+        elif isinstance(logical_expression, VellumValueLogicalConditionRequest):
+            lhs_variable_id = (
+                variable_id_map.lhs.id
+                if variable_id_map and variable_id_map.lhs and variable_id_map.lhs.id
+                else uuid4_from_hash(f"{self.node_id}|{hash(tuple(path))}|lhs")
+            )
+            rhs_variable_id = (
+                variable_id_map.rhs.id
+                if variable_id_map and variable_id_map.rhs and variable_id_map.rhs.id
+                else uuid4_from_hash(f"{self.node_id}|{hash(tuple(path))}|rhs")
+            )
+
+            return (
+                {
+                    "type": "LOGICAL_CONDITION",
+                    "lhs": str(lhs_variable_id),
+                    "operator": logical_expression.operator,
+                    "rhs": str(rhs_variable_id),
+                },
+                [
+                    create_node_input(
+                        self.node_id,
+                        f"vellum-query-builder-variable-{lhs_variable_id}",
+                        logical_expression.lhs_variable.value,
+                        display_context,
+                        input_id=lhs_variable_id,
+                    ),
+                    create_node_input(
+                        self.node_id,
+                        f"vellum-query-builder-variable-{rhs_variable_id}",
+                        logical_expression.rhs_variable.value,
+                        display_context,
+                        input_id=rhs_variable_id,
+                    ),
+                ],
+            )
+        else:
+            raise ValueError(f"Unsupported logical expression type: {type(logical_expression)}")