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

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

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

{vellum_ai-1.3.4 → vellum_ai-1.3.5}/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.5/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_parent_input.py

@@ -0,0 +1,85 @@
+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",
+                                },
+                            },
+                            "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)\ndef get_string(parent_input: str, dummy_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"This is the parent input: {parent_input}, this is the dummy input: {dummy_input}, and this is the populated input: {populated_input}"  # noqa: E501\n',  # noqa: E501
+                    }
+                ],
+            },
+        },
+    }

{vellum_ai-1.3.4 → vellum_ai-1.3.5}/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.5/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.5}/ee/vellum_ee/workflows/display/utils/expressions.py

@@ -6,6 +6,7 @@ from typing import TYPE_CHECKING, Any, Dict, List, cast
 
 from pydantic import BaseModel
 
+from vellum.client.types.function_definition import FunctionDefinition
 from vellum.client.types.logical_operator import LogicalOperator
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.expressions.accessor import AccessorExpression
@@ -422,6 +423,17 @@ def serialize_value(display_context: "WorkflowDisplayContext", value: Any) -> Js
 
     if callable(value):
         function_definition = compile_function_definition(value)
+        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 = FunctionDefinition.model_validate(model_data)
+
         source_path = inspect.getsourcefile(value)
         if source_path is not None:
             with virtual_open(source_path) as f:

{vellum_ai-1.3.4 → vellum_ai-1.3.5}/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.5}/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
@@ -599,7 +599,7 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
 
             workflow_output_display = self.output_displays.get(workflow_output)
             workflow_output_displays[workflow_output] = (
-                workflow_output_display or self._generate_workflow_output_display(workflow_output)
+                workflow_output_display or self._generate_workflow_output_display(workflow_output, self._workflow)
             )
 
         return WorkflowDisplayContext(
@@ -688,9 +688,13 @@ 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}")
-
+    def _generate_workflow_output_display(
+        self, output: OutputReference, workflow_class: Type[BaseWorkflow]
+    ) -> WorkflowOutputDisplay:
+        # TODO: use the output.id field instead once we add `__parent_class__` to BaseWorkflow.Outputs
+        output_id = workflow_class.__output_ids__.get(output.name) or uuid4_from_hash(
+            f"{self.workflow_id}|id|{output.name}"
+        )
         return WorkflowOutputDisplay(id=output_id, name=output.name)
 
     def __init_subclass__(cls, **kwargs: Any) -> None:

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

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

{vellum_ai-1.3.4 → vellum_ai-1.3.5}/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.5",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "1.3.4",
+            "X-Fern-SDK-Version": "1.3.5",
             **(self.get_custom_headers() or {}),
         }
         if self._api_version is not None:

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

@@ -120,7 +120,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:
@@ -270,11 +270,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)

{vellum_ai-1.3.4 → vellum_ai-1.3.5}/src/vellum/workflows/nodes/core/map_node/node.py

@@ -27,6 +27,7 @@ from vellum.workflows.nodes.bases.base_adornment_node import BaseAdornmentNode
 from vellum.workflows.nodes.utils import create_adornment
 from vellum.workflows.outputs import BaseOutputs
 from vellum.workflows.outputs.base import BaseOutput
+from vellum.workflows.references.node import NodeReference
 from vellum.workflows.references.output import OutputReference
 from vellum.workflows.state.context import WorkflowContext
 from vellum.workflows.types.generics import StateType
@@ -217,5 +218,11 @@ class MapNode(BaseAdornmentNode[StateType], Generic[StateType, MapNodeItemType])
         #     value: List[str]
         outputs_class.__annotations__ = {**previous_annotations, reference.name: annotation}
 
-        output_id = uuid4_from_hash(f"{cls.__id__}|{reference.name}")
+        subworkflow_class = cls.subworkflow.instance if isinstance(cls.subworkflow, NodeReference) else None
+        if subworkflow_class:
+            output_id = subworkflow_class.__output_ids__.get(reference.name) or uuid4_from_hash(
+                f"{cls.__id__}|{reference.name}"
+            )
+        else:
+            output_id = uuid4_from_hash(f"{cls.__id__}|{reference.name}")
         cls.__output_ids__[reference.name] = output_id

{vellum_ai-1.3.4 → vellum_ai-1.3.5}/src/vellum/workflows/nodes/displayable/bases/inline_prompt_node/node.py

@@ -100,7 +100,7 @@ class BaseInlinePromptNode(BasePromptNode[StateType], Generic[StateType]):
         execution_context = get_execution_context()
         request_options = self.request_options or RequestOptions()
 
