vellum-ai 0.14.69__py3-none-any.whl → 0.14.71__py3-none-any.whl

vellum_cli/tests/test_image_push.py

@@ -4,13 +4,14 @@ import os
 import shutil
 import subprocess
 import tempfile
-from unittest.mock import MagicMock, patch
+from unittest.mock import MagicMock
 from uuid import uuid4
 from typing import Generator
 
 from click.testing import CliRunner
 from httpx import Response
 
+from vellum.client.types.docker_service_token import DockerServiceToken
 from vellum_cli import main as cli_main
 
 
@@ -26,9 +27,18 @@ def mock_temp_dir() -> Generator[str, None, None]:
     shutil.rmtree(temp_dir)
 
 
-@patch("subprocess.run")
-@patch("docker.from_env")
-def test_image_push__self_hosted_happy_path(mock_docker_from_env, mock_run, vellum_client, monkeypatch):
+@pytest.fixture
+def mock_docker_from_env(mocker):
+    return mocker.patch("docker.from_env")
+
+
+@pytest.fixture
+def mock_subprocess_run(mocker):
+    return mocker.patch("subprocess.run")
+
+
+@pytest.mark.usefixtures("vellum_client")
+def test_image_push__self_hosted_happy_path(mock_docker_from_env, mock_subprocess_run, monkeypatch):
     # GIVEN a self hosted vellum api URL env var
     monkeypatch.setenv("VELLUM_API_URL", "mycompany.api.com")
     monkeypatch.setenv("VELLUM_API_KEY", "123456abcdef")
