vellum-ai 1.3.4__tar.gz → 1.3.6__tar.gz

{vellum_ai-1.3.4 → vellum_ai-1.3.6}/PKG-INFO

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

{vellum_ai-1.3.4 → vellum_ai-1.3.6}/ee/vellum_ee/workflows/display/nodes/tests/test_base_node_display.py

@@ -100,3 +100,20 @@ def test_serialize_display_data():
         "position": {"x": 0.0, "y": 0.0},
         "comment": {"expanded": True, "value": "I hope this works"},
     }
+
+
+def test_serialize_node_label_with_pascal_case():
+    """
+    Tests that a node with PascalCase name serializes with proper title case label.
+    """
+
+    # GIVEN a node with a PascalCase name that includes common patterns
+    class MyCustomNode(BaseNode):
+        pass
+
+    # WHEN we serialize the node
+    node_display_class = get_node_display_class(MyCustomNode)
+    data = node_display_class().serialize(WorkflowDisplayContext())
+
+    # THEN the label should be converted to proper title case with spaces
+    assert data["label"] == "My Custom Node"

{vellum_ai-1.3.4 → vellum_ai-1.3.6}/ee/vellum_ee/workflows/display/tests/test_base_workflow_display.py

@@ -9,6 +9,8 @@ from vellum.workflows.references.lazy import LazyReference
 from vellum.workflows.state import BaseState
 from vellum.workflows.workflows.base import BaseWorkflow
 from vellum_ee.workflows.display.base import EdgeDisplay, WorkflowInputsDisplay
+from vellum_ee.workflows.display.editor.types import NodeDisplayData, NodeDisplayPosition
+from vellum_ee.workflows.display.nodes import BaseNodeDisplay
 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
 
@@ -429,3 +431,48 @@ def test_serialize_workflow_with_edge_display_data():
     assert edge_with_display_data["type"] == "DEFAULT"
     assert "source_node_id" in edge_with_display_data
     assert "target_node_id" in edge_with_display_data
+
+
+def test_serialize_workflow_with_node_display_data():
+    """
+    Tests that nodes with z_index values serialize display_data correctly.
+    """
+
+    # GIVEN a workflow with a node that has custom display data
+    class TestNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            result: str
+
+    class TestWorkflow(BaseWorkflow):
+        graph = TestNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            final_result = TestNode.Outputs.result
+
+    class TestNodeDisplay(BaseNodeDisplay[TestNode]):
+        display_data = NodeDisplayData(position=NodeDisplayPosition(x=100, y=200), z_index=10, width=300, height=150)
+
+    class TestWorkflowDisplay(BaseWorkflowDisplay[TestWorkflow]):
+        pass
+
+    # WHEN we serialize the workflow with the custom node display
+    display = get_workflow_display(
+        base_display_class=TestWorkflowDisplay,
+        workflow_class=TestWorkflow,
+    )
+    serialized_workflow = display.serialize()
+
+    # THEN the node should include display_data with z_index
+    workflow_raw_data = cast(Dict[str, Any], serialized_workflow["workflow_raw_data"])
+    nodes = cast(List[Dict[str, Any]], workflow_raw_data["nodes"])
+
+    test_node = None
+    for node in nodes:
+        if node.get("type") == "GENERIC":
+            definition = node.get("definition")
+            if isinstance(definition, dict) and definition.get("name") == "TestNode":
+                test_node = node
+                break
+
+    assert test_node is not None, "TestNode not found in serialized nodes"
+    assert test_node["display_data"] == {"position": {"x": 100, "y": 200}, "z_index": 10, "width": 300, "height": 150}

{vellum_ai-1.3.4 → vellum_ai-1.3.6}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_api_node_serialization.py

