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

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

@@ -39,32 +39,36 @@ def test_serialize_workflow():
     workflow_raw_data = serialized_workflow["workflow_raw_data"]
     tool_calling_node = workflow_raw_data["nodes"][1]
     assert tool_calling_node == {
-        "id": "21f29cac-da87-495f-bba1-093d423f4e46",
-        "label": "GetCurrentWeatherNode",
+        "id": "649a81cf-ce93-47c1-aa0f-e7a58a0cba8c",
+        "label": "Get Current Weather Node",
         "type": "GENERIC",
+        "should_file_merge": True,
         "display_data": {
-            "position": {"x": 0.0, "y": 0.0},
-            "comment": {"value": "\n    A tool calling node that calls the get_current_weather function.\n    "},
+            "position": {"x": 200.0, "y": -50.0},
+            "comment": {
+                "expanded": True,
+                "value": "\n    A tool calling node that calls the get_current_weather function.\n    ",
+            },
         },
         "base": {
             "name": "ToolCallingNode",
-            "module": ["vellum", "workflows", "nodes", "experimental", "tool_calling_node", "node"],
+            "module": ["vellum", "workflows", "nodes", "displayable", "tool_calling_node", "node"],
         },
         "definition": {
             "name": "GetCurrentWeatherNode",
             "module": ["tests", "workflows", "basic_tool_calling_node", "workflow"],
         },
-        "trigger": {"id": "2414743b-b1dd-4552-8abf-9b7481df9762", "merge_behavior": "AWAIT_ATTRIBUTES"},
-        "ports": [{"id": "3cd6d78c-9dad-42aa-ad38-31f67057c379", "name": "default", "type": "DEFAULT"}],
+        "trigger": {"id": "fa785565-2906-433c-914a-79c574bcced4", "merge_behavior": "AWAIT_ATTRIBUTES"},
+        "ports": [{"id": "8ae76650-6658-441e-aab2-dbdc62dc6a48", "name": "default", "type": "DEFAULT"}],
         "adornments": None,
         "attributes": [
             {
-                "id": "44420e39-966f-4c59-bdf8-6365a61c5d2a",
+                "id": "6991a1bf-6a1d-4b0a-8e67-39505b324216",
                 "name": "ml_model",
                 "value": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "gpt-4o-mini"}},
             },
             {
-                "id": "669cfb4b-8c25-460e-8952-b63d91302cbc",
+                "id": "74ce80ae-4f12-48fd-a9b7-412532e383ec",
                 "name": "blocks",
                 "value": {
                     "type": "CONSTANT_VALUE",
@@ -111,7 +115,7 @@ def test_serialize_workflow():
                                                 "block_type": "VARIABLE",
                                                 "state": None,
                                                 "cache_config": None,
-                                                "input_variable": "question",
+                                                "input_variable": "aa87c0db-68c0-4c9b-9ad0-ddb48bb169eb",
                                             }
                                         ],
                                     }
