vellum-ai 1.4.1__py3-none-any.whl → 1.5.0__py3-none-any.whl

vellum_cli/tests/test_push.py

@@ -721,6 +721,7 @@ MY_OTHER_VELLUM_API_KEY=aaabbbcccddd
     vellum_client_class.assert_called_once_with(
         api_key="aaabbbcccddd",
         environment=mock.ANY,
+        api_version=None,
     )
 
     # AND the vellum lock file should have been updated with the correct workspace
@@ -882,6 +883,7 @@ MY_OTHER_VELLUM_API_KEY=aaabbbcccddd
     vellum_client_class.assert_called_once_with(
         api_key="aaabbbcccddd",
         environment=mock.ANY,
+        api_version=None,
     )
 
     # AND the vellum lock file should have the same two workflows

vellum_ee/assets/node-definitions.json

@@ -0,0 +1,483 @@
+{
+  "nodes": [
+    {
+      "id": "5d3c60ce-7acf-4d8b-a68d-65cc0b561ac5",
+      "display_data": {
+        "position": {
+          "x": 0.0,
+          "y": 0.0
+        },
+        "comment": {
+          "value": "\n    Used to conditionally determine which port to invoke next. This node exists to be backwards compatible with\n    Vellum's Conditional Node, and for most cases, you should extend `BaseNode.Ports` directly.\n    ",
+          "expanded": true
+        }
+      },
+      "base": {
+        "name": "BaseNode",
+        "module": [
+          "vellum",
+          "workflows",
+          "nodes",
+          "bases",
+          "base"
+        ]
+      },
+      "definition": {
+        "name": "ConditionalNode",
+        "module": [
+          "vellum",
+          "workflows",
+          "nodes",
+          "displayable",
+          "conditional_node",
+          "node"
+        ]
+      },
+      "trigger": {
+        "id": "2b5617b4-5cc0-4f9a-9369-24982e2cd8c0",
+        "merge_behavior": "AWAIT_ANY"
+      },
+      "ports": []
+    },
+    {
+      "id": "92e401f1-110f-4edc-8bb0-cad879e1ea08",
+      "display_data": {
+        "position": {
+          "x": 0.0,
+          "y": 0.0
+        },
+        "comment": {
+          "value": "\n    Used to raise an error to reject the surrounding Workflow.\n\n    error: Union[str, VellumError] - The error to raise.\n    ",
+          "expanded": true
+        }
+      },
+      "base": {
+        "name": "BaseNode",
+        "module": [
+          "vellum",
+          "workflows",
+          "nodes",
+          "bases",
+          "base"
+        ]
+      },
+      "definition": {
+        "name": "ErrorNode",
+        "module": [
+          "vellum",
+          "workflows",
+          "nodes",
+          "core",
+          "error_node",
+          "node"
+        ]
+      },
+      "trigger": {
+        "id": "c1b30829-76af-4d99-bf83-b030c551a7cf",
+        "merge_behavior": "AWAIT_ATTRIBUTES"
+      },
+      "ports": []
+    },
+    {
+      "id": "16b8d82d-458d-48d9-b57e-a447b19f311a",
+      "display_data": {
+        "position": {
+          "x": 0.0,
+          "y": 0.0
+        },
+        "comment": {
+          "value": "\n    A no-op Node purely used to display a note in the Vellum UI.\n    ",
+          "expanded": true
+        }
+      },
+      "base": {
+        "name": "BaseNode",
+        "module": [
+          "vellum",
+          "workflows",
+          "nodes",
+          "bases",
+          "base"
+        ]
+      },
+      "definition": {
+        "name": "NoteNode",
+        "module": [
+          "vellum",
+          "workflows",
+          "nodes",
+          "displayable",
+          "note_node",
+          "node"
+        ]
+      },
+      "trigger": {
+        "id": "2b6907b0-1adc-41e7-9d5b-3c6ccd9b973a",
+        "merge_behavior": "AWAIT_ANY"
+      },
+      "ports": [
+        {
+          "id": "22dac74c-7ad6-4a6f-97ae-0034124721ce",
+          "name": "default",
+          "type": "DEFAULT"
+        }
+      ]
+    },
+    {
+      "id": "035842e0-34ed-43af-97de-a706e40912ae",
+      "label": "Tool Calling Node",
+      "display_data": {
+        "position": {
+          "x": 0.0,
+          "y": 0.0
+        },
+        "comment": {
+          "value": "\n    A Node that dynamically invokes the provided functions to the underlying Prompt\n\n    Attributes:\n        ml_model: str - The model to use for tool calling (e.g., \"gpt-4o-mini\")\n        blocks: List[PromptBlock] - The prompt blocks to use (same format as InlinePromptNode)\n        functions: List[Tool] - The functions that can be called\n        prompt_inputs: Optional[EntityInputsInterface] - Mapping of input variable names to values\n        parameters: PromptParameters - The parameters for the Prompt\n        max_prompt_iterations: Optional[int] - Maximum number of prompt iterations before stopping\n    ",
+          "expanded": true
+        }
+      },
+      "base": {
+        "name": "BaseNode",
+        "module": [
+          "vellum",
+          "workflows",
+          "nodes",
+          "bases",
+          "base"
+        ]
+      },
+      "definition": {
+        "name": "ToolCallingNode",
+        "module": [
+          "vellum",
+          "workflows",
+          "nodes",
+          "displayable",
+          "tool_calling_node",
+          "node"
+        ]
+      },
+      "trigger": {
+        "id": "f9b4a4ce-68ae-45f4-9e29-38b588abdf97",
+        "merge_behavior": "AWAIT_ATTRIBUTES"
+      },
+      "ports": [
+        {
+          "id": "72157fce-fc16-44d8-a00d-506738a20730",
+          "name": "default",
+          "type": "DEFAULT"
+        }
+      ],
+      "attributes": [
+        {
+          "id": "df3761db-067a-4fe9-9fc3-ba270786fcf6",
+          "name": "ml_model",
+          "value": {
+            "type": "CONSTANT_VALUE",
+            "value": {
+              "type": "STRING",
+              "value": "gpt-4o-mini"
+            }
+          }
+        },
+        {
+          "id": "66133945-f7fd-43bb-8b46-0761e2b58241",
+          "name": "blocks",
+          "value": {
+            "type": "CONSTANT_VALUE",
+            "value": {
+              "type": "JSON",
+              "value": []
+            }
+          }
+        },
+        {
+          "id": "0079b429-3b1c-4f7c-9ccf-185ace4dcbb2",
+          "name": "functions",
+          "value": {
+            "type": "CONSTANT_VALUE",
+            "value": {
+              "type": "JSON",
+              "value": []
+            }
+          }
+        },
+        {
+          "id": "ebda56e6-2ace-472c-a106-36cb69264e96",
+          "name": "prompt_inputs",
+          "value": {
+            "type": "CONSTANT_VALUE",
+            "value": {
+              "type": "JSON",
+              "value": null
+            }
+          }
+        },
+        {
+          "id": "2534a586-5b37-41f3-a9a4-8162b8538df4",
+          "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": null,
+                "custom_parameters": null
+              }
+            }
+          }
+        },
+        {
+          "id": "118ef72a-0767-4659-8ddf-58a071f95988",
+          "name": "max_prompt_iterations",
+          "value": {
+            "type": "CONSTANT_VALUE",
+            "value": {
+              "type": "NUMBER",
+              "value": 5.0
+            }
+          }
+        },
+        {
+          "id": "d7ef5296-1e48-4d05-b97a-77f16d46fd50",
+          "name": "settings",
+          "value": {
+            "type": "CONSTANT_VALUE",
+            "value": {
+              "type": "JSON",
+              "value": null
+            }
+          }
+        }
+      ],
+      "outputs": [
+        {
+          "id": "c18a8725-21e1-4736-a77c-76d0fc035176",
+          "name": "text",
+          "type": "STRING",
+          "value": null
+        },
+        {
+          "id": "5a9ad073-c670-43d2-9198-a08e9fdda7ad",
+          "name": "chat_history",
+          "type": "CHAT_HISTORY",
+          "value": null
+        }
+      ]
+    },
+    {
+      "id": "187ed9ed-ca2b-49e4-943d-ee8da5fad973",
+      "label": "Web Search Node",
+      "display_data": {
+        "position": {
+          "x": 0.0,
+          "y": 0.0
+        },
+        "comment": {
+          "value": "\n    Used to perform web search using SerpAPI.\n\n    query: str - The search query to execute\n    api_key: str - SerpAPI authentication key\n    num_results: int - Number of search results to return (default: 10)\n    location: Optional[str] - Geographic location filter for search\n    ",
+          "expanded": true
+        }
+      },
+      "base": {
+        "name": "BaseNode",
+        "module": [
+          "vellum",
+          "workflows",
+          "nodes",
+          "bases",
+          "base"
+        ]
+      },
+      "definition": {
+        "name": "WebSearchNode",
+        "module": [
+          "vellum",
+          "workflows",
+          "nodes",
+          "displayable",
+          "web_search_node",
+          "node"
+        ]
+      },
+      "trigger": {
+        "id": "036c7a0c-fff3-44f7-b49b-429d8f44f212",
+        "merge_behavior": "AWAIT_ATTRIBUTES"
+      },
+      "ports": [
+        {
+          "id": "ef824748-d00d-41e7-b7b4-d0edc536c3af",
+          "name": "default",
+          "type": "DEFAULT"
+        }
+      ],
+      "attributes": [
+        {
+          "id": "b5ba3c60-e02c-46c8-b470-d86c4f8f42af",
+          "name": "query",
+          "value": {
+            "type": "CONSTANT_VALUE",
+            "value": {
+              "type": "STRING",
+              "value": ""
+            }
+          }
+        },
+        {
+          "id": "222408bc-7dae-4bb8-9aba-a1ac36bdc759",
+          "name": "api_key",
+          "value": {
+            "type": "CONSTANT_VALUE",
+            "value": {
+              "type": "JSON",
+              "value": null
+            }
+          }
+        },
+        {
+          "id": "795a0bbc-bb98-4bc8-a9d9-88b0cb796d23",
+          "name": "num_results",
+          "value": {
+            "type": "CONSTANT_VALUE",
+            "value": {
+              "type": "NUMBER",
+              "value": 10.0
+            }
+          }
+        },
+        {
+          "id": "e1648557-ca03-4a81-ab5b-86495284b325",
+          "name": "location",
+          "value": {
+            "type": "CONSTANT_VALUE",
+            "value": {
+              "type": "JSON",
+              "value": null
+            }
+          }
+        }
+      ],
+      "outputs": [
+        {
+          "id": "704a4ba3-1afe-482d-876a-91dcdbe90fb7",
+          "name": "text",
+          "type": "STRING",
+          "value": null
+        },
+        {
+          "id": "574b2ebe-f250-4024-b517-3cd47704c70e",
+          "name": "urls",
+          "type": "JSON",
+          "value": null
+        },
+        {
+          "id": "9798a067-3589-4a2a-a811-6019873cbbfe",
+          "name": "results",
+          "type": "JSON",
+          "value": null
+        }
+      ]
+    },
+    {
+      "id": "bf31cc42-b5e4-4191-a453-7191743ac200",
+      "display_data": {
+        "position": {
+          "x": 0.0,
+          "y": 0.0
+        },
+        "comment": {
+          "value": "\n    Used to directly reference the output of another node.\n    This provides backward compatibility with Vellum's Final Output Node.\n    ",
+          "expanded": true
+        }
+      },
+      "base": {
+        "name": "BaseNode",
+        "module": [
+          "vellum",
+          "workflows",
+          "nodes",
+          "bases",
+          "base"
+        ]
+      },
+      "definition": {
+        "name": "FinalOutputNode",
+        "module": [
+          "vellum",
+          "workflows",
+          "nodes",
+          "displayable",
+          "final_output_node",
+          "node"
+        ]
+      },
+      "trigger": {
+        "id": "0b2da045-2a4c-4939-8b5c-661652c759d4",
+        "merge_behavior": "AWAIT_ANY"
+      },
+      "ports": [],
+      "outputs": [
+        {
+          "id": "7f41909e-9ce1-4fde-ba77-a13dda301ece",
+          "name": "value",
+          "type": "STRING",
+          "value": {
+            "__undefined__": true
+          }
+        }
+      ]
+    }
+  ],
+  "errors": [
+    {
+      "node": "APINode",
+      "error": "APINode.Outputs.text"
+    },
+    {
+      "node": "CodeExecutionNode",
+      "error": "vellum.workflows.nodes.displayable.code_execution_node.node.CodeExecutionNode.Ports.default"
+    },
+    {
+      "node": "InlinePromptNode",
+      "error": "vellum.workflows.nodes.displayable.inline_prompt_node.node.InlinePromptNode.Ports.default"
+    },
+    {
+      "node": "InlineSubworkflowNode",
+      "error": "'NoneType' object has no attribute 'get_inputs_class'"
+    },
+    {
+      "node": "GuardrailNode",
+      "error": "vellum.workflows.nodes.displayable.guardrail_node.node.GuardrailNode.Ports.default"
+    },
+    {
+      "node": "MapNode",
+      "error": "Expected NodeReference items to have an instance"
+    },
+    {
+      "node": "MergeNode",
+      "error": "vellum.workflows.nodes.displayable.merge_node.node.MergeNode.Ports.default"
+    },
+    {
+      "node": "SubworkflowDeploymentNode",
+      "error": "headers: {'server': 'gunicorn', 'date': 'Mon, 22 Sep 2025 14:24:17 GMT', 'content-type': 'application/json', 'allow': 'GET, PUT, PATCH, DELETE, HEAD, OPTIONS', 'x-frame-options': 'DENY', 'content-length': '28', 'vary': 'Accept-Language, Origin', 'content-language': 'en', 'strict-transport-security': 'max-age=60; includeSubDomains; preload', 'x-content-type-options': 'nosniff', 'referrer-policy': 'same-origin', 'cross-origin-opener-policy': 'same-origin', 'via': '1.1 google', 'alt-svc': 'h3=\":443\"; ma=2592000,h3-29=\":443\"; ma=2592000'}, status_code: 403, body: {'detail': 'Invalid API key'}"
+    },
+    {
+      "node": "PromptDeploymentNode",
+      "error": "headers: {'server': 'gunicorn', 'date': 'Mon, 22 Sep 2025 14:24:17 GMT', 'content-type': 'application/json', 'allow': 'GET, PUT, PATCH, DELETE, HEAD, OPTIONS', 'x-frame-options': 'DENY', 'content-length': '28', 'vary': 'Accept-Language, Origin', 'content-language': 'en', 'strict-transport-security': 'max-age=60; includeSubDomains; preload', 'x-content-type-options': 'nosniff', 'referrer-policy': 'same-origin', 'cross-origin-opener-policy': 'same-origin', 'via': '1.1 google', 'alt-svc': 'h3=\":443\"; ma=2592000,h3-29=\":443\"; ma=2592000'}, status_code: 403, body: {'detail': 'Invalid API key'}"
+    },
+    {
+      "node": "SearchNode",
+      "error": "Expected NodeReference query to have an instance"
+    },
+    {
+      "node": "TemplatingNode",
+      "error": "TemplatingNode.Outputs.result"
+    }
+  ]
+}