-        processed_parameters = self._process_parameters(self.parameters)
+        processed_parameters = self.process_parameters(self.parameters)
 
         request_options["additional_body_parameters"] = {
             "execution_context": execution_context.model_dump(mode="json"),
@@ -300,7 +300,7 @@ class BaseInlinePromptNode(BasePromptNode[StateType], Generic[StateType]):
 
         return input_variables, input_values
 
-    def _process_parameters(self, parameters: PromptParameters) -> PromptParameters:
+    def process_parameters(self, parameters: PromptParameters) -> PromptParameters:
         """
         Process parameters to recursively convert any Pydantic models to JSON schema dictionaries.
         """

{vellum_ai-1.3.4 → vellum_ai-1.3.5}/src/vellum/workflows/nodes/displayable/guardrail_node/node.py

@@ -8,7 +8,6 @@ from vellum.workflows.constants import LATEST_RELEASE_TAG
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases import BaseNode
-from vellum.workflows.outputs.base import BaseOutputs
 from vellum.workflows.types.core import EntityInputsInterface, MergeBehavior
 from vellum.workflows.types.generics import StateType
 
@@ -33,7 +32,7 @@ class GuardrailNode(BaseNode[StateType], Generic[StateType]):
     class Trigger(BaseNode.Trigger):
         merge_behavior = MergeBehavior.AWAIT_ANY
 
-    class Outputs(BaseOutputs):
+    class Outputs(BaseNode.Outputs):
         score: float
         normalized_score: Optional[float]
         log: Optional[str]
@@ -98,7 +97,13 @@ class GuardrailNode(BaseNode[StateType], Generic[StateType]):
         else:
             reason = None
 
-        return self.Outputs(score=score, normalized_score=normalized_score, log=log, reason=reason, **metric_outputs)
+        return self.Outputs(
+            score=score,
+            normalized_score=normalized_score,
+            log=log,
+            reason=reason,
+            **metric_outputs,  # type: ignore [arg-type]
+        )
 
     def _compile_metric_inputs(self) -> List[MetricDefinitionInput]:
         # TODO: We may want to consolidate with prompt deployment input compilation

{vellum_ai-1.3.4 → vellum_ai-1.3.5}/src/vellum/workflows/nodes/displayable/tool_calling_node/node.py

@@ -138,6 +138,9 @@ class ToolCallingNode(BaseNode[StateType], Generic[StateType]):
                 )
 
     def _build_graph(self) -> None:
+        # Get the process_parameters method if it exists on this class
+        process_parameters_method = getattr(self.__class__, "process_parameters", None)
+
         self.tool_prompt_node = create_tool_prompt_node(
             ml_model=self.ml_model,
             blocks=self.blocks,
@@ -145,6 +148,7 @@ class ToolCallingNode(BaseNode[StateType], Generic[StateType]):
             prompt_inputs=self.prompt_inputs,
             parameters=self.parameters,
             max_prompt_iterations=self.max_prompt_iterations,
+            process_parameters_method=process_parameters_method,
         )
 
         # Create the router node (handles routing logic only)

{vellum_ai-1.3.4 → vellum_ai-1.3.5}/src/vellum/workflows/nodes/displayable/tool_calling_node/utils.py

@@ -329,6 +329,7 @@ def create_tool_prompt_node(
     prompt_inputs: Optional[EntityInputsInterface],
     parameters: PromptParameters,
     max_prompt_iterations: Optional[int] = None,
+    process_parameters_method: Optional[Callable] = None,
 ) -> Type[ToolPromptNode]:
     if functions and len(functions) > 0:
         prompt_functions: List[Union[Tool, FunctionDefinition]] = []
@@ -398,6 +399,7 @@ def create_tool_prompt_node(
                 "prompt_inputs": node_prompt_inputs,
                 "parameters": parameters,
                 "max_prompt_iterations": max_prompt_iterations,
+                **({"process_parameters": process_parameters_method} if process_parameters_method is not None else {}),
                 "__module__": __name__,
             },
         ),

{vellum_ai-1.3.4 → vellum_ai-1.3.5}/src/vellum/workflows/outputs/base.py

@@ -1,5 +1,6 @@
+from dataclasses import field
 import inspect
-from typing import TYPE_CHECKING, Any, Generic, Iterator, Set, Tuple, Type, TypeVar, Union, cast
+from typing import Any, Generic, Iterator, Set, Tuple, Type, TypeVar, Union, cast
 from typing_extensions import dataclass_transform
 
 from pydantic import GetCoreSchemaHandler
@@ -13,9 +14,6 @@ from vellum.workflows.references.output import OutputReference
 from vellum.workflows.types.generics import is_node_instance
 from vellum.workflows.types.utils import get_class_attr_names, infer_types
 