@@ -173,7 +173,7 @@ def test_serialize_workflow(vellum_client):
                 },
             ],
             "data": {
-                "label": "Simple A P I Node",
+                "label": "Simple API Node",
                 "error_output_id": None,
                 "source_handle_id": "7c33b4d3-9204-4bd5-9371-80ee34f83073",
                 "target_handle_id": "14b538a5-aedb-41f3-b579-039956b7c7ed",

vellum_ai-1.3.6/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_parent_input.py

@@ -0,0 +1,89 @@
+from deepdiff import DeepDiff
+
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+from tests.workflows.basic_tool_calling_node_parent_input.workflow import BasicToolCallingNodeParentInputWorkflow
+
+
+def test_serialize_workflow():
+    # GIVEN a Workflow that uses a generic node
+    # WHEN we serialize it
+    workflow_display = get_workflow_display(workflow_class=BasicToolCallingNodeParentInputWorkflow)
+
+    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": "e2e36cfc-cf24-42fd-ba8f-cce39c53d47b", "key": "text", "type": "STRING"},
+            {"id": "08ca9519-e421-47e8-a42d-44f49f6aab16", "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"][2]
+
+    attributes = tool_calling_node["attributes"]
+    function_attributes = next(attribute for attribute in attributes if attribute["name"] == "functions")
+    assert function_attributes == {
+        "id": "cec9f5f2-7bb0-42e4-9c56-f215f07c5569",
+        "name": "functions",
+        "value": {
+            "type": "CONSTANT_VALUE",
+            "value": {
+                "type": "JSON",
+                "value": [
+                    {
+                        "type": "CODE_EXECUTION",
+                        "name": "get_string",
+                        "description": "\n    Get a string with the parent input, dummy input, and the populated input.\n    ",  # noqa: E501
+                        "definition": {
+                            "state": None,
+                            "cache_config": None,
+                            "name": "get_string",
+                            "description": "\n    Get a string with the parent input, dummy input, and the populated input.\n    ",  # noqa: E501
+                            "parameters": {
+                                "type": "object",
+                                "properties": {"populated_input": {"type": "string"}},
+                                "required": ["populated_input"],
+                            },
+                            "inputs": {
+                                "parent_input": {
+                                    "type": "WORKFLOW_INPUT",
+                                    "input_variable_id": "4bf1f0e7-76c6-4204-9f8c-bd9c3b73a8db",
+                                },
+                                "dummy_input": {
+                                    "type": "NODE_OUTPUT",
+                                    "node_id": "8e89ae10-a709-45ec-89f8-242f92e4a83f",
+                                    "node_output_id": "0cd09f0a-c142-4d5d-acc7-b93cd30ca58d",
+                                },
+                                "constant_input": {
+                                    "type": "CONSTANT_VALUE",
+                                    "value": {"type": "STRING", "value": "constant_input"},
+                                },
+                            },
+                            "forced": None,
+                            "strict": None,
+                        },
+                        "src": 'from vellum.workflows.utils.functions import use_tool_inputs\n\nfrom .inputs import ParentInputs\nfrom .nodes.dummy_node import DummyNode\n\n\n@use_tool_inputs(\n    parent_input=ParentInputs.parent_input,\n    dummy_input=DummyNode.Outputs.text,\n    constant_input="constant_input",\n)\ndef get_string(parent_input: str, dummy_input: str, constant_input: str, populated_input: str) -> str:\n    """\n    Get a string with the parent input, dummy input, and the populated input.\n    """\n    return f"parent input: {parent_input}, dummy input: {dummy_input}, constant input: {constant_input}, populated input: {populated_input}"  # noqa: E501\n',  # noqa: E501
+                    }
+                ],
+            },
+        },
+    }

{vellum_ai-1.3.4 → vellum_ai-1.3.6}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_serialization.py

@@ -195,7 +195,7 @@ def test_serialize_workflow():
                             "frequency_penalty": 0.0,
                             "presence_penalty": 0.0,
                             "logit_bias": None,
-                            "custom_parameters": None,
+                            "custom_parameters": {"mode": "initial"},
                         },
                     },
                 },

vellum_ai-1.3.6/ee/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

{vellum_ai-1.3.4 → vellum_ai-1.3.6}/ee/vellum_ee/workflows/display/utils/expressions.py

@@ -7,6 +7,7 @@ from typing import TYPE_CHECKING, Any, Dict, List, cast
 from pydantic import BaseModel
 
 from vellum.client.types.logical_operator import LogicalOperator
