vellum-ai 0.14.63__py3-none-any.whl → 1.13.5__py3-none-any.whl

vellum_ee/workflows/display/tests/workflow_serialization/test_chat_message_dict_reference_serialization.py

@@ -0,0 +1,129 @@
+from typing import List
+
+from vellum import ChatMessage
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.nodes.displayable.set_state_node import SetStateNode
+from vellum.workflows.state.base import BaseState
+from vellum_ee.workflows.display.workflows.base_workflow_display import BaseWorkflowDisplay
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+
+def test_serialize_chat_message_dict_reference_with_definition():
+    """Test that ChatMessage dictionary references are serialized with definition field."""
+
+    class State(BaseState):
+        chat_history: List[ChatMessage] = []
+
+    class Inputs(BaseInputs):
+        message: str
+
+    class StoreUserMessage(SetStateNode[State]):
+        operations = {
+            "chat_history": State.chat_history
+            + ChatMessage(
+                text=Inputs.message,
+                role="USER",
+            ),
+        }
+
+    class TestWorkflow(BaseWorkflow[Inputs, State]):
+        graph = StoreUserMessage
+
+        class Outputs(BaseWorkflow.Outputs):
+            chat_history = State.chat_history
+
+    workflow_display = get_workflow_display(workflow_class=TestWorkflow)
+    serialized_workflow = workflow_display.serialize()
+
+    workflow_raw_data = serialized_workflow["workflow_raw_data"]
+    assert isinstance(workflow_raw_data, dict)
+    nodes = workflow_raw_data["nodes"]
+    assert isinstance(nodes, list)
+
+    set_state_node = next(
+        node
+        for node in nodes
+        if isinstance(node, dict) and node.get("type") == "GENERIC" and node.get("label") == "Store User Message"
+    )
+
+    assert isinstance(set_state_node, dict)
+    assert "attributes" in set_state_node
+    attributes = set_state_node["attributes"]
+    assert isinstance(attributes, list)
+
+    operations_attribute = next(
+        attribute for attribute in attributes if isinstance(attribute, dict) and attribute.get("name") == "operations"
+    )
+    assert isinstance(operations_attribute, dict)
+
+    assert operations_attribute == {
+        "id": "b1a79be0-9b4f-4236-aaba-a0ebd56e2079",
+        "name": "operations",
+        "value": {
+            "type": "DICTIONARY_REFERENCE",
+            "entries": [
+                {
+                    "id": "160c6ef1-30b4-40ff-8cad-88d73bc6ea54",
+                    "key": "chat_history",
+                    "value": {
+                        "type": "BINARY_EXPRESSION",
+                        "lhs": {"type": "WORKFLOW_STATE", "state_variable_id": "fff74a8e-752e-4088-9d3e-493e9162bda5"},
+                        "operator": "+",
+                        "rhs": {
+                            "type": "DICTIONARY_REFERENCE",
+                            "entries": [
+                                {
+                                    "id": "f50f80a5-3b36-4077-a90f-c13b38fd7919",
+                                    "key": "text",
+                                    "value": {
+                                        "type": "WORKFLOW_INPUT",
+                                        "input_variable_id": "cb4bd466-58e9-4ecd-a2b3-22ce280a0422",
+                                    },
+                                },
+                                {
+                                    "id": "2047e859-8c1a-42b9-b4d4-b6d6fc7b33b2",
+                                    "key": "role",
+                                    "value": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "USER"}},
+                                },
+                                {
+                                    "id": "ca0c0a31-e903-4908-998d-10916e287d77",
+                                    "key": "content",
+                                    "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+                                },
+                                {
+                                    "id": "78565b95-23a0-4be4-a9ce-89893a60f458",
+                                    "key": "source",
+                                    "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+                                },
+                            ],
+                            "definition": {
+                                "name": "ChatMessage",
+                                "module": ["vellum", "client", "types", "chat_message"],
+                            },
+                        },
+                    },
+                }
+            ],
+        },
+    }
+
+
+def test_serialize_chat_message_trigger_with_message_parameter():
+    """Test that ChatMessageTrigger with message parameter serializes correctly in dataset."""
+    # GIVEN a workflow module with a ChatMessageTrigger that has a message parameter
+    module_path = "tests.workflows.test_chat_message_trigger_serialization"
+
+    # WHEN we serialize the module
+    result = BaseWorkflowDisplay.serialize_module(module_path)
+
+    # THEN the dataset should contain the trigger's message in inputs
+    assert result.dataset is not None
+    assert isinstance(result.dataset, list)
+    assert len(result.dataset) == 1
+
+    # AND the message should be serialized in the inputs as array format
+    dataset_row = result.dataset[0]
+    assert dataset_row["label"] == "New conversation"
+    assert "inputs" in dataset_row
+    assert dataset_row["inputs"]["message"] == [{"type": "STRING", "value": "I want to tweet about AI agents"}]