vellum_ee/scripts/generate_node_definitions.py

@@ -0,0 +1,89 @@
+import json
+import logging
+import os
+from typing import Any, Dict, List, Optional, Type
+
+from vellum.workflows.nodes.bases.base import BaseNode
+import vellum.workflows.nodes.displayable as displayable_module
+from vellum.workflows.vellum_client import create_vellum_client
+from vellum_ee.workflows.display.nodes.get_node_display_class import get_node_display_class
+from vellum_ee.workflows.display.types import WorkflowDisplayContext
+
+logger = logging.getLogger(__name__)
+
+
+def create_display_context_with_client() -> WorkflowDisplayContext:
+    """Create a WorkflowDisplayContext with Vellum client for serialization."""
+    client = create_vellum_client()
+    return WorkflowDisplayContext(client=client)
+
+
+def get_all_displayable_node_classes() -> List[Type[BaseNode]]:
+    """Get all displayable node classes dynamically from the displayable module."""
+    node_classes = []
+    for class_name in displayable_module.__all__:
+        node_class = getattr(displayable_module, class_name)
+        node_classes.append(node_class)
+    return node_classes
+
+
+def clean_node_definition(definition: Dict[str, Any]) -> Dict[str, Any]:
+    """Remove unwanted fields from a successfully serialized node definition."""
+    fields_to_remove = ["inputs", "data", "type", "adornments", "should_file_merge"]
+    cleaned = {k: v for k, v in definition.items() if k not in fields_to_remove}
+    return cleaned
+
+
+def serialize_node_definition(
+    node_class: Type[BaseNode], display_context: WorkflowDisplayContext
+) -> Optional[Dict[str, Any]]:
+    """Serialize a single node definition, returning None if it fails."""
+    try:
+        display_class = get_node_display_class(node_class)
+        display_instance = display_class()
+        definition = display_instance.serialize(display_context)
+        return clean_node_definition(definition)
+    except Exception as e:
+        logger.info(f"Warning: Failed to serialize {node_class.__name__}: {e}")
+        return None
+
+
+def main() -> None:
+    """Main function to generate node definitions."""
+    logger.info("Generating node definitions...")
+
+    display_context = create_display_context_with_client()
+    node_classes = get_all_displayable_node_classes()
+
+    successful_nodes = []
+    errors = []
+
+    for node_class in node_classes:
+        logger.info(f"Serializing {node_class.__name__}...")
+        definition = serialize_node_definition(node_class, display_context)
+
+        if definition is not None:
+            successful_nodes.append(definition)
+        else:
+            try:
+                display_class = get_node_display_class(node_class)
+                display_instance = display_class()
+                display_instance.serialize(display_context)
+            except Exception as e:
+                errors.append({"node": node_class.__name__, "error": str(e)})
+
+    result = {"nodes": successful_nodes, "errors": errors}
+
+    output_path = "ee/vellum_ee/assets/node-definitions.json"
+    os.makedirs(os.path.dirname(output_path), exist_ok=True)
+
+    with open(output_path, "w") as f:
+        json.dump(result, f, indent=2)
+
+    logger.info(
+        f"Generated {len(successful_nodes)} successful node definitions and {len(errors)} errors in {output_path}"
+    )
+
+
+if __name__ == "__main__":
+    main()