+from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.expressions.accessor import AccessorExpression
 from vellum.workflows.expressions.add import AddExpression
@@ -243,7 +244,14 @@ def serialize_key(key: Any) -> str:
         return str(key)
 
 
+# Sentinel value to indicate a value should be omitted from serialization
+_UNDEFINED_SENTINEL: JsonObject = {"__undefined__": True}
+
+
 def serialize_value(display_context: "WorkflowDisplayContext", value: Any) -> JsonObject:
+    if value is undefined:
+        return _UNDEFINED_SENTINEL
+
     if isinstance(value, ConstantValueReference):
         return serialize_value(display_context, value._value)
 
@@ -314,7 +322,12 @@ def serialize_value(display_context: "WorkflowDisplayContext", value: Any) -> Js
         }
 
     if isinstance(value, list):
-        serialized_items = [serialize_value(display_context, item) for item in value]
+        serialized_items = []
+        for item in value:
+            serialized_item = serialize_value(display_context, item)
+            if serialized_item != _UNDEFINED_SENTINEL:
+                serialized_items.append(serialized_item)
+
         if all(isinstance(item, dict) and item["type"] == "CONSTANT_VALUE" for item in serialized_items):
             constant_values = []
             for item in serialized_items:
@@ -345,14 +358,17 @@ def serialize_value(display_context: "WorkflowDisplayContext", value: Any) -> Js
         return serialize_value(display_context, dict_value)
 
     if isinstance(value, dict):
-        serialized_entries: List[Dict[str, Any]] = [
-            {
-                "id": str(uuid4_from_hash(f"{key}|{val}")),
-                "key": serialize_key(key),
-                "value": serialize_value(display_context, val),
-            }
-            for key, val in value.items()
-        ]
+        serialized_entries: List[Dict[str, Any]] = []
+        for key, val in value.items():
+            serialized_val = serialize_value(display_context, val)
+            if serialized_val != _UNDEFINED_SENTINEL:
+                serialized_entries.append(
+                    {
+                        "id": str(uuid4_from_hash(f"{key}|{val}")),
+                        "key": serialize_key(key),
+                        "value": serialized_val,
+                    }
+                )
 
         # Check if all entries have constant values
         if all(entry["value"]["type"] == "CONSTANT_VALUE" for entry in serialized_entries):
@@ -422,6 +438,23 @@ def serialize_value(display_context: "WorkflowDisplayContext", value: Any) -> Js
 
     if callable(value):
         function_definition = compile_function_definition(value)
+
+        name = function_definition.name
+        description = function_definition.description or ""
+
+        inputs = getattr(value, "__vellum_inputs__", {})
+
+        if inputs:
+            serialized_inputs = {}
+            for param_name, input_ref in inputs.items():
+                serialized_inputs[param_name] = serialize_value(display_context, input_ref)
+
+            model_data = function_definition.model_dump()
+            model_data["inputs"] = serialized_inputs
+            function_definition_data = model_data
+        else:
+            function_definition_data = function_definition.model_dump()
+
         source_path = inspect.getsourcefile(value)
         if source_path is not None:
             with virtual_open(source_path) as f:
@@ -435,9 +468,9 @@ def serialize_value(display_context: "WorkflowDisplayContext", value: Any) -> Js
                 "type": "JSON",
                 "value": {
                     "type": "CODE_EXECUTION",
-                    "name": function_definition.name,
-                    "description": function_definition.description,
-                    "definition": function_definition.model_dump(),
+                    "name": name,
+                    "description": description,
+                    "definition": function_definition_data,
                     "src": source_code,
                 },
             },

{vellum_ai-1.3.4 → vellum_ai-1.3.6}/ee/vellum_ee/workflows/display/utils/vellum.py

@@ -102,7 +102,9 @@ def create_node_input_value_pointer_rule(
     if isinstance(value, OutputReference):
         if value not in display_context.global_node_output_displays:
             if issubclass(value.outputs_class, BaseNode.Outputs):
-                raise ValueError(f"Reference to node '{value.outputs_class._node_class.__name__}' not found in graph.")
+                raise ValueError(
+                    f"Reference to node '{value.outputs_class.__parent_class__.__name__}' not found in graph."
+                )
 
             raise ValueError(f"Reference to outputs '{value.outputs_class.__qualname__}' is invalid.")
 

{vellum_ai-1.3.4 → vellum_ai-1.3.6}/ee/vellum_ee/workflows/display/workflows/base_workflow_display.py

@@ -294,7 +294,7 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
                     )
 
             elif isinstance(workflow_output.instance, OutputReference):