@@ -122,7 +126,7 @@ def test_serialize_workflow():
                 },
             },
             {
-                "id": "78324739-ff89-47a5-902b-10da0cb95c6d",
+                "id": "1e3cd0b3-5657-42bd-8a71-48bdf9e9b835",
                 "name": "functions",
                 "value": {
                     "type": "CONSTANT_VALUE",
@@ -131,6 +135,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,
@@ -138,26 +144,33 @@ def test_serialize_workflow():
                                     "description": "\n    Get the current weather in a given location.\n    ",
                                     "parameters": {
                                         "type": "object",
-                                        "properties": {"location": {"type": "string"}, "unit": {"type": "string"}},
+                                        "properties": {
+                                            "location": {
+                                                "type": "string",
+                                                "description": "The location to get the weather for",
+                                            },
+                                            "unit": {"type": "string", "description": "The unit of temperature"},
+                                        },
                                         "required": ["location", "unit"],
                                     },
+                                    "inputs": None,
                                     "forced": None,
                                     "strict": None,
                                 },
-                                "src": 'def get_current_weather(location: str, unit: str) -> str:\n    """\n    Get the current weather in a given location.\n    """\n    return f"The current weather in {location} is sunny with a temperature of 70 degrees {unit}."\n',  # noqa: E501
+                                "src": 'import math\nfrom typing import Annotated\n\n\ndef get_current_weather(\n    location: Annotated[str, "The location to get the weather for"], unit: Annotated[str, "The unit of temperature"]\n) -> str:\n    """\n    Get the current weather in a given location.\n    """\n    return f"The current weather in {location} is sunny with a temperature of {get_temperature(70.1)} degrees {unit}."\n\n\ndef get_temperature(temperature: float) -> int:\n    """\n    Get the temperature in a given location.\n    """\n    return math.floor(temperature)\n',  # noqa: E501
                             }
                         ],
                     },
                 },
             },
             {
-                "id": "0f6dc102-3460-4963-91fa-7ba85d65ef7a",
+                "id": "e554e8c1-a270-4fbf-951f-fd4aca4afe9b",
                 "name": "prompt_inputs",
                 "value": {
                     "type": "DICTIONARY_REFERENCE",
                     "entries": [
                         {
-                            "id": "b6d4427d-16dd-478a-9780-f88d60d2263d",
+                            "id": "aa87c0db-68c0-4c9b-9ad0-ddb48bb169eb",
                             "key": "question",
                             "value": {
                                 "type": "WORKFLOW_INPUT",
@@ -168,20 +181,41 @@ def test_serialize_workflow():
                 },
             },
             {
-                "id": "b31575f0-633b-4bd0-ba6a-960532f3887a",
-                "name": "function_packages",
-                "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+                "id": "ef504b60-5b94-43d0-b31d-534309a52ff2",
+                "name": "parameters",
+                "value": {
+                    "type": "CONSTANT_VALUE",
+                    "value": {
+                        "type": "JSON",
+                        "value": {
+                            "stop": [],
+                            "temperature": 0.0,
+                            "max_tokens": 4096.0,
+                            "top_p": 1.0,
+                            "top_k": 0.0,
+                            "frequency_penalty": 0.0,
+                            "presence_penalty": 0.0,
+                            "logit_bias": None,
+                            "custom_parameters": {"mode": "initial"},
+                        },
+                    },
+                },
             },
             {
-                "id": "d316c45c-97ea-4f39-9a2d-5c43e2d355de",
-                "name": "runtime",
-                "value": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "PYTHON_3_11_6"}},
+                "id": "83546f2d-f531-4773-b87b-aeb104b9218d",
+                "name": "max_prompt_iterations",
+                "value": {"type": "CONSTANT_VALUE", "value": {"type": "NUMBER", "value": 25.0}},
+            },
+            {
+                "id": "bb8b8427-db2c-4115-b26b-c30dc705787a",
+                "name": "settings",
+                "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
             },
         ],
         "outputs": [
-            {"id": "e62bc785-a914-4066-b79e-8c89a5d0ec6c", "name": "text", "type": "STRING", "value": None},
+            {"id": "d0d0cd85-8546-4d90-bdc1-86c751ba04e5", "name": "text", "type": "STRING", "value": None},
             {
-                "id": "4674f1d9-e3af-411f-8a55-40a3a3ab5394",
+                "id": "33a737c2-d347-48d4-bf62-e36c06aebf0c",
                 "name": "chat_history",
                 "type": "CHAT_HISTORY",
                 "value": None,

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

@@ -0,0 +1,68 @@
+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 (
+    BasicToolCallingNodeWithVellumIntegrationToolWorkflow,
+)
+
+
+def test_serialize_workflow():
+    # GIVEN a Workflow that uses a tool calling node with a vellum integration tool
+    # WHEN we serialize it
+    workflow_display = get_workflow_display(workflow_class=BasicToolCallingNodeWithVellumIntegrationToolWorkflow)
+
+    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"] == "query"
+    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
+
+    # Find the text and chat_history outputs
+    text_output = next(var for var in output_variables if var["key"] == "text")
+    chat_history_output = next(var for var in output_variables if var["key"] == "chat_history")
+
+    assert text_output["type"] == "STRING"
+    assert chat_history_output["type"] == "CHAT_HISTORY"
+
+    # 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]
+
+    # Tool calling nodes serialize as GENERIC nodes
+    assert tool_calling_node["type"] == "GENERIC"
+    assert tool_calling_node["label"] == "Vellum Integration Tool Calling Node"
+
+    # Verify the node base class
+    assert tool_calling_node["base"]["name"] == "ToolCallingNode"
+
+    # Verify the node has the expected attributes with function definitions
+    assert "attributes" in tool_calling_node
+    attributes = tool_calling_node["attributes"]
+
+    # Find the functions attribute
+    functions_attr = next(attr for attr in attributes if attr["name"] == "functions")
+    assert functions_attr["value"]["type"] == "CONSTANT_VALUE"
+
+    # Verify the function definition details
+    functions_value = functions_attr["value"]["value"]["value"]
+    assert len(functions_value) == 1
+
+    function = functions_value[0]
+    assert function["type"] == "VELLUM_INTEGRATION"
+    assert function["provider"] == "COMPOSIO"  # VellumIntegrationProviderType.COMPOSIO
+    assert function["integration_name"] == "GITHUB"
+    assert function["name"] == "create_issue"
+    assert function["description"] == "Create a new issue in a GitHub repository"

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

@@ -0,0 +1,107 @@
+from datetime import datetime
+
+from deepdiff import DeepDiff
+
+from vellum.client.types.release_environment import ReleaseEnvironment
+from vellum.client.types.release_release_tag import ReleaseReleaseTag
+from vellum.client.types.release_review_reviewer import ReleaseReviewReviewer
+from vellum.client.types.slim_release_review import SlimReleaseReview
+from vellum.client.types.workflow_deployment_release import WorkflowDeploymentRelease
+from vellum.client.types.workflow_deployment_release_workflow_deployment import (
+    WorkflowDeploymentReleaseWorkflowDeployment,
+)
+from vellum.client.types.workflow_deployment_release_workflow_version import WorkflowDeploymentReleaseWorkflowVersion
+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(vellum_client):
+    vellum_client.workflow_deployments.retrieve_workflow_deployment_release.return_value = WorkflowDeploymentRelease(
+        id="test-id",
+        created=datetime.now(),
+        environment=ReleaseEnvironment(
+            id="test-id",
+            name="test-name",
+            label="test-label",
+        ),
+        created_by=None,
+        workflow_version=WorkflowDeploymentReleaseWorkflowVersion(
+            id="test-id",
+            input_variables=[],
+            output_variables=[],
+        ),
+        deployment=WorkflowDeploymentReleaseWorkflowDeployment(name="test-name"),
+        description="test-description",  # main mock
+        release_tags=[
+            ReleaseReleaseTag(
+                name="test-name",
+                source="USER",
+            )
+        ],
+        reviews=[
+            SlimReleaseReview(
+                id="test-id",
+                created=datetime.now(),
+                reviewer=ReleaseReviewReviewer(
+                    id="test-id",
+                    full_name="test-name",
+                ),
+                state="APPROVED",
+            )
+        ],
+    )
+    # 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": "a6c4a9d7-9615-478d-adb3-6577847c738d",
+        "name": "functions",
+        "value": {
+            "type": "CONSTANT_VALUE",
+            "value": {
+                "type": "JSON",
+                "value": [
+                    {
+                        "type": "WORKFLOW_DEPLOYMENT",
+                        "name": "test-name",
+                        "description": "test-description",
+                        "deployment": "deployment_1",
+                        "release_tag": "LATEST",
+                    }
+                ],
+            },
+        },
+    }

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

@@ -63,12 +63,12 @@ def test_serialize_workflow():
             "source_handle_id": "04da0bb6-5b42-4dd1-a4e4-08f3ab03e1a3",
         },
         "display_data": {
-            "position": {"x": 0.0, "y": 0.0},
+            "position": {"x": 0.0, "y": -50.0},
         },
     }
 
     try_node = workflow_raw_data["nodes"][1]