vellum_ee/workflows/display/nodes/vellum/inline_prompt_node.py

@@ -163,9 +163,7 @@ class BaseInlinePromptNodeDisplay(BaseNodeDisplay[_InlinePromptNodeType], Generi
         elif callable(function):
             normalized_functions = compile_function_definition(function)
         elif isinstance(function, DeploymentDefinition):
-            normalized_functions = compile_workflow_deployment_function_definition(
-                function.model_dump(), display_context.client
-            )
+            normalized_functions = compile_workflow_deployment_function_definition(function, display_context.client)
         else:
             raise ValueError(f"Unsupported function type: {type(function)}")
         return {

vellum_ee/workflows/display/nodes/vellum/tests/test_final_output_node.py

@@ -0,0 +1,78 @@
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.nodes import BaseNode
+from vellum.workflows.nodes.displayable.final_output_node import FinalOutputNode
+from vellum.workflows.state.base import BaseState
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+
+def test_final_output_node_display__serialize_with_valid_types():
+    # GIVEN a node that outputs a str
+    class StringNode(BaseNode):
+        class Outputs:
+            result: str
+
+    # AND a FinalOutputNode with matching type to that node
+    class CorrectOutput(FinalOutputNode[BaseState, str]):
+        class Outputs(FinalOutputNode.Outputs):
+            value = StringNode.Outputs.result
+
+    # AND a workflow referencing the node
+    class MyWorkflow(BaseWorkflow):
+        graph = StringNode >> CorrectOutput
+
+        class Outputs(BaseWorkflow.Outputs):
+            final_result = CorrectOutput.Outputs.value
+
+    # WHEN we serialize the workflow
+    workflow_display = get_workflow_display(workflow_class=MyWorkflow)
+
+    # THEN serialization should succeed without raising validation errors
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # AND the node should be properly serialized
+    assert "workflow_raw_data" in serialized_workflow
+    assert "nodes" in serialized_workflow["workflow_raw_data"]
+
+    # Find the terminal node in the serialized output
+    terminal_node = next(
+        node for node in serialized_workflow["workflow_raw_data"]["nodes"] if node["type"] == "TERMINAL"
+    )
+    assert terminal_node is not None
+    assert terminal_node["id"] == str(CorrectOutput.__id__)
+
+
+def test_final_output_node_display__serialize_with_invalid_types_should_raise_error():
+    # GIVEN a node that outputs a str
+    class StringNode(BaseNode):
+        class Outputs:
+            result: str
+
+    # AND a FinalOutputNode with mismatched types (expects list but gets str)
+    class BadOutput(FinalOutputNode[BaseState, list]):
+        """Output with type mismatch."""
+
+        class Outputs(FinalOutputNode.Outputs):
+            value = StringNode.Outputs.result  # str type, conflicts with list
+
+    # AND a workflow referencing the node
+    class MyWorkflow(BaseWorkflow):
+        graph = StringNode >> BadOutput
+
+        class Outputs(BaseWorkflow.Outputs):
+            final_result = BadOutput.Outputs.value
+
+    # WHEN we attempt to serialize the workflow
+    workflow_display = get_workflow_display(workflow_class=MyWorkflow)
+
+    # THEN serialization should complete without raising an exception
+    serialized_workflow = workflow_display.serialize()
+
+    # AND the error should be captured in workflow_display.errors
+    errors = list(workflow_display.display_context.errors)
+    assert len(errors) == 1
+    assert "Output type mismatch" in str(errors[0])
+    assert "list" in str(errors[0])
+    assert "str" in str(errors[0])
+
+    # AND the serialized workflow should still be created
+    assert "workflow_raw_data" in serialized_workflow

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

@@ -437,6 +437,11 @@ def test_serialize_workflow():
                 "name": "max_prompt_iterations",
                 "value": {"type": "CONSTANT_VALUE", "value": {"type": "NUMBER", "value": 5.0}},
             },
+            {
+                "id": "f92dc3ec-a19a-4491-a98a-2b2df322e2e3",
+                "name": "settings",
+                "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+            },
         ],
         "outputs": [
             {"id": "e62bc785-a914-4066-b79e-8c89a5d0ec6c", "name": "text", "type": "STRING", "value": None},