vellum-ai 0.14.73__tar.gz → 0.14.74__tar.gz

{vellum_ai-0.14.73 → vellum_ai-0.14.74}/PKG-INFO

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

{vellum_ai-0.14.73 → vellum_ai-0.14.74}/ee/vellum_ee/workflows/display/nodes/vellum/inline_prompt_node.py

@@ -15,6 +15,20 @@ from vellum_ee.workflows.display.utils.expressions import serialize_value
 from vellum_ee.workflows.display.utils.vellum import infer_vellum_variable_type
 from vellum_ee.workflows.display.vellum import NodeInput
 
+
+def _contains_descriptors(obj):
+    """Check if an object contains any descriptors or references that need special handling."""
+    if isinstance(obj, BaseDescriptor):
+        return True
+    elif isinstance(obj, dict):
+        return any(_contains_descriptors(v) for v in obj.values())
+    elif isinstance(obj, (list, tuple)):
+        return any(_contains_descriptors(item) for item in obj)
+    elif hasattr(obj, "__dict__"):
+        return any(_contains_descriptors(getattr(obj, field)) for field in obj.__dict__)
+    return False
+
+
 _InlinePromptNodeType = TypeVar("_InlinePromptNodeType", bound=InlinePromptNode)
 
 
@@ -23,7 +37,6 @@ class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generi
         InlinePromptNode.prompt_inputs,
     }
     __unserializable_attributes__ = {
-        InlinePromptNode.parameters,
         InlinePromptNode.settings,
         InlinePromptNode.expand_meta,
         InlinePromptNode.request_options,
@@ -46,11 +59,15 @@ 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)
-            if not isinstance(block, BaseDescriptor)
-        ]
+        has_descriptors = _contains_descriptors(node_blocks)
+
+        blocks: list = []
+        if not has_descriptors:
+            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 = (
             [self._generate_function_tools(function, i) for i, function in enumerate(function_definitions)]
@@ -72,7 +89,7 @@ class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generi
                 "target_handle_id": str(self.get_target_handle_id()),
                 "variant": "INLINE",
                 "exec_config": {
-                    "parameters": raise_if_descriptor(node.parameters).dict(),
+                    "parameters": self._serialize_parameters(node.parameters, display_context),
                     "input_variables": [prompt_input.dict() for prompt_input in prompt_inputs],
                     "prompt_template_block_data": {
                         "version": 1,
@@ -156,6 +173,7 @@ class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generi
             }
 
         elif prompt_block.block_type == "CHAT_MESSAGE":
+
             chat_properties: JsonObject = {
                 "chat_role": prompt_block.chat_role,
                 "chat_source": prompt_block.chat_source,
@@ -253,3 +271,14 @@ class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generi
                 raise ValueError(f"Failed to serialize attribute '{attribute.name}': {e}")
 
         return attributes
+
+    def _serialize_parameters(self, parameters, display_context: "WorkflowDisplayContext") -> JsonObject:
+        """Serialize parameters, returning empty object when nested descriptors are detected."""
+        params = raise_if_descriptor(parameters)
+        if not params:
+            return {}
+
+        if _contains_descriptors(params):
+            return {}
+
+        return params.dict()

{vellum_ai-0.14.73 → vellum_ai-0.14.74}/ee/vellum_ee/workflows/display/nodes/vellum/tests/test_prompt_node.py

@@ -2,6 +2,7 @@ import pytest
 from uuid import UUID
 from typing import Type
 
+from vellum.client.types.prompt_parameters import PromptParameters
 from vellum.client.types.variable_prompt_block import VariablePromptBlock
 from vellum.workflows import BaseWorkflow
 from vellum.workflows.inputs import BaseInputs
@@ -280,3 +281,104 @@ def test_serialize_node__port_groups():
 
     # AND the legacy source_handle_id should be the default port
     assert my_prompt_node["data"]["source_handle_id"] == "149d97a4-3da3-44a9-95f7-ea7b8d38b877"
+
+
+def test_serialize_node__prompt_parameters__dynamic_references():
+    # GIVEN input definition
+    class MyInputs(BaseInputs):
+        input_value: str
+
+    # AND a prompt node with PromptParameters containing dynamic references
+    class DynamicPromptNode(InlinePromptNode):
+        blocks = []
+        ml_model = "gpt-4o"
+        parameters = PromptParameters(custom_parameters={"json_schema": MyInputs.input_value})
+
+    # AND a workflow with the prompt node
+    class Workflow(BaseWorkflow[MyInputs, BaseState]):
+        graph = DynamicPromptNode
+
+    # WHEN the workflow is serialized
+    workflow_display = get_workflow_display(workflow_class=Workflow)
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN the node should properly serialize the PromptParameters
+    dynamic_prompt_node = next(
+        node
+        for node in serialized_workflow["workflow_raw_data"]["nodes"]
+        if node["id"] == str(DynamicPromptNode.__id__)
+    )
+
+    # AND the parameters should be properly serialized in exec_config
+    exec_config = dynamic_prompt_node["data"]["exec_config"]
+    assert "parameters" in exec_config
+
+    parameters = exec_config["parameters"]
+    assert parameters == {}
+
+    # AND the parameters should also be serialized in the attributes array
+    parameters_attribute = next(
+        (attr for attr in dynamic_prompt_node.get("attributes", []) if attr["name"] == "parameters"), None
+    )
+    assert parameters_attribute is not None
+    assert parameters_attribute["name"] == "parameters"
+    assert parameters_attribute["value"]["type"] == "DICTIONARY_REFERENCE"
+    assert parameters_attribute["value"]["entries"] == [
+        {
+            "id": "6b63ff96-a2eb-4c6e-bad1-bde01605fa86",
+            "key": "stop",
+            "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+        },
+        {
+            "id": "265a1c17-2089-4ac1-b2ce-361b6b9a3335",
+            "key": "temperature",
+            "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+        },
+        {
+            "id": "699976ec-8ec2-476a-a011-7cf810a8a307",
+            "key": "max_tokens",
+            "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+        },
+        {
+            "id": "a87e23da-9794-41ff-ba80-c3a77e976e75",
+            "key": "top_p",
+            "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+        },
+        {
+            "id": "18eb53c2-ec1a-4115-9f21-083af430df67",
+            "key": "top_k",
+            "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+        },
+        {
+            "id": "295509a2-5837-452c-893d-f47b67c63c8a",
+            "key": "frequency_penalty",
+            "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+        },
+        {
+            "id": "5fc64379-5566-426a-a909-dd56c3305aa5",
+            "key": "presence_penalty",
+            "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+        },
+        {
+            "id": "5d326da0-c096-4425-8bf1-3a18764e96e3",
+            "key": "logit_bias",
+            "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+        },
+        {
+            "id": "cd1a0e1b-6667-48a0-9964-257e1ec8851d",
+            "key": "custom_parameters",
+            "value": {
+                "entries": [
+                    {
+                        "id": "a9a3092e-dd18-4533-b6b5-24588ebd8f7f",
+                        "key": "json_schema",
+                        "value": {
+                            "input_variable_id": "c02d1201-86d1-4364-b3b3-4fc6824db8a4",
+                            "type": "WORKFLOW_INPUT",
+                        },
+                    }
+                ],
+                "type": "DICTIONARY_REFERENCE",
+            },
+        },
+    ]

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

@@ -1,7 +1,10 @@
+import pytest
+from dataclasses import dataclass
 from uuid import uuid4
 from typing import List
 
 from deepdiff import DeepDiff
+from pydantic import BaseModel
 
 from vellum.client.types.chat_message import ChatMessage
 from vellum.workflows.inputs.base import BaseInputs
@@ -70,6 +73,28 @@ def test_serialize_node__constant_value(serialize_node):
     )
 
 
+@pytest.mark.parametrize(
+    "boolean_value, expected_value",
+    [
+        (True, True),
+        (False, False),
+    ],
+)
+def test_serialize_node__constant_boolean_value(serialize_node, boolean_value, expected_value):
+    class BooleanValueGenericNode(BaseNode):
+        attr: bool = boolean_value
+
+    serialized_node = serialize_node(BooleanValueGenericNode)
+
+    assert serialized_node["attributes"][0]["value"] == {
+        "type": "CONSTANT_VALUE",
+        "value": {
+            "type": "JSON",
+            "value": expected_value,
+        },
+    }
+
+
 def test_serialize_node__constant_value_reference(serialize_node):
     class ConstantValueReferenceGenericNode(BaseNode):
         attr: str = ConstantValueReference("hello")
@@ -580,3 +605,68 @@ def test_serialize_node__coalesce(serialize_node):
         serialized_node,
         ignore_order=True,
     )
+
+
+def test_serialize_node__dataclass_with_node_output_reference(serialize_node):
+    @dataclass
+    class MyDataClass:
+        name: str
+        node_ref: str
+
+    class NodeWithOutput(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            result: str
+
+    class NodeWithOutputDisplay(BaseNodeDisplay[NodeWithOutput]):
+        pass
+
+    class GenericNodeWithDataclass(BaseNode):
+        attr = MyDataClass(name="test", node_ref=NodeWithOutput.Outputs.result)
+
+    node_output_id = uuid4()
+    serialized_node = serialize_node(
+        node_class=GenericNodeWithDataclass,
+        global_node_displays={NodeWithOutput: NodeWithOutputDisplay()},
+        global_node_output_displays={
+            NodeWithOutput.Outputs.result: (NodeWithOutput, NodeOutputDisplay(id=node_output_id, name="result"))
+        },
+    )
+
+    attr_value = serialized_node["attributes"][0]["value"]
+    assert attr_value["type"] == "DICTIONARY_REFERENCE"
+
+    assert any(
+        entry["key"] == "node_ref" and entry["value"]["type"] == "NODE_OUTPUT" for entry in attr_value["entries"]
+    )
+
+
+def test_serialize_node__pydantic_with_node_output_reference(serialize_node):
+    class MyPydanticModel(BaseModel):
+        name: str
+        node_ref: str
+
+    class NodeWithOutput(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            result: str
+
+    class NodeWithOutputDisplay(BaseNodeDisplay[NodeWithOutput]):
+        pass
+
+    class GenericNodeWithPydantic(BaseNode):
+        attr = MyPydanticModel(name="test", node_ref=NodeWithOutput.Outputs.result)
+
+    node_output_id = uuid4()
+    serialized_node = serialize_node(
+        node_class=GenericNodeWithPydantic,
+        global_node_displays={NodeWithOutput: NodeWithOutputDisplay()},
+        global_node_output_displays={
+            NodeWithOutput.Outputs.result: (NodeWithOutput, NodeOutputDisplay(id=node_output_id, name="result"))
+        },
+    )
+
+    attr_value = serialized_node["attributes"][0]["value"]
+    assert attr_value["type"] == "DICTIONARY_REFERENCE"
+
+    assert any(
+        entry["key"] == "node_ref" and entry["value"]["type"] == "NODE_OUTPUT" for entry in attr_value["entries"]
+    )

{vellum_ai-0.14.73 → vellum_ai-0.14.74}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_inline_prompt_node_serialization.py

@@ -240,6 +240,27 @@ def test_serialize_workflow():
                         },
                     },
                 },
+                {
+                    "id": "2b98319f-f43d-42d9-a8b0-b148d5de0a2c",
+                    "name": "parameters",
+                    "value": {
+                        "type": "CONSTANT_VALUE",
+                        "value": {
+                            "type": "JSON",
+                            "value": {
+                                "stop": [],
+                                "temperature": 0.0,
+                                "max_tokens": 4096,
+                                "top_p": 1.0,
+                                "top_k": 0,
+                                "frequency_penalty": 0.0,
+                                "presence_penalty": 0.0,
+                                "logit_bias": None,
+                                "custom_parameters": None,
+                            },
+                        },
+                    },
+                },
             ],
         },
         prompt_node,
@@ -437,3 +458,99 @@ def test_serialize_workflow_with_descriptor_blocks():
             },
         }
     ]
+
+
+def test_serialize_workflow_with_nested_descriptor_blocks():
+    """Test that serialization handles BaseDescriptor instances nested in ChatMessageBlock.blocks."""
+
+    class TestInputs(BaseInputs):
+        noun: str
+
+    class UpstreamNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            results: list
+
+        def run(self) -> Outputs:
+            return self.Outputs(results=["test"])
+
+    chat_block = ChatMessagePromptBlock(chat_role="SYSTEM", blocks=[JinjaPromptBlock(template="Hello")])
+
+    class TestInlinePromptNodeWithNestedDescriptorBlocks(InlinePromptNode):
+        ml_model = "gpt-4o"
+        blocks = [chat_block]
+        prompt_inputs = {"noun": TestInputs.noun}
+
+    object.__setattr__(chat_block, "blocks", [UpstreamNode.Outputs.results[0]])
+
+    class TestWorkflow(BaseWorkflow[TestInputs, BaseState]):
+        graph = UpstreamNode >> TestInlinePromptNodeWithNestedDescriptorBlocks
+
+    workflow_display = get_workflow_display(workflow_class=TestWorkflow)
+    serialized: dict = workflow_display.serialize()
+
+    prompt_nodes = [node for node in serialized["workflow_raw_data"]["nodes"] if node["type"] == "PROMPT"]
+    prompt_node = prompt_nodes[0]
+
+    blocks = prompt_node["data"]["exec_config"]["prompt_template_block_data"]["blocks"]
+    descriptor_blocks = [block for block in blocks if not isinstance(block, dict) or not block.get("block_type")]
+    assert len(descriptor_blocks) == 0, "BaseDescriptor blocks should not appear in serialized blocks"
+
+    blocks_attr = next((attr for attr in prompt_node["attributes"] if attr["name"] == "blocks"), None)
+    assert blocks_attr is not None, "blocks attribute should be present when blocks contain nested BaseDescriptor"
+    assert blocks_attr["value"]["type"] == "ARRAY_REFERENCE", "blocks attribute should be serialized as ARRAY_REFERENCE"
+    assert blocks_attr["value"]["items"] == [
+        {
+            "entries": [
+                {
+                    "id": "24a203be-3cba-4b20-bc84-9993a476c120",
+                    "key": "block_type",
+                    "value": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "CHAT_MESSAGE"}},
+                },
+                {
+                    "id": "c06269e6-f74c-4860-8fa5-22dcbdc89399",
+                    "key": "state",
+                    "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+                },
+                {
+                    "id": "dd9c0d43-b931-4dc8-8b3a-a7507ddff0c1",
+                    "key": "cache_config",
+                    "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+                },
+                {
+                    "id": "bef22f2b-0b6e-4910-88cc-6df736d2e20e",
+                    "key": "chat_role",
+                    "value": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "SYSTEM"}},
+                },
+                {
+                    "id": "c0beec30-f85e-4a78-a3fb-baee54a692f8",
+                    "key": "chat_source",
+                    "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+                },
+                {
+                    "id": "f601f4f2-62fe-4697-9fe0-99ca8aa64500",
+                    "key": "chat_message_unterminated",
+                    "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+                },
+                {
+                    "id": "ad550008-64e3-44a3-a32a-84ec226db31c",
+                    "key": "blocks",
+                    "value": {
+                        "items": [
+                            {
+                                "lhs": {
+                                    "node_id": "9fe5d3a3-7d26-4692-aa2d-e67c673b0c2b",
+                                    "node_output_id": "92f9a1b7-d33b-4f00-b4c2-e6f58150e166",
+                                    "type": "NODE_OUTPUT",
+                                },
+                                "operator": "accessField",
+                                "rhs": {"type": "CONSTANT_VALUE", "value": {"type": "NUMBER", "value": 0.0}},
+                                "type": "BINARY_EXPRESSION",
+                            }
+                        ],
+                        "type": "ARRAY_REFERENCE",
+                    },
+                },
+            ],
+            "type": "DICTIONARY_REFERENCE",
+        }
+    ]

{vellum_ai-0.14.73 → vellum_ai-0.14.74}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_inline_workflow_serialization.py

@@ -131,6 +131,8 @@ def test_serialize_workflow():
                         "value": [
                             {
                                 "type": "INLINE_WORKFLOW",
+                                "name": "BasicInlineSubworkflowWorkflow",
+                                "description": "\n    A workflow that gets the weather for a given city and date.\n    ",  # noqa: E501
                                 "exec_config": {
                                     "workflow_raw_data": {
                                         "nodes": [
@@ -410,6 +412,11 @@ def test_serialize_workflow():
                 "name": "function_configs",
                 "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
             },
+            {
+                "id": "1668419e-a193-43a5-8a97-3394e89bf278",
+                "name": "max_prompt_iterations",
+                "value": {"type": "CONSTANT_VALUE", "value": {"type": "NUMBER", "value": 5.0}},
+            },
         ],
         "outputs": [
             {"id": "e62bc785-a914-4066-b79e-8c89a5d0ec6c", "name": "text", "type": "STRING", "value": None},

{vellum_ai-0.14.73 → vellum_ai-0.14.74}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_serialization.py

@@ -131,6 +131,8 @@ def test_serialize_workflow():
                         "value": [
                             {
                                 "type": "CODE_EXECUTION",
+                                "name": "get_current_weather",
+                                "description": "\n    Get the current weather in a given location.\n    ",
                                 "definition": {
                                     "state": None,
                                     "cache_config": None,
@@ -183,6 +185,11 @@ def test_serialize_workflow():
                     ],
                 },
             },
+            {
+                "id": "1668419e-a193-43a5-8a97-3394e89bf278",
+                "name": "max_prompt_iterations",
+                "value": {"type": "CONSTANT_VALUE", "value": {"type": "NUMBER", "value": 5.0}},
+            },
         ],
         "outputs": [
             {"id": "e62bc785-a914-4066-b79e-8c89a5d0ec6c", "name": "text", "type": "STRING", "value": None},

vellum_ai-0.14.74/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_workflow_deployment_serialization.py

@@ -0,0 +1,62 @@
+from deepdiff import DeepDiff
+
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+from tests.workflows.basic_tool_calling_node_workflow_deployment.workflow import (
+    BasicToolCallingNodeWorkflowDeploymentWorkflow,
+)
+
+
+def test_serialize_workflow():
+    # GIVEN a Workflow that uses a generic node
+    # WHEN we serialize it
+    workflow_display = get_workflow_display(workflow_class=BasicToolCallingNodeWorkflowDeploymentWorkflow)
+
+    serialized_workflow: dict = workflow_display.serialize()
+    # THEN we should get a serialized representation of the Workflow
+    assert serialized_workflow.keys() == {
+        "workflow_raw_data",
+        "input_variables",
+        "state_variables",
+        "output_variables",
+    }
+
+    # AND its input variables should be what we expect
+    input_variables = serialized_workflow["input_variables"]
+    assert len(input_variables) == 1
+
+    # AND its output variables should be what we expect
+    output_variables = serialized_workflow["output_variables"]
+    assert len(output_variables) == 2
+    assert not DeepDiff(
+        [
+            {"id": "3626cfa6-76f8-465e-b156-c809e3a2cee9", "key": "text", "type": "STRING"},
+            {"id": "cb82117a-d649-4c3e-9342-c552028fa2ad", "key": "chat_history", "type": "CHAT_HISTORY"},
+        ],
+        output_variables,
+        ignore_order=True,
+    )
+
+    # AND its raw data should be what we expect
+    workflow_raw_data = serialized_workflow["workflow_raw_data"]
+    tool_calling_node = workflow_raw_data["nodes"][1]
+    function_attributes = next(attr for attr in tool_calling_node["attributes"] if attr["name"] == "functions")
+    assert function_attributes == {
+        "id": "73a94e3c-1935-4308-a68a-ecd5441804b7",
+        "name": "functions",
+        "value": {
+            "type": "CONSTANT_VALUE",
+            "value": {
+                "type": "JSON",
+                "value": [
+                    {
+                        "type": "WORKFLOW_DEPLOYMENT",
+                        "name": "deployment_1",
+                        "description": "Workflow deployment for deployment_1",
+                        "deployment": "deployment_1",
+                        "release_tag": "LATEST",
+                    }
+                ],
+            },
+        },
+    }

{vellum_ai-0.14.73 → vellum_ai-0.14.74}/ee/vellum_ee/workflows/display/utils/expressions.py

@@ -1,5 +1,8 @@
+from dataclasses import asdict, is_dataclass
 from typing import TYPE_CHECKING, Any, Dict, List, cast
 
+from pydantic import BaseModel
+
 from vellum.client.types.logical_operator import LogicalOperator
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.expressions.accessor import AccessorExpression
@@ -39,6 +42,7 @@ from vellum.workflows.references.state_value import StateValueReference
 from vellum.workflows.references.vellum_secret import VellumSecretReference
 from vellum.workflows.references.workflow_input import WorkflowInputReference
 from vellum.workflows.types.core import JsonArray, JsonObject
+from vellum.workflows.types.definition import DeploymentDefinition
 from vellum.workflows.types.generics import is_workflow_class
 from vellum.workflows.utils.uuids import uuid4_from_hash
 from vellum_ee.workflows.display.utils.exceptions import UnsupportedSerializationException
@@ -290,6 +294,10 @@ def serialize_value(display_context: "WorkflowDisplayContext", value: Any) -> Js
                 "items": cast(JsonArray, serialized_items),  # list[JsonObject] -> JsonArray
             }
 
+    if is_dataclass(value) and not isinstance(value, type):
+        dict_value = asdict(value)
+        return serialize_value(display_context, dict_value)
+
     if isinstance(value, dict):
         serialized_entries: List[Dict[str, Any]] = [
             {
@@ -321,18 +329,41 @@ def serialize_value(display_context: "WorkflowDisplayContext", value: Any) -> Js
         from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
 
         workflow_display = get_workflow_display(workflow_class=value)
-        value = workflow_display.serialize()
+        serialized_value: dict = workflow_display.serialize()
+        name = serialized_value["workflow_raw_data"]["definition"]["name"]
+        description = value.__doc__ or ""
         return {
             "type": "CONSTANT_VALUE",
             "value": {
                 "type": "JSON",
                 "value": {
                     "type": "INLINE_WORKFLOW",
-                    "exec_config": value,
+                    "name": name,
+                    "description": description,
+                    "exec_config": serialized_value,
+                },
+            },
+        }
+
+    if isinstance(value, DeploymentDefinition):
+        return {
+            "type": "CONSTANT_VALUE",
+            "value": {
+                "type": "JSON",
+                "value": {
+                    "type": "WORKFLOW_DEPLOYMENT",
+                    "name": value.deployment,
+                    "description": f"Workflow deployment for {value.deployment}",
+                    "deployment": value.deployment,
+                    "release_tag": value.release_tag,
                 },
             },
         }
 
+    if isinstance(value, BaseModel):
+        dict_value = value.model_dump()
+        return serialize_value(display_context, dict_value)
+
     if not isinstance(value, BaseDescriptor):
         vellum_value = primitive_to_vellum_value(value)
         return {

{vellum_ai-0.14.73 → vellum_ai-0.14.74}/ee/vellum_ee/workflows/display/workflows/base_workflow_display.py

@@ -690,8 +690,7 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
         try:
             display_module = importlib.import_module(full_workflow_display_module_path)
         except ModuleNotFoundError:
-            logger.exception("Failed to import workflow display module: %s", full_workflow_display_module_path)
-            return None
+            return BaseWorkflowDisplay._gather_event_display_context_from_workflow_crawling(module_path, workflow_class)
 
         WorkflowDisplayClass: Optional[Type[BaseWorkflowDisplay]] = None
         for name, definition in display_module.__dict__.items():
@@ -708,11 +707,26 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
             WorkflowDisplayClass = definition
             break
 
-        if not WorkflowDisplayClass:
-            logger.exception("No workflow display class found in module: %s", full_workflow_display_module_path)
-            return None
+        if WorkflowDisplayClass:
+            return WorkflowDisplayClass().get_event_display_context()
+
+        return BaseWorkflowDisplay._gather_event_display_context_from_workflow_crawling(module_path, workflow_class)
+
+    @staticmethod
+    def _gather_event_display_context_from_workflow_crawling(
+        module_path: str,
+        workflow_class: Optional[Type[BaseWorkflow]] = None,
+    ) -> Union[WorkflowEventDisplayContext, None]:
+        try:
+            if workflow_class is None:
+                workflow_class = BaseWorkflow.load_from_module(module_path)
 
-        return WorkflowDisplayClass().get_event_display_context()
+            workflow_display = get_workflow_display(workflow_class=workflow_class)
+            return workflow_display.get_event_display_context()
+
+        except ModuleNotFoundError:
+            logger.exception("Failed to load workflow from module %s", module_path)
+            return None
 
     def get_event_display_context(self):
         display_context = self.display_context