-                terminal_node_id = workflow_output.instance.outputs_class._node_class.__id__
+                terminal_node_id = workflow_output.instance.outputs_class.__parent_class__.__id__
                 serialized_terminal_node = serialized_nodes.get(terminal_node_id)
                 if serialized_terminal_node and isinstance(serialized_terminal_node["data"], dict):
                     serialized_terminal_node["data"]["name"] = workflow_output_display.name
@@ -688,10 +688,8 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
 
         return EntrypointDisplay(id=entrypoint_id, edge_display=edge_display)
 
-    def _generate_workflow_output_display(self, output: BaseDescriptor) -> WorkflowOutputDisplay:
-        output_id = uuid4_from_hash(f"{self.workflow_id}|id|{output.name}")
-
-        return WorkflowOutputDisplay(id=output_id, name=output.name)
+    def _generate_workflow_output_display(self, output: OutputReference) -> WorkflowOutputDisplay:
+        return WorkflowOutputDisplay(id=output.id, name=output.name)
 
     def __init_subclass__(cls, **kwargs: Any) -> None:
         super().__init_subclass__(**kwargs)

{vellum_ai-1.3.4 → vellum_ai-1.3.6}/pyproject.toml

@@ -3,7 +3,7 @@ name = "vellum-ai"
 
 [tool.poetry]
 name = "vellum-ai"
-version = "1.3.4"
+version = "1.3.6"
 description = ""
 readme = "README.md"
 authors = []

{vellum_ai-1.3.4 → vellum_ai-1.3.6}/src/vellum/client/README.md