vellum_ee/workflows/display/tests/workflow_serialization/test_chat_message_trigger_serialization.py

@@ -0,0 +1,412 @@
+"""Tests for ChatMessageTrigger serialization."""
+
+from typing import Optional
+
+from vellum import ChatMessage, ChatMessagePromptBlock, JinjaPromptBlock
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.inputs import BaseInputs
+from vellum.workflows.nodes import InlinePromptNode
+from vellum.workflows.nodes.bases import BaseNode
+from vellum.workflows.ports import Port
+from vellum.workflows.references import LazyReference
+from vellum.workflows.state.base import BaseState
+from vellum.workflows.triggers.chat_message import ChatMessageTrigger
+from vellum_ee.workflows.display.utils.exceptions import (
+    StateValidationError,
+    TriggerValidationError,
+    WorkflowValidationError,
+)
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+from tests.workflows.chat_message_trigger_execution.workflows.simple_chat_workflow import SimpleChatWorkflow
+
+
+def test_simple_chat_workflow_serialization():
+    """SimpleChatWorkflow from tests/workflows serializes correctly with ChatMessageTrigger."""
+
+    # GIVEN a Workflow that uses a ChatMessageTrigger
+    # WHEN we serialize it
+    workflow_display = get_workflow_display(workflow_class=SimpleChatWorkflow)
+    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",
+        "triggers",
+    }
+
+    # AND the triggers should be serialized correctly
+    assert serialized_workflow["triggers"] == [
+        {
+            "id": "9e14c49b-c6d9-4fe5-9ff2-835fd695fe5f",
+            "type": "CHAT_MESSAGE",
+            "name": "chat",
+            "attributes": [
+                {
+                    "id": "5edbfd78-b634-4305-b2ad-d9feecbd5e5f",
+                    "key": "message",
+                    "type": "ARRAY",
+                    "required": True,
+                    "default": {
+                        "type": "ARRAY",
+                        "value": None,
+                    },
+                    "extensions": None,
+                    "schema": {
+                        "anyOf": [
+                            {"type": "string"},
+                            {
+                                "type": "array",
+                                "items": {
+                                    "$ref": "#/$defs/vellum.client.types.array_chat_message_content_item.ArrayChatMessageContentItem"  # noqa: E501
+                                },
+                            },
+                        ]
+                    },
+                }
+            ],
+            "exec_config": {
+                "output": {
+                    "type": "WORKFLOW_OUTPUT",
+                    "output_variable_id": "cc1208e9-c043-47f4-abea-c01ac0dbf04c",
+                },
+            },
+            "display_data": {
+                "label": "Chat Message",
+                "position": {
+                    "x": 0.0,
+                    "y": 0.0,
+                },
+                "z_index": 0,
+                "icon": "vellum:icon:message-dots",
+                "color": "blue",
+            },
+        }
+    ]
+
+
+class ResponseNode(BaseNode):
+    """Node that returns a simple response."""
+
+    class Outputs(BaseNode.Outputs):
+        response: str = "Hello!"
+
+
+class ChatTriggerWithoutOutput(ChatMessageTrigger):
+    """Chat trigger without Config.output specified."""
+
+    pass
+
+
+class WorkflowWithUnspecifiedChatTriggerOutput(BaseWorkflow[BaseInputs, BaseState]):
+    """Workflow using ChatTrigger without output specified."""
+
+    graph = ChatTriggerWithoutOutput >> ResponseNode
+
+    class Outputs(BaseWorkflow.Outputs):
+        response = ResponseNode.Outputs.response
+
+
+def test_chat_message_trigger_validation__output_not_specified():
+    """
+    Tests that serialization adds TriggerValidationError to errors when Chat Trigger output is not specified.
+    """
+
+    # GIVEN a Workflow that uses a ChatMessageTrigger without Config.output specified
+    workflow_display = get_workflow_display(workflow_class=WorkflowWithUnspecifiedChatTriggerOutput)
+
+    # WHEN we serialize the workflow
+    workflow_display.serialize()
+
+    # THEN the display_context should contain a TriggerValidationError
+    errors = list(workflow_display.display_context.errors)
+    assert len(errors) == 1
+
+    # AND the error should be a TriggerValidationError with the expected message
+    error = errors[0]
+    assert isinstance(error, TriggerValidationError)
+    assert "Chat Trigger output must be specified" in str(error)
+
+
+def test_chat_message_trigger_graph_with_duplicate_edges():
+    """ChatMessageTrigger graph with duplicate edges should deduplicate and report error."""
+
+    # GIVEN a ChatMessageTrigger subclass
+    class Chat(ChatMessageTrigger):
+        pass
+
+    class Orchestrator(BaseNode):
+        pass
+
+    # AND a workflow with a graph containing duplicate edges from trigger to node
+    class TestWorkflow(BaseWorkflow[BaseInputs, BaseState]):
+        graph = {
+            Chat >> Orchestrator,
+            Chat >> Orchestrator,
+        }
+
+    # WHEN we serialize the workflow
+    workflow_display = get_workflow_display(workflow_class=TestWorkflow)
+    result: dict = workflow_display.serialize()
+
+    # THEN the workflow should serialize successfully
+    assert "workflow_raw_data" in result
+    assert "triggers" in result
+
+    # AND there should be a CHAT_MESSAGE trigger
+    triggers: list = result["triggers"]
+    assert len(triggers) == 1
+    assert triggers[0]["type"] == "CHAT_MESSAGE"
+
+    # AND there should NOT be a MANUAL trigger
+    manual_triggers = [t for t in triggers if t.get("type") == "MANUAL"]
+    assert len(manual_triggers) == 0
+
+    # AND there should NOT be an ENTRYPOINT node
+    workflow_raw_data: dict = result["workflow_raw_data"]
+    nodes: list = workflow_raw_data["nodes"]
+    entrypoint_nodes = [n for n in nodes if isinstance(n, dict) and n.get("type") == "ENTRYPOINT"]
+    assert len(entrypoint_nodes) == 0, "ChatMessageTrigger workflows should NOT have an ENTRYPOINT node"
+
+    # AND edges should have unique IDs (no duplicates)
+    edges: list = workflow_raw_data["edges"]
+    edge_ids = [e["id"] for e in edges if isinstance(e, dict)]
+    assert len(edge_ids) == len(set(edge_ids)), f"Duplicate edge IDs found: {edge_ids}"
+
+    # AND there should be an error about the duplicate edge
+    errors = list(workflow_display.display_context.errors)
+    duplicate_edge_errors = [
+        e for e in errors if isinstance(e, WorkflowValidationError) and "duplicate" in str(e).lower()
+    ]
+    assert len(duplicate_edge_errors) == 1, f"Expected 1 duplicate edge error, got {len(duplicate_edge_errors)}"
+
+
+def test_graph_with_shared_prefix_different_paths__no_validation_error():
+    """Graph with shared prefix but different paths should not produce validation errors."""
+
+    # GIVEN a ChatMessageTrigger subclass as the entry point
+    class A(ChatMessageTrigger):
+        pass
+
+    # AND nodes for a workflow
+    class B(BaseNode):
+        pass
+
+    class C(BaseNode):
+        pass
+
+    class D(BaseNode):
+        pass
+
+    # AND a workflow with a graph containing shared prefix but different paths
+    class TestWorkflow(BaseWorkflow[BaseInputs, BaseState]):
+        graph = {
+            A >> B >> C,
+            A >> B >> D,
+        }
+
+    # WHEN we serialize the workflow
+    workflow_display = get_workflow_display(workflow_class=TestWorkflow)
+    result: dict = workflow_display.serialize()
+
+    # THEN the workflow should serialize successfully
+    assert "workflow_raw_data" in result
+
+    # AND there should be NO validation errors about duplicates
+    errors = list(workflow_display.display_context.errors)
+    duplicate_errors = [e for e in errors if isinstance(e, WorkflowValidationError) and "duplicate" in str(e).lower()]
+    assert len(duplicate_errors) == 0, f"Expected no duplicate errors, got {len(duplicate_errors)}: {duplicate_errors}"
+
+
+def test_graph_with_duplicate_paths__validation_error():
+    """Graph with duplicate paths should produce a validation error."""
+
+    # GIVEN nodes for a workflow
+    class A(BaseNode):
+        pass
+
+    class B(BaseNode):
+        pass
+
+    class C(BaseNode):
+        pass
+
+    # AND a workflow with a graph containing duplicate paths
+    class TestWorkflow(BaseWorkflow[BaseInputs, BaseState]):
+        graph = {
+            A >> B >> C,
+            A >> B >> C,
+        }
+
+    # WHEN we serialize the workflow
+    workflow_display = get_workflow_display(workflow_class=TestWorkflow)
+    result: dict = workflow_display.serialize()
+
+    # THEN the workflow should serialize successfully
+    assert "workflow_raw_data" in result
+
+    # AND there should be a validation error about the duplicate path
+    errors = list(workflow_display.display_context.errors)
+    duplicate_errors = [e for e in errors if isinstance(e, WorkflowValidationError) and "duplicate" in str(e).lower()]
+    assert len(duplicate_errors) == 1, f"Expected 1 duplicate error, got {len(duplicate_errors)}"
+
+
+def test_graph_with_different_ports_same_target__no_validation_error():
+    """Graph with different ports from same node to same target should not produce validation errors."""
+
+    # GIVEN a node with multiple ports
+    class A(BaseNode):
+        class Ports(BaseNode.Ports):
+            foo = Port()
+            bar = Port()
+
+    # AND a target node
+    class B(BaseNode):
+        pass
+
+    # AND a workflow with a graph where different ports connect to the same target
+    class TestWorkflow(BaseWorkflow[BaseInputs, BaseState]):
+        graph = {
+            A.Ports.foo >> B,
+            A.Ports.bar >> B,
+        }
+
+    # WHEN we serialize the workflow
+    workflow_display = get_workflow_display(workflow_class=TestWorkflow)
+    result: dict = workflow_display.serialize()
+
+    # THEN the workflow should serialize successfully
+    assert "workflow_raw_data" in result
+
+    # AND there should be NO validation errors about duplicates
+    errors = list(workflow_display.display_context.errors)
+    duplicate_errors = [e for e in errors if isinstance(e, WorkflowValidationError) and "duplicate" in str(e).lower()]
+    assert len(duplicate_errors) == 0, f"Expected no duplicate errors, got {len(duplicate_errors)}: {duplicate_errors}"
+
+
+def test_chat_message_trigger_message_wired_to_prompt_inputs():
+    """Tests that ChatMessageTrigger.message can be wired to InlinePromptNode.prompt_inputs."""
+
+    # GIVEN a ChatMessageTrigger subclass
+    class Chat(ChatMessageTrigger):
+        class Display(ChatMessageTrigger.Display):
+            label: str = "Chat"
+
+    # AND an InlinePromptNode that uses the trigger's message as a prompt input
+    class PromptNode(InlinePromptNode):
+        ml_model = "gpt-4o"
+        blocks = [
+            ChatMessagePromptBlock(
+                chat_role="USER",
+                blocks=[JinjaPromptBlock(template="{{ message }}")],
+            ),
+        ]
+        prompt_inputs = {"message": Chat.message}
+
+    # AND a workflow that wires the trigger to the prompt node
+    class TestWorkflow(BaseWorkflow[BaseInputs, BaseState]):
+        graph = Chat >> PromptNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            result = PromptNode.Outputs.text
+
+    # WHEN we serialize the workflow
+    workflow_display = get_workflow_display(workflow_class=TestWorkflow)
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN the workflow should serialize successfully
+    assert "workflow_raw_data" in serialized_workflow
+
+    # AND the prompt node should have the message input wired correctly
+    workflow_raw_data = serialized_workflow["workflow_raw_data"]
+    nodes = workflow_raw_data["nodes"]
+    prompt_nodes = [n for n in nodes if isinstance(n, dict) and n.get("type") == "PROMPT"]
+    assert len(prompt_nodes) == 1
+
+    prompt_node = prompt_nodes[0]
+    inputs = prompt_node.get("inputs", [])
+    message_input = next((i for i in inputs if i.get("key") == "message"), None)
+    assert message_input is not None
+
+    # AND the input should reference the trigger attribute
+    rules = message_input.get("value", {}).get("rules", [])
+    trigger_attr_rule = next((r for r in rules if r.get("type") == "TRIGGER_ATTRIBUTE"), None)
+    assert trigger_attr_rule is not None
+
+    # AND the prompt input variable type should be ARRAY
+    exec_config = prompt_node.get("data", {}).get("exec_config", {})
+    input_variables = exec_config.get("input_variables", [])
+    message_var = next((v for v in input_variables if v.get("key") == "message"), None)
+    assert message_var is not None
+    assert message_var.get("type") == "ARRAY"
+
+
+def test_chat_message_trigger_validation__chat_history_none_default():
+    """Tests that serialization adds StateValidationError when chat_history defaults to None instead of empty array."""
+
+    # GIVEN a state class with chat_history defaulting to None
+    class InvalidChatState(BaseState):
+        chat_history: Optional[ChatMessage] = None
+
+    # AND a ChatMessageTrigger with output specified
+    class ChatTrigger(ChatMessageTrigger):
+        class Config(ChatMessageTrigger.Config):
+            output = LazyReference("ChatHistoryNoneWorkflow.Outputs.response")
+
+    # AND a workflow using the trigger with the invalid state
+    class ChatHistoryNoneWorkflow(BaseWorkflow[BaseInputs, InvalidChatState]):
+        graph = ChatTrigger >> ResponseNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            response = ResponseNode.Outputs.response
+
+    # WHEN we serialize the workflow
+    workflow_display = get_workflow_display(workflow_class=ChatHistoryNoneWorkflow)
+    workflow_display.serialize()
+
+    # THEN the display_context should contain a StateValidationError
+    errors = list(workflow_display.display_context.errors)
+    state_errors = [e for e in errors if isinstance(e, StateValidationError)]
+    assert len(state_errors) == 1
+
+    # AND the error should mention chat_history and empty array
+    error = state_errors[0]
+    assert "chat_history" in str(error)
+    assert "empty array" in str(error)
+
+
+def test_chat_message_trigger_validation__chat_history_missing():
+    """Tests that serialization adds StateValidationError when chat_history is missing from state class."""
+
+    # GIVEN a state class without chat_history
+    class StateMissingChatHistory(BaseState):
+        pass
+
+    # AND a ChatMessageTrigger with output specified
+    class ChatTrigger(ChatMessageTrigger):
+        class Config(ChatMessageTrigger.Config):
+            output = LazyReference("MissingChatHistoryWorkflow.Outputs.response")
+
+    # AND a workflow using the trigger with the state missing chat_history
+    class MissingChatHistoryWorkflow(BaseWorkflow[BaseInputs, StateMissingChatHistory]):
+        graph = ChatTrigger >> ResponseNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            response = ResponseNode.Outputs.response
+
+    # WHEN we serialize the workflow
+    workflow_display = get_workflow_display(workflow_class=MissingChatHistoryWorkflow)
+    workflow_display.serialize()
+
+    # THEN the display_context should contain a StateValidationError
+    errors = list(workflow_display.display_context.errors)
+    state_errors = [e for e in errors if isinstance(e, StateValidationError)]
+    assert len(state_errors) == 1
+
+    # AND the error should mention chat_history is required
+    error = state_errors[0]
+    assert "chat_history" in str(error)
+    assert "require" in str(error)