-    assert try_node["id"] == "1381c078-efa2-4255-89a1-7b4cb742c7fc"
+    assert try_node["id"] == "25cb9a9f-a046-4efc-931f-00248240a02e"
 
 
 def test_serialize_workflow__standalone():

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

@@ -0,0 +1,108 @@
+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.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": "2ae688ad-8690-4765-a5fa-aecc7d6496e5"},
+                        "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"],
+                            },
+                        },
+                    },
+                }
+            ],
+        },
+    }

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

@@ -36,19 +36,19 @@ def test_serialize_workflow__missing_final_output_node():
     assert not DeepDiff(
         [
             {
-                "id": "acc91103-f761-47a5-bdd4-0e5e7650bb30",
+                "id": "8683c087-4372-4357-bdd4-e13a50447d5e",
                 "type": "TERMINAL",
                 "data": {
                     "label": "First Final Output Node",
                     "name": "alpha",
-                    "target_handle_id": "a0c2eb7a-398e-4f28-b63d-f3bae9b563ee",
-                    "output_id": "0cd02933-c5b9-47c9-aede-e97c5870e8aa",
+                    "target_handle_id": "438edefd-131d-4d00-8645-d0a7ea07029e",
+                    "output_id": "1d261e4b-4d77-4ace-9349-972129583519",
                     "output_type": "STRING",
-                    "node_input_id": "16363762-c14a-4162-8fab-525079d3cffe",
+                    "node_input_id": "ec1a9df2-a809-49fa-971b-8718df47e456",
                 },
                 "inputs": [
                     {
-                        "id": "16363762-c14a-4162-8fab-525079d3cffe",
+                        "id": "ec1a9df2-a809-49fa-971b-8718df47e456",
                         "key": "node_input",
                         "value": {
                             "rules": [
@@ -61,7 +61,7 @@ def test_serialize_workflow__missing_final_output_node():
                         },
                     }
                 ],
-                "display_data": {"position": {"x": 0.0, "y": 0.0}},
+                "display_data": {"position": {"x": 200.0, "y": 75.0}},
                 "base": {
                     "name": "FinalOutputNode",
                     "module": ["vellum", "workflows", "nodes", "displayable", "final_output_node", "node"],
@@ -72,7 +72,7 @@ def test_serialize_workflow__missing_final_output_node():
                 },
                 "outputs": [
                     {
-                        "id": "0cd02933-c5b9-47c9-aede-e97c5870e8aa",
+                        "id": "1d261e4b-4d77-4ace-9349-972129583519",
                         "name": "value",
                         "type": "STRING",
                         "value": {
@@ -81,6 +81,11 @@ def test_serialize_workflow__missing_final_output_node():
                         },
                     }
                 ],
+                "trigger": {
+                    "id": "438edefd-131d-4d00-8645-d0a7ea07029e",
+                    "merge_behavior": "AWAIT_ANY",
+                },
+                "ports": [],
             },
             {
                 "id": "bb88768d-472e-4997-b7ea-de09163d1b4c",
@@ -102,8 +107,8 @@ def test_serialize_workflow__missing_final_output_node():
                                 {
                                     "type": "NODE_OUTPUT",
                                     "data": {
-                                        "node_id": "32d88cab-e9fa-4a56-9bc2-fb6e1fd0897f",
-                                        "output_id": "04df0e76-690a-4ae1-ab52-fe825a334dcc",
+                                        "node_id": "74b891e0-5573-4c7a-a0ef-c3c210187738",
+                                        "output_id": "ae21fc3f-dd81-4174-b08a-97bc96422a8f",
                                     },
                                 }
                             ],
@@ -111,7 +116,7 @@ def test_serialize_workflow__missing_final_output_node():
                         },
                     }
                 ],