@@ -232,3 +232,19 @@ client = Vellum(
 )
 ```
 
+## Contributing
+
+While we value open-source contributions to this SDK, this library is generated programmatically.
+Additions made directly to this library would have to be moved over to our generation code,
+otherwise they would be overwritten upon the next generated release. Feel free to open a PR as
+a proof of concept, but know that we will not be able to merge it as-is. We suggest opening
+an issue first to discuss with us!
+
+On the other hand, contributions to the README are always very welcome!
+## Open-Source vs. Paid
+
+This repo is available under the [MIT expat license](https://github.com/vellum-ai/vellum-python-sdks/blob/main/LICENSE), except
+for the `ee` directory (which has its [license here](https://github.com/vellum-ai/vellum-python-sdks/blob/main/ee/LICENSE)) if applicable.
+
+To learn more, [book a demo](https://www.vellum.ai/landing-pages/request-demo) or see our [pricing page](https://www.vellum.ai/pricing).
+

{vellum_ai-1.3.4 → vellum_ai-1.3.6}/src/vellum/client/core/client_wrapper.py

@@ -27,10 +27,10 @@ class BaseClientWrapper:
 
     def get_headers(self) -> typing.Dict[str, str]:
         headers: typing.Dict[str, str] = {
-            "User-Agent": "vellum-ai/1.3.4",
+            "User-Agent": "vellum-ai/1.3.6",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "1.3.4",
+            "X-Fern-SDK-Version": "1.3.6",
             **(self.get_custom_headers() or {}),
         }
         if self._api_version is not None:

{vellum_ai-1.3.4 → vellum_ai-1.3.6}/src/vellum/plugins/vellum_mypy.py

@@ -20,6 +20,7 @@ from mypy.types import AnyType, CallableType, FunctionLike, Instance, Type as My
 
 TypeResolver = Callable[[str, List[MypyType]], MypyType]
 NODE_ATTRIBUTE_REGEX = r"^[a-z].*$"
+BASE_NODE_FULLNAME = "vellum.workflows.nodes.bases.base.BaseNode"
 
 DESCRIPTOR_PATHS: list[tuple[str, str, str]] = [
     (
@@ -28,12 +29,12 @@ DESCRIPTOR_PATHS: list[tuple[str, str, str]] = [
         r"^[^_].*$",
     ),
     (
-        "vellum.workflows.nodes.bases.base.BaseNode.ExternalInputs",
+        f"{BASE_NODE_FULLNAME}.ExternalInputs",
         "vellum.workflows.references.external_input.ExternalInputReference",
         r"^[^_].*$",
     ),
     (
-        "vellum.workflows.nodes.bases.base.BaseNode.Execution",
+        f"{BASE_NODE_FULLNAME}.Execution",
         "vellum.workflows.references.execution_count.ExecutionCountReference",
         r"^count$",
     ),
@@ -48,7 +49,7 @@ DESCRIPTOR_PATHS: list[tuple[str, str, str]] = [
         r"^[^_].*$",
     ),
     (
-        "vellum.workflows.nodes.bases.base.BaseNode",
+        BASE_NODE_FULLNAME,
         "vellum.workflows.references.node.NodeReference",
         NODE_ATTRIBUTE_REGEX,
     ),
@@ -163,7 +164,7 @@ class VellumMypyPlugin(Plugin):
         elif _is_subclass(ctx.cls.info, "vellum.workflows.nodes.displayable.final_output_node.node.FinalOutputNode"):
             self._dynamic_output_node_class_hook(ctx, "value")
 
-        if _is_subclass(ctx.cls.info, "vellum.workflows.nodes.bases.base.BaseNode"):
+        if _is_subclass(ctx.cls.info, BASE_NODE_FULLNAME):
             return self._base_node_class_hook(ctx)
 
         if _is_subclass(ctx.cls.info, "vellum.workflows.workflows.base.BaseWorkflow"):
@@ -241,6 +242,9 @@ class VellumMypyPlugin(Plugin):
         """
 
         for key, sym in ctx.cls.info.names.items():
+            if ctx.cls.info.fullname == BASE_NODE_FULLNAME:
+                continue
+
             if not isinstance(sym.node, Var):
                 continue
 
@@ -250,6 +254,7 @@ class VellumMypyPlugin(Plugin):
             type_ = sym.node.type
             if not type_:
                 continue
+
             sym.node.type = self._get_resolvable_type(
                 lambda fullname, types: ctx.api.named_type(fullname, types), type_
             )
@@ -301,7 +306,7 @@ class VellumMypyPlugin(Plugin):
                     and isinstance(arg.expr, MemberExpr)
                     and isinstance(arg.expr.expr, NameExpr)
                     and isinstance(arg.expr.expr.node, TypeInfo)
-                    and _is_subclass(arg.expr.expr.node, "vellum.workflows.nodes.bases.base.BaseNode")
+                    and _is_subclass(arg.expr.expr.node, BASE_NODE_FULLNAME)
                     and arg.expr.name == "Outputs"
                 ):
                     self._calls_with_nested_descriptor_expressions.add(call_expr)
@@ -548,7 +553,7 @@ class VellumMypyPlugin(Plugin):
         if not isinstance(ctx.default_return_type, Instance):
             return ctx.default_return_type
 
-        if not _is_subclass(ctx.default_return_type.type, "vellum.workflows.nodes.bases.base.BaseNode.Outputs"):
+        if not _is_subclass(ctx.default_return_type.type, f"{BASE_NODE_FULLNAME}.Outputs"):
             return ctx.default_return_type
 
         outputs_node = self._get_node_outputs_type_info(ctx)
@@ -677,9 +682,7 @@ class VellumMypyPlugin(Plugin):
 
         expr = ctx.context.callee.expr
         instance = ctx.api.get_expression_type(expr)
-        if not isinstance(instance, Instance) or not _is_subclass(
-            instance.type, "vellum.workflows.nodes.bases.base.BaseNode"
-        ):
+        if not isinstance(instance, Instance) or not _is_subclass(instance.type, BASE_NODE_FULLNAME):
             return None
 
         outputs_node = instance.type.names.get("Outputs")

vellum_ai-1.3.6/src/vellum/workflows/executable.py

@@ -0,0 +1,9 @@
+from uuid import UUID
+from typing import Dict
+
+from vellum.workflows.utils.uuids import uuid4_from_hash
+
+
+class BaseExecutable:
+    __id__: UUID = uuid4_from_hash(__qualname__)
+    __output_ids__: Dict[str, UUID] = {}

{vellum_ai-1.3.4 → vellum_ai-1.3.6}/src/vellum/workflows/graph/graph.py

@@ -96,6 +96,11 @@ class Graph:
     def from_edge(edge: Edge) -> "Graph":
         return Graph(entrypoints={edge.from_port}, edges=[edge], terminals={port for port in edge.to_node.Ports})
 
+    @staticmethod
+    def empty() -> "Graph":
+        """Create an empty graph with no entrypoints, edges, or terminals."""
+        return Graph(entrypoints=set(), edges=[], terminals=set())
+
     def __rshift__(self, other: GraphTarget) -> "Graph":
         if not self._edges and not self._entrypoints:
             raise ValueError("Graph instance can only create new edges from nodes within existing edges")

{vellum_ai-1.3.4 → vellum_ai-1.3.6}/src/vellum/workflows/graph/tests/test_graph.py

@@ -4,6 +4,23 @@ from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.ports.port import Port
 
 
+def test_graph__empty():
+    # WHEN we create an empty graph
+    graph = Graph.empty()
+
+    # THEN the graph has no entrypoints
+    assert len(list(graph.entrypoints)) == 0
+
+    # AND no nodes
+    assert len(list(graph.nodes)) == 0
+
+    # AND no edges
+    assert len(list(graph.edges)) == 0
+
+    # AND string representation indicates empty graph
+    assert str(graph) == "Graph(empty)"
+
+
 def test_graph__from_node():
     # GIVEN a node
     class MyNode(BaseNode):

{vellum_ai-1.3.4 → vellum_ai-1.3.6}/src/vellum/workflows/nodes/bases/base.py

@@ -13,6 +13,7 @@ from vellum.workflows.descriptors.utils import is_unresolved, resolve_value
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.events.node import NodeExecutionStreamingEvent
 from vellum.workflows.exceptions import NodeException
+from vellum.workflows.executable import BaseExecutable
 from vellum.workflows.graph import Graph
 from vellum.workflows.graph.graph import GraphTarget
 from vellum.workflows.inputs.base import BaseInputs
@@ -120,7 +121,7 @@ class BaseNodeMeta(ABCMeta):
         cls = super().__new__(mcs, name, bases, dct)
         node_class = cast(Type["BaseNode"], cls)
 
-        node_class.Outputs._node_class = node_class
+        node_class.Outputs.__parent_class__ = node_class
 
         # Add cls to relevant nested classes, since python should've been doing this by default
         for port in node_class.Ports:
@@ -260,9 +261,7 @@ class _BaseNodeExecutionMeta(type):
 NodeRunResponse = Union[BaseOutputs, Iterator[BaseOutput]]
 
 
-class BaseNode(Generic[StateType], ABC, metaclass=BaseNodeMeta):
-    __id__: UUID = uuid4_from_hash(__qualname__)
-    __output_ids__: Dict[str, UUID] = {}
+class BaseNode(Generic[StateType], ABC, BaseExecutable, metaclass=BaseNodeMeta):
     state: StateType
     _context: WorkflowContext
     _inputs: MappingProxyType[NodeReference, Any]
@@ -270,11 +269,8 @@ class BaseNode(Generic[StateType], ABC, metaclass=BaseNodeMeta):
     class ExternalInputs(BaseInputs):
         __descriptor_class__ = ExternalInputReference
 
-    # TODO: Consider using metaclasses to prevent the need for users to specify that the
-    #   "Outputs" class inherits from "BaseOutputs" and do so automatically.
-    #   https://app.shortcut.com/vellum/story/4008/auto-inherit-basenodeoutputs-in-outputs-classes
     class Outputs(BaseOutputs):
-        _node_class: Type["BaseNode"] = field(init=False)
+        __parent_class__: Type["BaseNode"] = field(init=False)
 
     class Ports(NodePorts):
         default = Port(default=True)