vellum_ee/workflows/display/tests/workflow_serialization/test_code_tool_node_reference_error.py

@@ -0,0 +1,106 @@
+import pytest
+
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.nodes.displayable.inline_prompt_node.node import InlinePromptNode
+from vellum.workflows.nodes.displayable.tool_calling_node.node import ToolCallingNode
+from vellum_ee.workflows.display.utils.exceptions import UnsupportedSerializationException
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+
+def test_serialize_workflow__code_tool_with_node_reference__raises_error():
+    """
+    Tests that a serialization error is raised when a code tool references a workflow node.
+    """
+
+    # GIVEN a function that references a node class
+    def my_tool_with_node_reference(query: str) -> str:
+        return str(InlinePromptNode)
+
+    # AND a tool calling node that uses this function
+    class MyToolCallingNode(ToolCallingNode):
+        functions = [my_tool_with_node_reference]
+
+    # AND a workflow with the tool calling node
+    class TestWorkflow(BaseWorkflow):
+        graph = MyToolCallingNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            result = MyToolCallingNode.Outputs.text
+
+    # WHEN we try to serialize the workflow
+    workflow_display = get_workflow_display(workflow_class=TestWorkflow)
+
+    # THEN a serialization error should be raised
+    with pytest.raises(UnsupportedSerializationException) as exc_info:
+        workflow_display.serialize()
+
+    # AND the error message should mention the node class and provide guidance
+    error_message = str(exc_info.value)
+    assert "InlinePromptNode" in error_message
+    assert "Code tools cannot reference workflow nodes" in error_message
+    assert "Inline Subworkflow tool" in error_message
+
+
+def test_serialize_workflow__code_tool_without_node_reference__no_error():
+    """
+    Tests that no error is raised when a code tool does not reference any workflow nodes,
+    even if the module has node imports at the top level.
+    """
+
+    # GIVEN a function that does NOT reference any node class (even though InlinePromptNode
+    # is imported at the module level)
+    def my_simple_tool(query: str) -> str:
+        return query.upper()
+
+    # AND a tool calling node that uses this function
+    class MyToolCallingNode(ToolCallingNode):
+        functions = [my_simple_tool]
+
+    # AND a workflow with the tool calling node
+    class TestWorkflow(BaseWorkflow):
+        graph = MyToolCallingNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            result = MyToolCallingNode.Outputs.text
+
+    # WHEN we serialize the workflow
+    workflow_display = get_workflow_display(workflow_class=TestWorkflow)
+    serialized_workflow = workflow_display.serialize()
+
+    # THEN no error should be raised and the workflow should serialize successfully
+    assert serialized_workflow is not None
+    assert "workflow_raw_data" in serialized_workflow
+
+
+def test_serialize_workflow__code_tool_with_node_instantiation__raises_error():
+    """
+    Tests that a serialization error is raised when a code tool instantiates a node and calls its run method.
+    """
+
+    # GIVEN a function that instantiates a node and calls its run method
+    def my_tool():
+        node: InlinePromptNode = InlinePromptNode()
+        return node.run()
+
+    # AND a tool calling node that uses this function
+    class MyToolCallingNode(ToolCallingNode):
+        functions = [my_tool]
+
+    # AND a workflow with the tool calling node
+    class TestWorkflow(BaseWorkflow):
+        graph = MyToolCallingNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            result = MyToolCallingNode.Outputs.text
+
+    # WHEN we try to serialize the workflow
+    workflow_display = get_workflow_display(workflow_class=TestWorkflow)
+
+    # THEN a serialization error should be raised
+    with pytest.raises(UnsupportedSerializationException) as exc_info:
+        workflow_display.serialize()
+
+    # AND the error message should mention the node class
+    error_message = str(exc_info.value)
+    assert "InlinePromptNode" in error_message
+    assert "Code tools cannot reference workflow nodes" in error_message