-if TYPE_CHECKING:
-    from vellum.workflows.nodes.bases.base import BaseNode
-
 _Delta = TypeVar("_Delta")
 _Accumulated = TypeVar("_Accumulated")
 
@@ -112,18 +110,16 @@ class _BaseOutputsMeta(type):
         if not cls.__qualname__.endswith(".Outputs") or not other.__qualname__.endswith(".Outputs"):
             return super().__eq__(other)
 
-        self_outputs_class = cast(Type["BaseNode.Outputs"], cls)
-        other_outputs_class = cast(Type["BaseNode.Outputs"], other)
+        self_outputs_class = cast(Type["BaseOutputs"], cls)
+        other_outputs_class = cast(Type["BaseOutputs"], other)
 
-        if not hasattr(self_outputs_class, "_node_class") or not hasattr(other_outputs_class, "_node_class"):
+        if not hasattr(self_outputs_class, "__parent_class__") or not hasattr(other_outputs_class, "__parent_class__"):
             return super().__eq__(other)
 
-        if self_outputs_class._node_class is None or other_outputs_class._node_class is None:
+        if self_outputs_class.__parent_class__ is None or other_outputs_class.__parent_class__ is None:
             return super().__eq__(other)
 
-        return getattr(self_outputs_class._node_class, "__qualname__") == getattr(
-            other_outputs_class._node_class, "__qualname__"
-        )
+        return self_outputs_class.__parent_class__.__qualname__ == other_outputs_class.__parent_class__.__qualname__
 
     def __setattr__(cls, name: str, value: Any) -> None:
         if isinstance(value, OutputReference):
@@ -187,6 +183,10 @@ class _BaseOutputsMeta(type):
 
 
 class BaseOutputs(metaclass=_BaseOutputsMeta):
+    # TODO: Uncomment once we figure out why this causes a failure in `infer_types`
+    # __parent_class__: Type[Union["BaseNode", "BaseWorkflow"]] = field(init=False)
+    __parent_class__: Type = field(init=False)
+
     def __init__(self, **kwargs: Any) -> None:
         declared_fields = {descriptor.name for descriptor in self.__class__}
         provided_fields = set(kwargs.keys())

{vellum_ai-1.3.4 → vellum_ai-1.3.5}/src/vellum/workflows/references/output.py

@@ -35,13 +35,11 @@ class OutputReference(BaseDescriptor[_OutputType], Generic[_OutputType]):
 
     @cached_property
     def id(self) -> UUID:
-        self._outputs_class = self._outputs_class
-
-        node_class = getattr(self._outputs_class, "_node_class", None)
-        if not node_class:
+        parent_class = self._outputs_class.__parent_class__
+        if not parent_class:
             return uuid4()
 
-        output_ids = getattr(node_class, "__output_ids__", {})
+        output_ids = getattr(parent_class, "__output_ids__", {})
         if not isinstance(output_ids, dict):
             return uuid4()
 

{vellum_ai-1.3.4 → vellum_ai-1.3.5}/src/vellum/workflows/workflows/base.py

@@ -1,3 +1,4 @@
+from dataclasses import field
 from datetime import datetime
 from functools import lru_cache
 import importlib
@@ -199,6 +200,12 @@ class _BaseWorkflowMeta(type):
         if inputs_class is not BaseInputs and inputs_class.__parent_class__ is type(None):
             inputs_class.__parent_class__ = workflow_class
 
+        # TODO: Uncomment this once we figure out why it's causing the ipython reload test to fail
+        # workflow_class.Outputs.__parent_class__ = workflow_class
+        workflow_class.__output_ids__ = {
+            ref.name: uuid4_from_hash(f"{workflow_class.__id__}|id|{ref.name}") for ref in workflow_class.Outputs
+        }
+
         return workflow_class
 
 
@@ -207,6 +214,7 @@ GraphAttribute = Union[Type[BaseNode], Graph, Set[Type[BaseNode]], Set[Graph]]
 
 class BaseWorkflow(Generic[InputsType, StateType], metaclass=_BaseWorkflowMeta):
     __id__: UUID = uuid4_from_hash(__qualname__)
+    __output_ids__: Dict[str, UUID] = {}
     graph: ClassVar[GraphAttribute]
     unused_graphs: ClassVar[Set[GraphAttribute]]  # nodes or graphs that are defined but not used in the graph
     emitters: List[BaseWorkflowEmitter]
@@ -214,7 +222,7 @@ class BaseWorkflow(Generic[InputsType, StateType], metaclass=_BaseWorkflowMeta):
     is_dynamic: ClassVar[bool] = False
 
     class Outputs(BaseOutputs):
-        pass
+        __parent_class__: Type["BaseWorkflow"] = field(init=False)
 
     WorkflowEvent = Union[  # type: ignore
         GenericWorkflowEvent,