vellum-ai 0.14.68__tar.gz → 0.14.70__tar.gz

{vellum_ai-0.14.68 → vellum_ai-0.14.70}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vellum-ai
-Version: 0.14.68
+Version: 0.14.70
 Summary: 
 License: MIT
 Requires-Python: >=3.9,<4.0

{vellum_ai-0.14.68 → vellum_ai-0.14.70}/ee/vellum_cli/__init__.py

@@ -362,9 +362,12 @@ def images() -> None:
     "This field does not push multiple local tags of the passed in image.",
 )
 @click.option("--workspace", type=str, help="The specific Workspace config to use when pushing")
-def image_push(image: str, tag: Optional[List[str]] = None, workspace: Optional[str] = None) -> None:
+@click.option("--source", type=str, help="Path to Dockerfile to build before pushing")
+def image_push(
+    image: str, tag: Optional[List[str]] = None, workspace: Optional[str] = None, source: Optional[str] = None
+) -> None:
     """Push Docker image to Vellum"""
-    image_push_command(image, tag, workspace)
+    image_push_command(image, tag, workspace, source)
 
 
 @workflows.command(name="init")

{vellum_ai-0.14.68 → vellum_ai-0.14.70}/ee/vellum_cli/image_push.py

@@ -17,10 +17,33 @@ from vellum_cli.logger import handle_cli_error, load_cli_logger
 _SUPPORTED_ARCHITECTURE = "amd64"
 
 
-def image_push_command(image: str, tags: Optional[List[str]] = None, workspace: Optional[str] = None) -> None:
+def image_push_command(
+    image: str, tags: Optional[List[str]] = None, workspace: Optional[str] = None, source: Optional[str] = None
+) -> None:
     load_dotenv(dotenv_path=os.path.join(os.getcwd(), ".env"))
     logger = load_cli_logger()
     config = load_vellum_cli_config()
+
+    if source:
+        logger.info(f"Building Docker image from Dockerfile: {source}")
+
+        if not os.path.exists(source):
+            handle_cli_error(logger, "Dockerfile not found", f"Dockerfile does not exist: {source}")
+
+        source_dir = os.path.dirname(source)
+        dockerfile_name = os.path.basename(source)
+
+        build_result = subprocess.run(
+            ["docker", "buildx", "build", "-f", dockerfile_name, "--platform=linux/amd64", "-t", image, "."],
+            cwd=source_dir,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+
+        if build_result.returncode != 0:
+            handle_cli_error(logger, "Docker build failed", build_result.stderr.decode("utf-8"))
+
+        logger.info("Docker build completed successfully")
     workspace_config = next((w for w in config.workspaces if w.name == workspace), DEFAULT_WORKSPACE_CONFIG)
 
     api_key = os.getenv(workspace_config.api_key, None)

{vellum_ai-0.14.68 → vellum_ai-0.14.70}/ee/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_ai-0.14.68 → vellum_ai-0.14.70}/ee/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_ai-0.14.68 → vellum_ai-0.14.70}/ee/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_ai-0.14.68 → vellum_ai-0.14.70}/ee/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_ai-0.14.68 → vellum_ai-0.14.70}/ee/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_ai-0.14.68 → vellum_ai-0.14.70}/ee/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_ai-0.14.68 → vellum_ai-0.14.70}/ee/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_ai-0.14.68 → vellum_ai-0.14.70}/ee/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_ai-0.14.68 → vellum_ai-0.14.70}/ee/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_ai-0.14.68 → vellum_ai-0.14.70}/ee/vellum_ee/workflows/display/nodes/vellum/inline_prompt_node.py

@@ -18,10 +18,9 @@ _InlinePromptNodeType = TypeVar("_InlinePromptNodeType", bound=InlinePromptNode)
 
 
 class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generic[_InlinePromptNodeType]):
-    __serializable_inputs__ = {InlinePromptNode.prompt_inputs}
+    __serializable_inputs__ = {InlinePromptNode.prompt_inputs, InlinePromptNode.functions}
     __unserializable_attributes__ = {
         InlinePromptNode.blocks,
-        InlinePromptNode.functions,
         InlinePromptNode.parameters,
         InlinePromptNode.settings,
         InlinePromptNode.expand_meta,
@@ -29,7 +28,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
@@ -48,9 +47,10 @@ class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generi
         blocks: list = [
             self._generate_prompt_block(block, input_variable_id_by_name, [i]) for i, block in enumerate(node_blocks)
         ]
+
         functions = (
             [self._generate_function_tools(function, i) for i, function in enumerate(function_definitions)]
-            if function_definitions
+            if isinstance(function_definitions, list)
             else []
         )
         blocks.extend(functions)

{vellum_ai-0.14.68 → vellum_ai-0.14.70}/ee/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_ai-0.14.68 → vellum_ai-0.14.70}/ee/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_ai-0.14.68 → vellum_ai-0.14.70}/ee/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_ai-0.14.68 → vellum_ai-0.14.70}/ee/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_ai-0.14.68 → vellum_ai-0.14.70}/ee/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_ai-0.14.68 → vellum_ai-0.14.70}/ee/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_ai-0.14.68 → vellum_ai-0.14.70}/ee/vellum_ee/workflows/display/nodes/vellum/search_node.py

@@ -42,7 +42,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

{vellum_ai-0.14.68 → vellum_ai-0.14.70}/ee/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_ai-0.14.68 → vellum_ai-0.14.70}/ee/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_ai-0.14.70/ee/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"

{vellum_ai-0.14.68 → vellum_ai-0.14.70}/ee/vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_attributes_serialization.py

@@ -7,6 +7,7 @@ from vellum.client.types.chat_message import ChatMessage
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.references.constant import ConstantValueReference
+from vellum.workflows.references.environment_variable import EnvironmentVariableReference
 from vellum.workflows.references.lazy import LazyReference
 from vellum.workflows.references.vellum_secret import VellumSecretReference
 from vellum.workflows.state.base import BaseState
@@ -475,6 +476,21 @@ def test_serialize_node__node_execution(serialize_node):
     )
 
 
+def test_serialize_node__environment_variable(serialize_node):
+    class EnvironmentVariableGenericNode(BaseNode):
+        attr = EnvironmentVariableReference(name="API_KEY")
+
+    serialized_node = serialize_node(EnvironmentVariableGenericNode)
+
+    expected_value = {
+        "type": "ENVIRONMENT_VARIABLE",
+        "environment_variable": "API_KEY",
+    }
+
+    actual_value = serialized_node["attributes"][0]["value"]
+    assert actual_value == expected_value
+
+
 def test_serialize_node__coalesce(serialize_node):
     class CoalesceNodeA(BaseNode):
         class Outputs(BaseNode.Outputs):