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

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

@@ -0,0 +1,71 @@
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+from tests.workflows.basic_tool_calling_node_tool_wrapper.workflow import BasicToolCallingNodeWrapperWorkflow
+
+
+def test_serialize_workflow():
+    # GIVEN a Workflow that uses a tool calling node with tool wrapper
+    # WHEN we serialize it
+    workflow_display = get_workflow_display(workflow_class=BasicToolCallingNodeWrapperWorkflow)
+
+    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
+    assert input_variables[0]["key"] == "date_input"
+    assert input_variables[0]["type"] == "STRING"
+
+    # AND its output variables should be what we expect
+    output_variables = serialized_workflow["output_variables"]
+    assert len(output_variables) == 2
+    output_keys = {output["key"] for output in output_variables}
+    assert output_keys == {"text", "chat_history"}
+
+    # AND its raw data should be what we expect
+    workflow_raw_data = serialized_workflow["workflow_raw_data"]
+
+    nodes = workflow_raw_data["nodes"]
+    assert len(nodes) == 2
+
+    tool_calling_node = next(node for node in nodes if node.get("type") == "GENERIC")
+
+    functions_attr = next(attr for attr in tool_calling_node["attributes"] if attr["name"] == "functions")
+    functions = functions_attr["value"]["value"]["value"]
+    assert len(functions) == 1
+    assert functions[0] == {
+        "type": "CODE_EXECUTION",
+        "name": "get_current_weather",
+        "description": "",
+        "definition": {
+            "state": None,
+            "cache_config": None,
+            "name": "get_current_weather",
+            "description": None,
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "location": {"type": "string", "description": "The location to get the weather for"},
+                    "units": {"type": "string", "description": "The unit of temperature", "default": "fahrenheit"},
+                },
+                "required": ["location"],
+                "examples": [{"location": "San Francisco"}, {"location": "New York", "units": "celsius"}],
+            },
+            "inputs": {
+                "date_input": {
+                    "type": "WORKFLOW_INPUT",
+                    "input_variable_id": functions[0]["definition"]["inputs"]["date_input"]["input_variable_id"],
+                }
+            },
+            "forced": None,
+            "strict": None,
+        },
+        "src": 'from typing import Annotated\n\n\ndef get_current_weather(\n    date_input: str,\n    location: Annotated[str, "The location to get the weather for"],\n    units: Annotated[str, "The unit of temperature"] = "fahrenheit",\n) -> str:\n    return f"The current weather on {date_input} in {location} is sunny with a temperature of 70 degrees {units}."\n',  # noqa: E501
+    }

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