-                "display_data": {"position": {"x": 0.0, "y": 0.0}},
+                "display_data": {"position": {"x": 400.0, "y": -50.0}},
                 "base": {
                     "name": "FinalOutputNode",
                     "module": ["vellum", "workflows", "nodes", "displayable", "final_output_node", "node"],

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

@@ -0,0 +1,88 @@
+from typing import List
+
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.nodes import MapNode
+from vellum.workflows.nodes.bases import BaseNode
+from vellum.workflows.nodes.displayable import FinalOutputNode
+from vellum.workflows.outputs import BaseOutputs
+from vellum.workflows.state import BaseState
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+
+class TestInputs(BaseInputs):
+    items: List[str]
+
+
+class TestIteration(BaseNode):
+    item = MapNode.SubworkflowInputs.item
+    index = MapNode.SubworkflowInputs.index
+
+    class Outputs(BaseOutputs):
+        processed: str
+
+    def run(self) -> Outputs:
+        return self.Outputs(processed=f"processed_{self.item}_{self.index}")
+
+
+class TestIterationSubworkflow(BaseWorkflow[MapNode.SubworkflowInputs, BaseState]):
+    graph = TestIteration
+
+    class Outputs(BaseOutputs):
+        processed = TestIteration.Outputs.processed
+
+
+class TestMapNode(MapNode):
+    items = TestInputs.items
+    subworkflow = TestIterationSubworkflow
+
+
+class TestFinalOutputNode(FinalOutputNode[BaseState, List[str]]):
+    class Outputs(FinalOutputNode.Outputs):
+        value = TestMapNode.Outputs.processed
+
+
+class TestWorkflowWithFinalOutputReferencingMap(BaseWorkflow[TestInputs, BaseState]):
+    graph = TestMapNode >> TestFinalOutputNode
+
+    class Outputs(BaseOutputs):
+        final_result = TestFinalOutputNode.Outputs.value
+
+
+def test_serialize_workflow__final_output_node_referencing_map_node():
+    """
+    Test that final output nodes referencing map node outputs have correct outputs structure.
+
+    This test verifies that when a FinalOutputNode references a MapNode output,
+    the serialized output contains proper NODE_OUTPUT references instead of None values.
+    This addresses the Agent Builder issue where final outputs showed value=None in the UI.
+    """
+    workflow_display = get_workflow_display(workflow_class=TestWorkflowWithFinalOutputReferencingMap)
+
+    # WHEN we serialize it
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN the final output node should have the correct outputs structure
+    workflow_raw_data = serialized_workflow["workflow_raw_data"]
+    map_node = next(node for node in workflow_raw_data["nodes"] if node["type"] == "MAP")
+    final_output_node = next(node for node in workflow_raw_data["nodes"] if node["type"] == "TERMINAL")
+
+    # AND the map node's subworkflow should have the one output variable
+    output_variable = next(iter(map_node["data"]["output_variables"]))
+    map_node_output_id = output_variable["id"]
+
+    # AND the final output node should have an outputs array with proper structure
+    assert "outputs" in final_output_node
+    outputs = final_output_node["outputs"]
+    assert len(outputs) == 1
+
+    output = outputs[0]
+    # AND the output should have the correct structure with NODE_OUTPUT reference instead of None
+    assert output["name"] == "value"
+    assert output["type"] == "JSON"
+
+    # AND the value should be a NODE_OUTPUT reference, not None
+    assert output["value"] is not None, f"Expected NODE_OUTPUT reference but got None. Full output: {output}"
+    assert output["value"]["type"] == "NODE_OUTPUT", f"Expected NODE_OUTPUT type but got {output['value']['type']}"
+    assert "node_id" in output["value"], f"Missing node_id in output value: {output['value']}"
+    assert output["value"]["node_output_id"] == map_node_output_id