@@ -37,7 +47,7 @@ def test_image_push__self_hosted_happy_path(mock_docker_from_env, mock_run, vell
     mock_docker_client = MagicMock()
     mock_docker_from_env.return_value = mock_docker_client
 
-    mock_run.side_effect = [
+    mock_subprocess_run.side_effect = [
         subprocess.CompletedProcess(
             args="", returncode=0, stdout=b'{"manifests": [{"platform": {"architecture": "amd64"}}]}'
         ),
@@ -56,10 +66,8 @@ def test_image_push__self_hosted_happy_path(mock_docker_from_env, mock_run, vell
     assert "Image successfully pushed" in result.output
 
 
-@patch("subprocess.run")
-@patch("docker.from_env")
 def test_image_push__self_hosted_happy_path__workspace_option(
-    mock_docker_from_env, mock_run, mock_httpx_transport, mock_temp_dir
+    mock_docker_from_env, mock_subprocess_run, mock_httpx_transport, mock_temp_dir
 ):
     # GIVEN a workspace config with a new env for url
     with open(os.path.join(mock_temp_dir, "vellum.lock.json"), "w") as f:
@@ -90,7 +98,7 @@ def test_image_push__self_hosted_happy_path__workspace_option(
     mock_docker_client = MagicMock()
     mock_docker_from_env.return_value = mock_docker_client
 
-    mock_run.side_effect = [
+    mock_subprocess_run.side_effect = [
         subprocess.CompletedProcess(
             args="", returncode=0, stdout=b'{"manifests": [{"platform": {"architecture": "amd64"}}]}'
         ),
@@ -144,9 +152,8 @@ def test_image_push__self_hosted_happy_path__workspace_option(
     assert str(request.url) == "https://api.vellum.mycompany.ai/v1/container-images/push"
 
 
-@patch("subprocess.run")
-@patch("docker.from_env")
-def test_image_push__self_hosted_blocks_repo(mock_docker_from_env, mock_run, vellum_client, monkeypatch):
+@pytest.mark.usefixtures("vellum_client", "mock_subprocess_run")
+def test_image_push__self_hosted_blocks_repo(mock_docker_from_env, monkeypatch):
     # GIVEN a self hosted vellum api URL env var
     monkeypatch.setenv("VELLUM_API_URL", "mycompany.api.com")
 
@@ -163,3 +170,87 @@ def test_image_push__self_hosted_blocks_repo(mock_docker_from_env, mock_run, vel
 
     # AND gives the error message for self hosted installs not including the repo
     assert "For adding images to your self hosted install you must include" in result.output
+
+
+def test_image_push_with_source_success(
+    mock_docker_from_env, mock_subprocess_run, vellum_client, monkeypatch, mock_temp_dir
+):
+    monkeypatch.setenv("VELLUM_API_URL", "https://api.vellum.ai")
+    monkeypatch.setenv("VELLUM_API_KEY", "123456abcdef")
+
+    dockerfile_path = os.path.join(mock_temp_dir, "Dockerfile")
+    with open(dockerfile_path, "w") as f:
+        f.write("FROM alpine:latest\n")
+
+    mock_docker_client = MagicMock()
+    mock_docker_from_env.return_value = mock_docker_client
+    mock_docker_client.images.push.return_value = [b'{"status": "Pushed"}']
+
+    mock_subprocess_run.side_effect = [
+        subprocess.CompletedProcess(args="", returncode=0, stdout=b"Build successful"),
+        subprocess.CompletedProcess(
+            args="", returncode=0, stdout=b'{"manifests": [{"platform": {"architecture": "amd64"}}]}'
+        ),
+        subprocess.CompletedProcess(args="", returncode=0, stdout=b"sha256:hellosha"),
+    ]
+
+    vellum_client.container_images.docker_service_token.return_value = DockerServiceToken(
+        access_token="345678mnopqr", organization_id="test-org", repository="myrepo.net"
+    )
+
+    runner = CliRunner()
+    result = runner.invoke(cli_main, ["image", "push", "myimage:latest", "--source", dockerfile_path])
+
+    assert result.exit_code == 0, result.output
+
+    build_call = mock_subprocess_run.call_args_list[0]
+    assert build_call[0][0] == [
+        "docker",
+        "buildx",
+        "build",
+        "-f",
+        "Dockerfile",
+        "--platform=linux/amd64",
+        "-t",
+        "myimage:latest",
+        ".",
+    ]
+    assert build_call[1]["cwd"] == mock_temp_dir
+
+    assert "Docker build completed successfully" in result.output
+    assert "Image successfully pushed" in result.output
+
+
+@pytest.mark.usefixtures("mock_docker_from_env", "mock_subprocess_run", "vellum_client")
+def test_image_push_with_source_dockerfile_not_exists(monkeypatch, mock_temp_dir):
+    monkeypatch.setenv("VELLUM_API_URL", "https://api.vellum.ai")
+    monkeypatch.setenv("VELLUM_API_KEY", "123456abcdef")
+
+    nonexistent_dockerfile = os.path.join(mock_temp_dir, "nonexistent_dockerfile")
+
+    runner = CliRunner()
+    result = runner.invoke(cli_main, ["image", "push", "myimage:latest", "--source", nonexistent_dockerfile])
+
+    assert result.exit_code == 1
+    assert "Dockerfile does not exist" in result.output
+
+
+@pytest.mark.usefixtures("mock_docker_from_env", "vellum_client")
+def test_image_push_with_source_build_fails(mock_subprocess_run, monkeypatch, mock_temp_dir):
+    monkeypatch.setenv("VELLUM_API_URL", "https://api.vellum.ai")
+    monkeypatch.setenv("VELLUM_API_KEY", "123456abcdef")
+
+    dockerfile_path = os.path.join(mock_temp_dir, "Dockerfile")
+    with open(dockerfile_path, "w") as f:
+        f.write("FROM alpine:latest\n")
+
+    mock_subprocess_run.side_effect = [
+        subprocess.CompletedProcess(args="", returncode=1, stderr=b"Build failed: missing dependency"),
+    ]
+
+    runner = CliRunner()
+    result = runner.invoke(cli_main, ["image", "push", "myimage:latest", "--source", dockerfile_path])
+
+    assert result.exit_code == 1
+    assert "Docker build failed" in result.output
+    assert "Build failed: missing dependency" in result.output

vellum_ee/workflows/display/nodes/base_node_display.py

@@ -310,7 +310,7 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
 
         return self._get_node_display_uuid("target_handle_id")
 
-    def get_target_handle_id_by_source_node_id(self, source_node_id: UUID) -> UUID:
+    def get_target_handle_id_by_source_node_id(self, _source_node_id: UUID) -> UUID:
         """
         In the vast majority of cases, nodes will only have a single target handle and can be retrieved independently
         of the source node. However, in rare cases (such as legacy Merge nodes), this method can be overridden to

vellum_ee/workflows/display/nodes/utils.py

@@ -8,11 +8,11 @@ _T = TypeVar("_T")
 
 
 @overload
-def raise_if_descriptor(node_attr: BaseDescriptor[_T]) -> _T: ...
+def raise_if_descriptor(_node_attr: BaseDescriptor[_T]) -> _T: ...
 
 
 @overload
-def raise_if_descriptor(node_attr: _T) -> _T: ...
+def raise_if_descriptor(_node_attr: _T) -> _T: ...
 
 
 def raise_if_descriptor(node_attr: Union[NodeReference[_T], _T]) -> Optional[_T]:

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

@@ -1,5 +1,5 @@
 from uuid import UUID
-from typing import Any, ClassVar, Dict, Generic, Optional, TypeVar, cast
+from typing import ClassVar, Dict, Generic, Optional, TypeVar, cast
 
 from vellum.workflows.nodes.displayable import APINode
 from vellum.workflows.references.output import OutputReference
@@ -32,7 +32,7 @@ class BaseAPINodeDisplay(BaseNodeDisplay[_APINodeType], Generic[_APINodeType]):
     }
 
     def serialize(
-        self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs: Any
+        self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **_kwargs
     ) -> JsonObject:
         node = self._node
         node_id = self.node_id

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

@@ -24,7 +24,7 @@ class BaseCodeExecutionNodeDisplay(BaseNodeDisplay[_CodeExecutionNodeType], Gene
     }
 
     def serialize(
-        self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
+        self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **_kwargs
     ) -> JsonObject:
         node = self._node
         node_id = self.node_id

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

@@ -45,7 +45,7 @@ class BaseConditionalNodeDisplay(BaseNodeDisplay[_ConditionalNodeType], Generic[
     rule_ids: ClassVar[List[RuleIdMap]]
     condition_ids: ClassVar[list[ConditionId]]
 
-    def serialize(self, display_context: WorkflowDisplayContext, **kwargs: Any) -> JsonObject:
+    def serialize(self, display_context: WorkflowDisplayContext, **_kwargs) -> JsonObject:
         node = self._node
         node_id = self.node_id
 

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

@@ -20,7 +20,7 @@ class BaseErrorNodeDisplay(BaseNodeDisplay[_ErrorNodeType], Generic[_ErrorNodeTy
 
     __serializable_inputs__ = {ErrorNode.error}
 
-    def serialize(self, display_context: WorkflowDisplayContext, **kwargs) -> JsonObject:
+    def serialize(self, display_context: WorkflowDisplayContext, **_kwargs) -> JsonObject:
         node_id = self.node_id
         error_source_input_id = self.node_input_ids_by_name.get(
             ErrorNode.error.name,

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

@@ -1,5 +1,5 @@
 from uuid import UUID
-from typing import Any, ClassVar, Generic, Optional, TypeVar
+from typing import ClassVar, Generic, Optional, TypeVar
 
 from vellum.workflows.nodes.displayable.final_output_node import FinalOutputNode
 from vellum.workflows.types.core import JsonObject
@@ -19,7 +19,7 @@ NODE_INPUT_KEY = "node_input"
 class BaseFinalOutputNodeDisplay(BaseNodeDisplay[_FinalOutputNodeType], Generic[_FinalOutputNodeType]):
     output_name: ClassVar[Optional[str]] = None
 
-    def serialize(self, display_context: WorkflowDisplayContext, **kwargs: Any) -> JsonObject:
+    def serialize(self, display_context: WorkflowDisplayContext, **_kwargs) -> JsonObject:
         node = self._node
         node_id = self.node_id
 

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

@@ -15,7 +15,7 @@ class BaseGuardrailNodeDisplay(BaseNodeDisplay[_GuardrailNodeType], Generic[_Gua
     __serializable_inputs__ = {GuardrailNode.metric_inputs}
 
     def serialize(
-        self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
+        self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **_kwargs
     ) -> JsonObject:
         node = self._node
         node_id = self.node_id

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

@@ -2,6 +2,7 @@ from uuid import UUID
 from typing import Callable, Dict, Generic, List, Optional, Tuple, Type, TypeVar, Union
 
 from vellum import FunctionDefinition, PromptBlock, RichTextChildBlock, VellumVariable
+from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.nodes import InlinePromptNode
 from vellum.workflows.types.core import JsonObject
 from vellum.workflows.utils.functions import compile_function_definition
@@ -18,9 +19,10 @@ _InlinePromptNodeType = TypeVar("_InlinePromptNodeType", bound=InlinePromptNode)
 
 
 class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generic[_InlinePromptNodeType]):
-    __serializable_inputs__ = {InlinePromptNode.prompt_inputs, InlinePromptNode.functions}
+    __serializable_inputs__ = {
+        InlinePromptNode.prompt_inputs,
+    }
     __unserializable_attributes__ = {
-        InlinePromptNode.blocks,
         InlinePromptNode.parameters,
         InlinePromptNode.settings,
         InlinePromptNode.expand_meta,
@@ -28,7 +30,7 @@ class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generi
     }
 
     def serialize(
-        self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
+        self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **_kwargs
     ) -> JsonObject:
         node = self._node
         node_id = self.node_id
@@ -45,7 +47,9 @@ class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generi
         ml_model = str(raise_if_descriptor(node.ml_model))
 
         blocks: list = [
-            self._generate_prompt_block(block, input_variable_id_by_name, [i]) for i, block in enumerate(node_blocks)
+            self._generate_prompt_block(block, input_variable_id_by_name, [i])
+            for i, block in enumerate(node_blocks)
+            if not isinstance(block, BaseDescriptor)
         ]
 
         functions = (

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

@@ -2,8 +2,10 @@ from uuid import UUID
 from typing import ClassVar, Dict, Generic, List, Optional, Tuple, Type, TypeVar
 
 from vellum import VellumVariable
+from vellum.workflows.constants import undefined
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes import InlineSubworkflowNode
+from vellum.workflows.nodes.displayable.bases.utils import primitive_to_vellum_value
 from vellum.workflows.types.core import JsonObject
 from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
 from vellum_ee.workflows.display.nodes.utils import raise_if_descriptor
@@ -24,7 +26,7 @@ class BaseInlineSubworkflowNodeDisplay(
     __serializable_inputs__ = {InlineSubworkflowNode.subworkflow_inputs}
 
     def serialize(
-        self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
+        self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **_kwargs
     ) -> JsonObject:
         node = self._node
         node_id = self.node_id
@@ -100,6 +102,12 @@ class BaseInlineSubworkflowNodeDisplay(
                 id=node_inputs_by_key[descriptor.name].id,
                 key=descriptor.name,
                 type=infer_vellum_variable_type(descriptor),
+                required=descriptor.instance is undefined,
+                default=(
+                    primitive_to_vellum_value(descriptor.instance).dict()
+                    if descriptor.instance is not undefined
+                    else None
+                ),
             )
             for descriptor in subworkflow_inputs_class
         ]

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

@@ -17,7 +17,7 @@ class BaseMapNodeDisplay(BaseAdornmentNodeDisplay[_MapNodeType], Generic[_MapNod
     __serializable_inputs__ = {MapNode.items}  # type: ignore[misc]
 
     def serialize(
-        self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
+        self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **_kwargs
     ) -> JsonObject:
         node = self._node
         node_id = self.node_id

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

@@ -17,7 +17,7 @@ class BaseMergeNodeDisplay(BaseNodeDisplay[_MergeNodeType], Generic[_MergeNodeTy
         super().__init__()
         self._target_handle_iterator = 0
 
-    def serialize(self, display_context: WorkflowDisplayContext, **kwargs: Any) -> JsonObject:
+    def serialize(self, display_context: WorkflowDisplayContext, **_kwargs: Any) -> JsonObject:
         node = self._node
         node_id = self.node_id
 

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

@@ -13,6 +13,7 @@ class BaseNoteNodeDisplay(BaseNodeDisplay[_NoteNodeType], Generic[_NoteNodeType]
     style: ClassVar[Union[Dict[str, Any], None]] = None
 
     def serialize(self, display_context: WorkflowDisplayContext, **kwargs: Any) -> JsonObject:
+        del display_context, kwargs  # Unused parameters
         node_id = self.node_id
 
         return {

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

@@ -15,7 +15,7 @@ class BasePromptDeploymentNodeDisplay(BaseNodeDisplay[_PromptDeploymentNodeType]
     __serializable_inputs__ = {PromptDeploymentNode.prompt_inputs}
 
     def serialize(
-        self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
+        self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **_kwargs
     ) -> JsonObject:
         node = self._node
         node_id = self.node_id

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

@@ -18,7 +18,7 @@ _RetryNodeType = TypeVar("_RetryNodeType", bound=RetryNode)
 
 
 class BaseRetryNodeDisplay(BaseAdornmentNodeDisplay[_RetryNodeType], Generic[_RetryNodeType]):
-    def serialize(self, display_context: WorkflowDisplayContext, **kwargs: Any) -> JsonObject:
+    def serialize(self, display_context: WorkflowDisplayContext, **_kwargs: Any) -> JsonObject:
         node = self._node
         node_id = self.node_id
 

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

@@ -7,6 +7,7 @@ from vellum import (
     VellumValueLogicalConditionGroupRequest,
     VellumValueLogicalConditionRequest,
 )
+from vellum.workflows.nodes.displayable.bases.types import MetadataLogicalCondition, MetadataLogicalConditionGroup
 from vellum.workflows.nodes.displayable.search_node import SearchNode
 from vellum.workflows.references import OutputReference
 from vellum.workflows.types.core import JsonArray, JsonObject
@@ -42,7 +43,7 @@ class BaseSearchNodeDisplay(BaseNodeDisplay[_SearchNodeType], Generic[_SearchNod
     }
 
     def serialize(
-        self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
+        self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **_kwargs
     ) -> JsonObject:
         node = self._node
         node_id = self.node_id
@@ -88,7 +89,8 @@ class BaseSearchNodeDisplay(BaseNodeDisplay[_SearchNodeType], Generic[_SearchNod
         node_inputs: Dict[str, NodeInput] = {}
 
         options = raise_if_descriptor(node.options)
-        filters = options.filters if options else None
+        raw_filters = raise_if_descriptor(node.filters)
+        filters = raw_filters if raw_filters else options.filters if options else None
 
         external_id_filters = filters.external_ids if filters else None
 
@@ -104,17 +106,21 @@ class BaseSearchNodeDisplay(BaseNodeDisplay[_SearchNodeType], Generic[_SearchNod
                 raw_metadata_filters, display_context=display_context
             )
 
-        result_merging = options.result_merging if options else None
+        raw_result_merging = raise_if_descriptor(node.result_merging)
+        result_merging = raw_result_merging if raw_result_merging else options.result_merging if options else None
         result_merging_enabled = True if result_merging and result_merging.enabled else False
 
         raw_weights = raise_if_descriptor(node.weights)
         weights = raw_weights if raw_weights is not None else options.weights if options is not None else None
 
+        raw_limit = raise_if_descriptor(node.limit)
+        limit = raw_limit if raw_limit is not None else options.limit if options is not None 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),
+            ("limit", limit),
             ("separator", raise_if_descriptor(node.chunk_separator)),
             (
                 "result_merging_enabled",
@@ -141,7 +147,12 @@ class BaseSearchNodeDisplay(BaseNodeDisplay[_SearchNodeType], Generic[_SearchNod
 
     def _serialize_logical_expression(
         self,
-        logical_expression: Union[VellumValueLogicalConditionGroupRequest, VellumValueLogicalConditionRequest],
+        logical_expression: Union[
+            VellumValueLogicalConditionGroupRequest,
+            VellumValueLogicalConditionRequest,
+            MetadataLogicalConditionGroup,
+            MetadataLogicalCondition,
+        ],
         display_context: WorkflowDisplayContext,
         path: List[int] = [],
     ) -> Tuple[JsonObject, List[NodeInput]]:
@@ -175,10 +186,10 @@ class BaseSearchNodeDisplay(BaseNodeDisplay[_SearchNodeType], Generic[_SearchNod
 
             lhs_query_input_id: UUID = self.metadata_filter_input_id_by_operand_id.get(
                 UUID(lhs_variable_id)
-            ) or uuid4_from_hash(f"{self.node_id}|{hash(tuple(path))}")
+            ) or uuid4_from_hash(f"{self.node_id}|lhs|{hash(tuple(path))}")
             rhs_query_input_id: UUID = self.metadata_filter_input_id_by_operand_id.get(
                 UUID(rhs_variable_id)
-            ) or uuid4_from_hash(f"{self.node_id}|{hash(tuple(path))}")
+            ) or uuid4_from_hash(f"{self.node_id}|rhs|{hash(tuple(path))}")
 
             return (
                 {
@@ -206,5 +217,57 @@ class BaseSearchNodeDisplay(BaseNodeDisplay[_SearchNodeType], Generic[_SearchNod
                     ),
                 ],
             )
+
+        elif isinstance(logical_expression, MetadataLogicalConditionGroup):
+            conditions = []
+            variables = []
+            for idx, metadata_condition in enumerate(logical_expression.conditions):
+                serialized_condition, serialized_variables = self._serialize_logical_expression(
+                    metadata_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, MetadataLogicalCondition):
+            lhs_variable = logical_expression.lhs_variable
+            rhs_variable = logical_expression.rhs_variable
+
+            lhs_query_input_id = uuid4_from_hash(f"{self.node_id}|lhs|{hash(tuple(path))}")
+            rhs_query_input_id = uuid4_from_hash(f"{self.node_id}|rhs|{hash(tuple(path))}")
+
+            return (
+                {
+                    "type": "LOGICAL_CONDITION",
+                    "lhs_variable_id": str(lhs_query_input_id),
+                    "operator": logical_expression.operator,
+                    "rhs_variable_id": str(rhs_query_input_id),
+                },
+                [
+                    create_node_input(
+                        self.node_id,
+                        f"vellum-query-builder-variable-{lhs_query_input_id}",
+                        lhs_variable,
+                        display_context,
+                        input_id=lhs_query_input_id,
+                    ),
+                    create_node_input(
+                        self.node_id,
+                        f"vellum-query-builder-variable-{rhs_query_input_id}",
+                        rhs_variable,
+                        display_context,
+                        input_id=rhs_query_input_id,
+                    ),
+                ],
+            )
         else:
             raise ValueError(f"Unsupported logical expression type: {type(logical_expression)}")

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

@@ -17,7 +17,7 @@ class BaseSubworkflowDeploymentNodeDisplay(
     __serializable_inputs__ = {SubworkflowDeploymentNode.subworkflow_inputs}
 
     def serialize(
-        self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
+        self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **_kwargs
     ) -> JsonObject:
         node = self._node
         node_id = self.node_id

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

@@ -18,7 +18,7 @@ class BaseTemplatingNodeDisplay(BaseNodeDisplay[_TemplatingNodeType], Generic[_T
     __serializable_inputs__ = {TemplatingNode.inputs}
 
     def serialize(
-        self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
+        self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **_kwargs
     ) -> JsonObject:
         node = self._node
         node_id = self.node_id

vellum_ee/workflows/display/nodes/vellum/tests/test_inline_subworkflow_node.py

@@ -0,0 +1,88 @@
+from typing import Optional
+
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.nodes import InlineSubworkflowNode
+from vellum.workflows.nodes.bases import BaseNode
+from vellum.workflows.state.base import BaseState
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+
+def test_serialize_node__inline_subworkflow_inputs():
+    # GIVEN a main workflow with inputs
+    class MainInputs(BaseInputs):
+        pass
+
+    # AND an inline subworkflow with inputs
+    class NestedInputs(BaseInputs):
+        input: str
+        input_with_default: str = "default"
+        optional_input: Optional[str] = None
+        optional_input_with_default: Optional[str] = "optional_default"
+
+    class NestedNode(BaseNode):
+        input = NestedInputs.input
+        input_with_default = NestedInputs.input_with_default
+
+        class Outputs(BaseNode.Outputs):
+            result: str
+
+        def run(self) -> Outputs:
+            return self.Outputs(result=f"{self.input}-{self.input_with_default}")
+
+    class NestedWorkflow(BaseWorkflow[NestedInputs, BaseState]):
+        graph = NestedNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            result = NestedNode.Outputs.result
+
+    class MyInlineSubworkflowNode(InlineSubworkflowNode):
+        subworkflow_inputs = {
+            "input": "input",
+            "input_with_default": "input_with_default",
+            "optional_input": "optional_input",
+            "optional_input_with_default": "optional_input_with_default",
+        }
+        subworkflow = NestedWorkflow
+
+    class MainWorkflow(BaseWorkflow[MainInputs, BaseState]):
+        graph = MyInlineSubworkflowNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            result = MyInlineSubworkflowNode.Outputs.result
+
+    # WHEN the workflow is serialized
+    workflow_display = get_workflow_display(workflow_class=MainWorkflow)
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN the inline subworkflow node should have the correct input variables
+    inline_subworkflow_node = next(
+        node
+        for node in serialized_workflow["workflow_raw_data"]["nodes"]
+        if node["id"] == str(MyInlineSubworkflowNode.__id__)
+    )
+
+    input_variables = inline_subworkflow_node["data"]["input_variables"]
+    assert len(input_variables) == 4
+
+    input_var = next(var for var in input_variables if var["key"] == "input")
+    assert input_var["required"] is True
+    assert input_var["default"] is None
+    assert input_var["type"] == "STRING"
+
+    input_with_default_var = next(var for var in input_variables if var["key"] == "input_with_default")
+    assert input_with_default_var["required"] is False
+    assert input_with_default_var["default"] == {"type": "STRING", "value": "default"}
+    assert input_with_default_var["type"] == "STRING"
+
+    optional_input_var = next(var for var in input_variables if var["key"] == "optional_input")
+    assert optional_input_var["required"] is False
+    assert optional_input_var["default"] == {"type": "JSON", "value": None}
+    assert optional_input_var["type"] == "STRING"
+
+    optional_input_with_default_var = next(
+        var for var in input_variables if var["key"] == "optional_input_with_default"
+    )
+    assert optional_input_with_default_var["required"] is False
+    assert optional_input_with_default_var["default"] == {"type": "STRING", "value": "optional_default"}
+    assert optional_input_with_default_var["type"] == "STRING"