@@ -1,3 +1,11 @@
+from vellum.client.types.chat_message_prompt_block import ChatMessagePromptBlock
+from vellum.client.types.rich_text_prompt_block import RichTextPromptBlock
+from vellum.client.types.variable_prompt_block import VariablePromptBlock
+from vellum.workflows.constants import VellumIntegrationProviderType
+from vellum.workflows.nodes.displayable.tool_calling_node import ToolCallingNode
+from vellum.workflows.state.base import BaseState
+from vellum.workflows.types.definition import VellumIntegrationToolDefinition
+from vellum.workflows.workflows.base import BaseInputs, BaseWorkflow
 from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
 
 from tests.workflows.basic_tool_calling_node_with_vellum_integration_tool.workflow import (
@@ -66,3 +74,114 @@ def test_serialize_workflow():
     assert function["integration_name"] == "GITHUB"
     assert function["name"] == "create_issue"
     assert function["description"] == "Create a new issue in a GitHub repository"
+
+
+def test_serialize_workflow__with_toolkit_version():
+    """
+    Tests that VellumIntegrationToolDefinition with toolkit_version serializes correctly.
+    """
+
+    # GIVEN a VellumIntegrationToolDefinition with toolkit_version
+    github_tool_with_version = VellumIntegrationToolDefinition(
+        provider=VellumIntegrationProviderType.COMPOSIO,
+        integration_name="GITHUB",
+        name="create_issue",
+        description="Create a new issue in a GitHub repository",
+        toolkit_version="1.2.3",
+    )
+
+    # AND a ToolCallingNode that uses this tool
+    class TestInputs(BaseInputs):
+        query: str
+
+    class TestToolCallingNode(ToolCallingNode):
+        ml_model = "gpt-4o-mini"
+        blocks = [
+            ChatMessagePromptBlock(
+                chat_role="USER",
+                blocks=[
+                    RichTextPromptBlock(
+                        blocks=[
+                            VariablePromptBlock(input_variable="question"),
+                        ],
+                    ),
+                ],
+            ),
+        ]
+        functions = [github_tool_with_version]
+        prompt_inputs = {"question": TestInputs.query}
+
+    class TestWorkflow(BaseWorkflow[TestInputs, BaseState]):
+        graph = TestToolCallingNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            text = TestToolCallingNode.Outputs.text
+
+    # WHEN we serialize the workflow
+    workflow_display = get_workflow_display(workflow_class=TestWorkflow)
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN the function should include the toolkit_version
+    workflow_raw_data = serialized_workflow["workflow_raw_data"]
+    tool_calling_node = workflow_raw_data["nodes"][1]
+    attributes = tool_calling_node["attributes"]
+    functions_attr = next(attr for attr in attributes if attr["name"] == "functions")
+    functions_value = functions_attr["value"]["value"]["value"]
+    function = functions_value[0]
+
+    assert function["toolkit_version"] == "1.2.3"
+
+
+def test_serialize_workflow__without_toolkit_version():
+    """
+    Tests that VellumIntegrationToolDefinition without toolkit_version serializes with null.
+    """
+
+    # GIVEN a VellumIntegrationToolDefinition without toolkit_version
+    github_tool_no_version = VellumIntegrationToolDefinition(
+        provider=VellumIntegrationProviderType.COMPOSIO,
+        integration_name="SLACK",
+        name="send_message",
+        description="Send a message to a Slack channel",
+    )
+
+    # AND a ToolCallingNode that uses this tool
+    class TestInputs(BaseInputs):
+        query: str
+
+    class TestToolCallingNode(ToolCallingNode):
+        ml_model = "gpt-4o-mini"
+        blocks = [
+            ChatMessagePromptBlock(
+                chat_role="USER",
+                blocks=[
+                    RichTextPromptBlock(
+                        blocks=[
+                            VariablePromptBlock(input_variable="question"),
+                        ],
+                    ),
+                ],
+            ),
+        ]
+        functions = [github_tool_no_version]
+        prompt_inputs = {"question": TestInputs.query}
+
+    class TestWorkflow(BaseWorkflow[TestInputs, BaseState]):
+        graph = TestToolCallingNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            text = TestToolCallingNode.Outputs.text
+
+    # WHEN we serialize the workflow
+    workflow_display = get_workflow_display(workflow_class=TestWorkflow)
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN the function should have toolkit_version as None
+    workflow_raw_data = serialized_workflow["workflow_raw_data"]
+    tool_calling_node = workflow_raw_data["nodes"][1]
+    attributes = tool_calling_node["attributes"]
+    functions_attr = next(attr for attr in attributes if attr["name"] == "functions")
+    functions_value = functions_attr["value"]["value"]["value"]
+    function = functions_value[0]
+
+    assert function["toolkit_version"] is None

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

@@ -33,7 +33,7 @@ def test_serialize_workflow(vellum_client):
             input_variables=[],
             output_variables=[],
         ),
-        deployment=WorkflowDeploymentReleaseWorkflowDeployment(name="test-name"),
+        deployment=WorkflowDeploymentReleaseWorkflowDeployment(id="test-deployment-id", name="test-name"),
         description="test-description",  # main mock
         release_tags=[
             ReleaseReleaseTag(

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

@@ -47,8 +47,6 @@ def test_serialize_workflow():
 
     # AND its raw data should be what we expect
     workflow_raw_data = serialized_workflow["workflow_raw_data"]
-    assert len(workflow_raw_data["edges"]) == 3
-    assert len(workflow_raw_data["nodes"]) == 4
 
     # AND each node should be serialized correctly
     entrypoint_node = workflow_raw_data["nodes"][0]

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

@@ -5,6 +5,7 @@ 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
 
 
@@ -67,7 +68,7 @@ def test_serialize_chat_message_dict_reference_with_definition():
                     "key": "chat_history",
                     "value": {
                         "type": "BINARY_EXPRESSION",
-                        "lhs": {"type": "WORKFLOW_STATE", "state_variable_id": "2ae688ad-8690-4765-a5fa-aecc7d6496e5"},
+                        "lhs": {"type": "WORKFLOW_STATE", "state_variable_id": "fff74a8e-752e-4088-9d3e-493e9162bda5"},
                         "operator": "+",
                         "rhs": {
                             "type": "DICTIONARY_REFERENCE",
@@ -106,3 +107,23 @@ def test_serialize_chat_message_dict_reference_with_definition():
             ],
         },
     }
+
+
+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)