vellum-ai 0.14.38__py3-none-any.whl → 0.14.40__py3-none-any.whl

vellum/__init__.py

@@ -443,6 +443,7 @@ from .types import (
     TestSuiteRunMetricNumberOutput,
     TestSuiteRunMetricOutput,
     TestSuiteRunMetricStringOutput,
+    TestSuiteRunProgress,
     TestSuiteRunPromptSandboxExecConfigDataRequest,
     TestSuiteRunPromptSandboxExecConfigRequest,
     TestSuiteRunPromptSandboxHistoryItemExecConfig,
@@ -1072,6 +1073,7 @@ __all__ = [
     "TestSuiteRunMetricNumberOutput",
     "TestSuiteRunMetricOutput",
     "TestSuiteRunMetricStringOutput",
+    "TestSuiteRunProgress",
     "TestSuiteRunPromptSandboxExecConfigDataRequest",
     "TestSuiteRunPromptSandboxExecConfigRequest",
     "TestSuiteRunPromptSandboxHistoryItemExecConfig",

vellum/client/core/client_wrapper.py

@@ -18,7 +18,7 @@ class BaseClientWrapper:
         headers: typing.Dict[str, str] = {
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "0.14.38",
+            "X-Fern-SDK-Version": "0.14.40",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

vellum/client/types/__init__.py

@@ -453,6 +453,7 @@ from .test_suite_run_metric_json_output import TestSuiteRunMetricJsonOutput
 from .test_suite_run_metric_number_output import TestSuiteRunMetricNumberOutput
 from .test_suite_run_metric_output import TestSuiteRunMetricOutput
 from .test_suite_run_metric_string_output import TestSuiteRunMetricStringOutput
+from .test_suite_run_progress import TestSuiteRunProgress
 from .test_suite_run_prompt_sandbox_exec_config_data_request import TestSuiteRunPromptSandboxExecConfigDataRequest
 from .test_suite_run_prompt_sandbox_exec_config_request import TestSuiteRunPromptSandboxExecConfigRequest
 from .test_suite_run_prompt_sandbox_history_item_exec_config import TestSuiteRunPromptSandboxHistoryItemExecConfig
@@ -1052,6 +1053,7 @@ __all__ = [
     "TestSuiteRunMetricNumberOutput",
     "TestSuiteRunMetricOutput",
     "TestSuiteRunMetricStringOutput",
+    "TestSuiteRunProgress",
     "TestSuiteRunPromptSandboxExecConfigDataRequest",
     "TestSuiteRunPromptSandboxExecConfigRequest",
     "TestSuiteRunPromptSandboxHistoryItemExecConfig",

vellum/client/types/test_suite_run_progress.py

@@ -0,0 +1,20 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.pydantic_utilities import UniversalBaseModel
+from ..core.pydantic_utilities import IS_PYDANTIC_V2
+import typing
+import pydantic
+
+
+class TestSuiteRunProgress(UniversalBaseModel):
+    number_of_requested_test_cases: int
+    number_of_completed_test_cases: int
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

vellum/client/types/test_suite_run_read.py

@@ -9,6 +9,7 @@ from .test_suite_run_state import TestSuiteRunState
 import pydantic
 import typing
 from .test_suite_run_exec_config import TestSuiteRunExecConfig
+from .test_suite_run_progress import TestSuiteRunProgress
 from ..core.pydantic_utilities import IS_PYDANTIC_V2
 from ..core.pydantic_utilities import update_forward_refs
 
@@ -33,6 +34,8 @@ class TestSuiteRunRead(UniversalBaseModel):
     Configuration that defines how the Test Suite should be run
     """
 
+    progress: typing.Optional[TestSuiteRunProgress] = None
+
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
     else:

vellum/client/types/vellum_sdk_error_code_enum.py

@@ -11,6 +11,7 @@ VellumSdkErrorCodeEnum = typing.Union[
         "INVALID_CODE",
         "INVALID_TEMPLATE",
         "INTERNAL_ERROR",
+        "PROVIDER_CREDENTIALS_UNAVAILABLE",
         "PROVIDER_ERROR",
         "USER_DEFINED_ERROR",
         "WORKFLOW_CANCELLED",

vellum/client/types/workflow_execution_event_error_code.py

@@ -6,6 +6,7 @@ WorkflowExecutionEventErrorCode = typing.Union[
     typing.Literal[
         "WORKFLOW_INITIALIZATION",
         "WORKFLOW_CANCELLED",
+        "PROVIDER_CREDENTIALS_UNAVAILABLE",
         "NODE_EXECUTION_COUNT_LIMIT_REACHED",
         "INTERNAL_SERVER_ERROR",
         "NODE_EXECUTION",

vellum/types/test_suite_run_progress.py

@@ -0,0 +1,3 @@
+# WARNING: This file will be removed in a future release. Please import from "vellum.client" instead.
+
+from vellum.client.types.test_suite_run_progress import *

vellum/workflows/errors/types.py

@@ -17,6 +17,7 @@ class WorkflowErrorCode(Enum):
     INVALID_TEMPLATE = "INVALID_TEMPLATE"
     INTERNAL_ERROR = "INTERNAL_ERROR"
     NODE_EXECUTION = "NODE_EXECUTION"
+    PROVIDER_CREDENTIALS_UNAVAILABLE = "PROVIDER_CREDENTIALS_UNAVAILABLE"
     PROVIDER_ERROR = "PROVIDER_ERROR"
     USER_DEFINED_ERROR = "USER_DEFINED_ERROR"
     WORKFLOW_CANCELLED = "WORKFLOW_CANCELLED"

vellum/workflows/events/tests/test_event.py

@@ -89,6 +89,7 @@ mock_node_uuid = str(uuid4_from_hash(MockNode.__qualname__))
                         "foo": "bar",
                     },
                     "display_context": None,
+                    "initial_state": None,
                 },
                 "parent": None,
             },

vellum/workflows/events/workflow.py

@@ -54,8 +54,10 @@ class WorkflowEventDisplayContext(UniversalBaseModel):
     workflow_outputs: Dict[str, UUID]
 
 
-class WorkflowExecutionInitiatedBody(_BaseWorkflowExecutionBody, Generic[InputsType]):
+class WorkflowExecutionInitiatedBody(_BaseWorkflowExecutionBody, Generic[InputsType, StateType]):
     inputs: InputsType
+    initial_state: Optional[StateType] = None
+
     # It is still the responsibility of the workflow server to populate this context. The SDK's
     # Workflow Runner will always leave this field None.
     #
@@ -67,15 +69,23 @@ class WorkflowExecutionInitiatedBody(_BaseWorkflowExecutionBody, Generic[InputsT
     def serialize_inputs(self, inputs: InputsType, _info: Any) -> Dict[str, Any]:
         return default_serializer(inputs)
 
+    @field_serializer("initial_state")
+    def serialize_initial_state(self, initial_state: Optional[StateType], _info: Any) -> Optional[Dict[str, Any]]:
+        return default_serializer(initial_state)
+
 
-class WorkflowExecutionInitiatedEvent(_BaseWorkflowEvent, Generic[InputsType]):
+class WorkflowExecutionInitiatedEvent(_BaseWorkflowEvent, Generic[InputsType, StateType]):
     name: Literal["workflow.execution.initiated"] = "workflow.execution.initiated"
-    body: WorkflowExecutionInitiatedBody[InputsType]
+    body: WorkflowExecutionInitiatedBody[InputsType, StateType]
 
     @property
     def inputs(self) -> InputsType:
         return self.body.inputs
 
+    @property
+    def initial_state(self) -> Optional[StateType]:
+        return self.body.initial_state
+
 
 class WorkflowExecutionStreamingBody(_BaseWorkflowExecutionBody):
     output: BaseOutput

vellum/workflows/nodes/bases/tests/test_base_node.py

@@ -4,11 +4,13 @@ from typing import Optional
 
 from vellum.client.types.string_vellum_value_request import StringVellumValueRequest
 from vellum.core.pydantic_utilities import UniversalBaseModel
+from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.tests.test_utils import FixtureState
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes import FinalOutputNode
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.outputs.base import BaseOutputs
+from vellum.workflows.references.output import OutputReference
 from vellum.workflows.state.base import BaseState, StateMeta
 
 
@@ -259,3 +261,25 @@ def test_resolve_value__for_falsy_values(falsy_value, expected_type):
 
     # THEN the output has the correct value
     assert falsy_output.value == falsy_value
+
+
+def test_node_outputs__inherits_instance():
+    # GIVEN a node with two outputs, one with and one without a default instance
+    class MyNode(BaseNode):
+        class Outputs:
+            foo: str
+            bar = "hello"
+
+    # AND a node that inherits from MyNode
+    class InheritedNode(MyNode):
+        pass
+
+    # WHEN we reference each output
+    foo_output = InheritedNode.Outputs.foo
+    bar_output = InheritedNode.Outputs.bar
+
+    # THEN the output reference instances are correct
+    assert isinstance(foo_output, OutputReference)
+    assert foo_output.instance is undefined
+    assert isinstance(bar_output, OutputReference)
+    assert bar_output.instance == "hello"

vellum/workflows/nodes/core/try_node/node.py

@@ -4,7 +4,6 @@ from vellum.workflows.context import execution_context, get_parent_context
 from vellum.workflows.errors.types import WorkflowError, WorkflowErrorCode
 from vellum.workflows.events.workflow import is_workflow_event
 from vellum.workflows.exceptions import NodeException
-from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.bases.base_adornment_node import BaseAdornmentNode
 from vellum.workflows.nodes.utils import create_adornment
 from vellum.workflows.outputs.base import BaseOutput, BaseOutputs
@@ -24,7 +23,7 @@ class TryNode(BaseAdornmentNode[StateType], Generic[StateType]):
 
     on_error_code: Optional[WorkflowErrorCode] = None
 
-    class Outputs(BaseNode.Outputs):
+    class Outputs(BaseAdornmentNode.Outputs):
         error: Optional[WorkflowError] = None
 
     def run(self) -> Iterator[BaseOutput]:

vellum/workflows/nodes/displayable/bases/base_prompt_node/node.py

@@ -69,7 +69,13 @@ class BasePromptNode(BaseNode, Generic[StateType]):
         return outputs
 
     def _handle_api_error(self, e: ApiError):
-        if e.status_code and e.status_code >= 400 and e.status_code < 500 and isinstance(e.body, dict):
+        if e.status_code and e.status_code == 403 and isinstance(e.body, dict):
+            raise NodeException(
+                message=e.body.get("detail", "Provider credentials is missing or unavailable"),
+                code=WorkflowErrorCode.PROVIDER_CREDENTIALS_UNAVAILABLE,
+            )
+
+        elif e.status_code and e.status_code >= 400 and e.status_code < 500 and isinstance(e.body, dict):
             raise NodeException(
                 message=e.body.get("detail", "Failed to execute Prompt"),
                 code=WorkflowErrorCode.INVALID_INPUTS,

vellum/workflows/nodes/displayable/inline_prompt_node/tests/test_node.py

@@ -170,8 +170,13 @@ def test_inline_prompt_node__function_definitions(vellum_adhoc_prompt_client):
             WorkflowErrorCode.INTERNAL_ERROR,
             "Failed to execute Prompt",
         ),
+        (
+            ApiError(status_code=403, body={"detail": "Provider credentials is missing or unavailable"}),
+            WorkflowErrorCode.PROVIDER_CREDENTIALS_UNAVAILABLE,
+            "Provider credentials is missing or unavailable",
+        ),
     ],
-    ids=["404", "invalid_dict", "invalid_body", "no_status_code", "500"],
+    ids=["404", "invalid_dict", "invalid_body", "no_status_code", "500", "403"],
 )
 def test_inline_prompt_node__api_error__invalid_inputs_node_exception(
     vellum_adhoc_prompt_client, exception, expected_code, expected_message

vellum/workflows/nodes/displayable/prompt_deployment_node/tests/test_node.py

@@ -491,3 +491,29 @@ def test_prompt_deployment_node__no_fallbacks(vellum_client):
 
     # AND the client should have been called only once (for the primary model)
     assert vellum_client.execute_prompt_stream.call_count == 1
+
+
+def test_prompt_deployment_node__provider_credentials_missing(vellum_client):
+    # GIVEN a Prompt Deployment Node
+    class TestPromptDeploymentNode(PromptDeploymentNode):
+        deployment = "test_deployment"
+        prompt_inputs = {}
+
+    # AND the client responds with a 403 error of provider credentials missing
+    primary_error = ApiError(
+        body={"detail": "Provider credentials is missing or unavailable"},
+        status_code=403,
+    )
+
+    vellum_client.execute_prompt_stream.side_effect = primary_error
+
+    # WHEN we run the node
+    node = TestPromptDeploymentNode()
+
+    # THEN the node should raise an exception
+    with pytest.raises(NodeException) as exc_info:
+        list(node.run())
+
+    # AND the exception should contain the original error message
+    assert exc_info.value.message == "Provider credentials is missing or unavailable"
+    assert exc_info.value.code == WorkflowErrorCode.PROVIDER_CREDENTIALS_UNAVAILABLE

vellum/workflows/nodes/experimental/tool_calling_node/__init__.py

@@ -0,0 +1,3 @@
+from vellum.workflows.nodes.experimental.tool_calling_node.node import ToolCallingNode
+
+__all__ = ["ToolCallingNode"]

vellum/workflows/nodes/experimental/tool_calling_node/node.py

@@ -0,0 +1,147 @@
+from collections.abc import Callable
+from typing import Any, ClassVar, Dict, List, Optional, cast
+
+from vellum import ChatMessage, FunctionDefinition, PromptBlock
+from vellum.client.types.chat_message_request import ChatMessageRequest
+from vellum.workflows.context import execution_context, get_parent_context
+from vellum.workflows.errors.types import WorkflowErrorCode
+from vellum.workflows.exceptions import NodeException
+from vellum.workflows.graph.graph import Graph
+from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.nodes.bases import BaseNode
+from vellum.workflows.nodes.experimental.tool_calling_node.utils import (
+    ToolRouterNode,
+    create_function_node,
+    create_tool_router_node,
+)
+from vellum.workflows.outputs.base import BaseOutputs
+from vellum.workflows.state.base import BaseState
+from vellum.workflows.state.context import WorkflowContext
+from vellum.workflows.types.core import EntityInputsInterface
+from vellum.workflows.workflows.base import BaseWorkflow
+
+
+class ToolCallingNode(BaseNode):
+    """
+    A Node that dynamically invokes the provided functions to the underlying Prompt
+
+    Attributes:
+        ml_model: str - The model to use for tool calling (e.g., "gpt-4o-mini")
+        blocks: List[PromptBlock] - The prompt blocks to use (same format as InlinePromptNode)
+        functions: List[FunctionDefinition] - The functions that can be called
+        function_callables: List[Callable] - The callables that can be called
+        prompt_inputs: Optional[EntityInputsInterface] - Mapping of input variable names to values
+    """
+
+    ml_model: ClassVar[str] = "gpt-4o-mini"
+    blocks: ClassVar[List[PromptBlock]] = []
+    functions: ClassVar[List[FunctionDefinition]] = []
+    function_callables: ClassVar[Dict[str, Callable[..., Any]]] = {}
+    prompt_inputs: ClassVar[Optional[EntityInputsInterface]] = None
+    # TODO: https://linear.app/vellum/issue/APO-342/support-tool-call-max-retries
+    max_tool_calls: ClassVar[int] = 1
+
+    class Outputs(BaseOutputs):
+        """
+        The outputs of the ToolCallingNode.
+
+        text: The final text response after tool calling
+        chat_history: The complete chat history including tool calls
+        """
+
+        text: str = ""
+        chat_history: List[ChatMessage] = []
+
+    def run(self) -> Outputs:
+        """
+        Run the tool calling workflow.
+
+        This dynamically builds a graph with router and function nodes,
+        then executes the workflow.
+        """
+        self._validate_functions()
+
+        initial_chat_history = []
+
+        # Extract chat history from prompt inputs if available
+        if self.prompt_inputs and "chat_history" in self.prompt_inputs:
+            chat_history_input = self.prompt_inputs["chat_history"]
+            if isinstance(chat_history_input, list) and all(
+                isinstance(msg, (ChatMessage, ChatMessageRequest)) for msg in chat_history_input
+            ):
+                initial_chat_history = [
+                    msg if isinstance(msg, ChatMessage) else ChatMessage.model_validate(msg.model_dump())
+                    for msg in chat_history_input
+                ]
+
+        self._build_graph()
+
+        with execution_context(parent_context=get_parent_context()):
+
+            class ToolCallingState(BaseState):
+                chat_history: List[ChatMessage] = initial_chat_history
+
+            class ToolCallingWorkflow(BaseWorkflow[BaseInputs, ToolCallingState]):
+                graph = self._graph
+
+                class Outputs(BaseWorkflow.Outputs):
+                    text: str = ToolRouterNode.Outputs.text
+                    chat_history: List[ChatMessage] = ToolCallingState.chat_history
+
+            subworkflow = ToolCallingWorkflow(
+                parent_state=self.state,
+                context=WorkflowContext.create_from(self._context),
+            )
+
+            terminal_event = subworkflow.run()
+
+            if terminal_event.name == "workflow.execution.paused":
+                raise NodeException(
+                    code=WorkflowErrorCode.INVALID_OUTPUTS,
+                    message="Subworkflow unexpectedly paused",
+                )
+            elif terminal_event.name == "workflow.execution.fulfilled":
+                node_outputs = self.Outputs()
+
+                for output_descriptor, output_value in terminal_event.outputs:
+                    setattr(node_outputs, output_descriptor.name, output_value)
+
+                return node_outputs
+            elif terminal_event.name == "workflow.execution.rejected":
+                raise Exception(f"Workflow execution rejected: {terminal_event.error}")
+
+            raise Exception(f"Unexpected workflow event: {terminal_event.name}")
+
+    def _build_graph(self) -> None:
+        self.tool_router_node = create_tool_router_node(
+            ml_model=self.ml_model,
+            blocks=self.blocks,
+            functions=self.functions,
+            prompt_inputs=self.prompt_inputs,
+        )
+
+        self._function_nodes = {
+            function.name: create_function_node(
+                function=function,
+                function_callable=cast(Callable[..., Any], self.function_callables[function.name]),  # type: ignore
+            )
+            for function in self.functions
+        }
+
+        graph_set = set()
+
+        # Add connections from ports of router to function nodes and back to router
+        for function_name, FunctionNodeClass in self._function_nodes.items():
+            router_port = getattr(self.tool_router_node.Ports, function_name)  # type: ignore  # mypy thinks name is still optional # noqa: E501
+            edge_graph = router_port >> FunctionNodeClass >> self.tool_router_node
+            graph_set.add(edge_graph)
+
+        default_port = getattr(self.tool_router_node.Ports, "default")
+        graph_set.add(default_port)
+
+        self._graph = Graph.from_set(graph_set)
+
+    def _validate_functions(self) -> None:
+        for function in self.functions:
+            if function.name is None:
+                raise ValueError("Function name is required")

vellum/workflows/nodes/experimental/tool_calling_node/utils.py

@@ -0,0 +1,132 @@
+from collections.abc import Callable
+import json
+from typing import Any, Iterator, List, Optional, Type, cast
+
+from vellum import ChatMessage, FunctionDefinition, PromptBlock
+from vellum.client.types.function_call_chat_message_content import FunctionCallChatMessageContent
+from vellum.client.types.function_call_chat_message_content_value import FunctionCallChatMessageContentValue
+from vellum.client.types.variable_prompt_block import VariablePromptBlock
+from vellum.workflows.nodes.bases import BaseNode
+from vellum.workflows.nodes.displayable.inline_prompt_node.node import InlinePromptNode
+from vellum.workflows.outputs.base import BaseOutput
+from vellum.workflows.ports.port import Port
+from vellum.workflows.references.lazy import LazyReference
+from vellum.workflows.types.core import EntityInputsInterface
+
+
+class FunctionNode(BaseNode):
+    """Node that executes a specific function."""
+
+    function: FunctionDefinition
+
+
+class ToolRouterNode(InlinePromptNode):
+    def run(self) -> Iterator[BaseOutput]:
+        self.prompt_inputs = {**self.prompt_inputs, "chat_history": self.state.chat_history}  # type: ignore
+        generator = super().run()
+        for output in generator:
+            if output.name == "results" and output.value:
+                values = cast(List[Any], output.value)
+                if values and len(values) > 0:
+                    if values[0].type == "STRING":
+                        self.state.chat_history.append(ChatMessage(role="ASSISTANT", text=values[0].value))
+                    elif values[0].type == "FUNCTION_CALL":
+                        function_call = values[0].value
+                        if function_call is not None:
+                            self.state.chat_history.append(
+                                ChatMessage(
+                                    role="FUNCTION",
+                                    content=FunctionCallChatMessageContent(
+                                        value=FunctionCallChatMessageContentValue(
+                                            name=function_call.name,
+                                            arguments=function_call.arguments,
+                                            id=function_call.id,
+                                        ),
+                                    ),
+                                )
+                            )
+            yield output
+
+
+def create_tool_router_node(
+    ml_model: str,
+    blocks: List[PromptBlock],
+    functions: List[FunctionDefinition],
+    prompt_inputs: Optional[EntityInputsInterface],
+) -> Type[ToolRouterNode]:
+    Ports = type("Ports", (), {})
+    for function in functions:
+        if function.name is None:
+            # We should not raise an error here since we filter out functions without names
+            raise ValueError("Function name is required")
+
+        function_name = function.name
+        port_condition = LazyReference(
+            lambda: (
+                ToolRouterNode.Outputs.results[0]["type"].equals("FUNCTION_CALL")
+                & ToolRouterNode.Outputs.results[0]["value"]["name"].equals(function_name)
+            )
+        )
+        port = Port.on_if(port_condition)
+        setattr(Ports, function_name, port)
+
+    setattr(Ports, "default", Port.on_else())
+
+    # Add a chat history block to blocks
+    blocks.append(
+        VariablePromptBlock(
+            block_type="VARIABLE",
+            input_variable="chat_history",
+            state=None,
+            cache_config=None,
+        )
+    )
+
+    node = type(
+        "ToolRouterNode",
+        (ToolRouterNode,),
+        {
+            "ml_model": ml_model,
+            "blocks": blocks,
+            "functions": functions,
+            "prompt_inputs": prompt_inputs,
+            "Ports": Ports,
+            "__module__": __name__,
+        },
+    )
+
+    return node
+
+
+def create_function_node(function: FunctionDefinition, function_callable: Callable[..., Any]) -> Type[FunctionNode]:
+    """
+    Create a FunctionNode class for a given function.
+
+    This ensures the callable is properly registered and can be called with the expected arguments.
+    """
+
+    # Create a class-level wrapper that calls the original function
+    def execute_function(self) -> BaseNode.Outputs:
+        outputs = self.state.meta.node_outputs.get(ToolRouterNode.Outputs.text)
+        # first parse into json
+        outputs = json.loads(outputs)
+        arguments = outputs["arguments"]
+
+        # Call the original function directly with the arguments
+        result = function_callable(**arguments)
+
+        self.state.chat_history.append(ChatMessage(role="FUNCTION", text=result))
+
+        return self.Outputs()
+
+    node = type(
+        f"FunctionNode_{function.name}",
+        (FunctionNode,),
+        {
+            "function": function,
+            "run": execute_function,
+            "__module__": __name__,
+        },
+    )
+
+    return node

vellum/workflows/nodes/utils.py

@@ -57,10 +57,12 @@ def create_adornment(
         class Subworkflow(BaseWorkflow):
             graph = inner_cls
 
-            # mypy is wrong here, this works and is defined
-            class Outputs(inner_cls.Outputs):  # type: ignore[name-defined]
+            class Outputs(BaseWorkflow.Outputs):
                 pass
 
+        for output_reference in inner_cls.Outputs:
+            setattr(Subworkflow.Outputs, output_reference.name, output_reference)
+
         dynamic_module = f"{inner_cls.__module__}.{inner_cls.__name__}.{ADORNMENT_MODULE_NAME}"
         # This dynamic module allows calls to `type_hints` to work
         sys.modules[dynamic_module] = ModuleType(dynamic_module)

vellum/workflows/outputs/base.py

@@ -147,8 +147,9 @@ class _BaseOutputsMeta(type):
             instance = vars(cls).get(name, undefined)
             if instance is undefined:
                 for base in cls.__mro__[1:]:
-                    if hasattr(base, name):
-                        instance = getattr(base, name)
+                    inherited_output_reference = getattr(base, name, undefined)
+                    if isinstance(inherited_output_reference, OutputReference):
+                        instance = inherited_output_reference.instance
                         break
 
             types = infer_types(cls, name)

vellum/workflows/references/output.py

@@ -1,4 +1,6 @@
+from functools import cached_property
 from queue import Queue
+from uuid import UUID, uuid4
 from typing import TYPE_CHECKING, Any, Generator, Generic, Optional, Tuple, Type, TypeVar, cast
 
 from pydantic import GetCoreSchemaHandler
@@ -31,6 +33,24 @@ class OutputReference(BaseDescriptor[_OutputType], Generic[_OutputType]):
     def outputs_class(self) -> Type["BaseOutputs"]:
         return self._outputs_class
 
+    @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:
+            return uuid4()
+
+        output_ids = getattr(node_class, "__output_ids__", {})
+        if not isinstance(output_ids, dict):
+            return uuid4()
+
+        output_id = output_ids.get(self.name)
+        if not isinstance(output_id, UUID):
+            return uuid4()
+
+        return output_id
+
     def resolve(self, state: "BaseState") -> _OutputType:
         node_output = state.meta.node_outputs.get(self, undefined)
         if isinstance(node_output, Queue):