vellum-ai 0.9.16rc2__py3-none-any.whl → 0.10.0__py3-none-any.whl

vellum/workflows/nodes/displayable/prompt_deployment_node/__init__.py

@@ -0,0 +1,5 @@
+from .node import PromptDeploymentNode
+
+__all__ = [
+    "PromptDeploymentNode",
+]

vellum/workflows/nodes/displayable/prompt_deployment_node/node.py

@@ -0,0 +1,45 @@
+from typing import Iterator
+
+from vellum.workflows.errors import VellumErrorCode
+from vellum.workflows.exceptions import NodeException
+from vellum.workflows.nodes.displayable.bases import BasePromptDeploymentNode as BasePromptDeploymentNode
+from vellum.workflows.outputs import BaseOutput
+from vellum.workflows.types.generics import StateType
+
+
+class PromptDeploymentNode(BasePromptDeploymentNode[StateType]):
+    """
+    Used to execute a Prompt Deployment and surface a string output for convenience.
+
+    prompt_inputs: EntityInputsInterface - The inputs for the Prompt
+    deployment: Union[UUID, str] - Either the Prompt Deployment's UUID or its name.
+    release_tag: str - The release tag to use for the Prompt Execution
+    external_id: Optional[str] - The external ID to use for the Prompt Execution
+    expand_meta: Optional[PromptDeploymentExpandMetaRequest] - Expandable execution fields to include in the response
+    raw_overrides: Optional[RawPromptExecutionOverridesRequest] - The raw overrides to use for the Prompt Execution
+    expand_raw: Optional[Sequence[str]] - Expandable raw fields to include in the response
+    metadata: Optional[Dict[str, Optional[Any]]] - The metadata to use for the Prompt Execution
+    request_options: Optional[RequestOptions] - The request options to use for the Prompt Execution
+    """
+
+    class Outputs(BasePromptDeploymentNode.Outputs):
+        text: str
+
+    def run(self) -> Iterator[BaseOutput]:
+        outputs = yield from self._process_prompt_event_stream()
+        if not outputs:
+            raise NodeException(
+                message="Expected to receive outputs from Prompt",
+                code=VellumErrorCode.INTERNAL_ERROR,
+            )
+
+        string_output = next((output for output in outputs if output.type == "STRING"), None)
+        if not string_output or string_output.value is None:
+            output_types = {output.type for output in outputs}
+            is_plural = len(output_types) > 1
+            raise NodeException(
+                message=f"Expected to receive a non-null string output from Prompt. Only found outputs of type{'s' if is_plural else ''}: {', '.join(output_types)}",  # noqa: E501
+                code=VellumErrorCode.INTERNAL_ERROR,
+            )
+
+        yield BaseOutput(name="text", value=string_output.value)

vellum/workflows/nodes/displayable/search_node/__init__.py

@@ -0,0 +1,5 @@
+from .node import SearchNode
+
+__all__ = [
+    "SearchNode",
+]

vellum/workflows/nodes/displayable/search_node/node.py

@@ -0,0 +1,26 @@
+from typing import ClassVar
+
+from vellum.workflows.nodes.displayable.bases import BaseSearchNode as BaseSearchNode
+from vellum.workflows.types.generics import StateType
+
+
+class SearchNode(BaseSearchNode[StateType]):
+    """
+    A SearchNode that outputs the text of the search results concatenated as a single string.
+
+    document_index: Union[UUID, str] - Either the Document Index's UUID or its name.
+    query: str - The query to search for.
+    options: Optional[SearchRequestOptionsRequest] = None - The request options to use for the search
+    request_options: Optional[RequestOptions] = None - The request options to use for the search
+    chunk_separator: str = "\n\n#####\n\n" - Used to separate the text of each search result.
+    """
+
+    chunk_separator: ClassVar[str] = "\n\n#####\n\n"
+
+    class Outputs(BaseSearchNode.Outputs):
+        text: str
+
+    def run(self) -> Outputs:
+        results = self._perform_search().results
+        text = self.chunk_separator.join([r.text for r in results])
+        return self.Outputs(results=results, text=text)

vellum/workflows/nodes/displayable/subworkflow_deployment_node/__init__.py

@@ -0,0 +1,5 @@
+from .node import SubworkflowDeploymentNode
+
+__all__ = [
+    "SubworkflowDeploymentNode",
+]

vellum/workflows/nodes/displayable/subworkflow_deployment_node/node.py

@@ -0,0 +1,156 @@
+from uuid import UUID
+from typing import Any, ClassVar, Dict, Generic, Iterator, List, Optional, Set, Union, cast
+
+from vellum import (
+    ChatMessage,
+    WorkflowExpandMetaRequest,
+    WorkflowOutput,
+    WorkflowRequestChatHistoryInputRequest,
+    WorkflowRequestInputRequest,
+    WorkflowRequestJsonInputRequest,
+    WorkflowRequestNumberInputRequest,
+    WorkflowRequestStringInputRequest,
+)
+from vellum.core import RequestOptions
+
+from vellum.workflows.constants import LATEST_RELEASE_TAG, OMIT
+from vellum.workflows.errors import VellumErrorCode
+from vellum.workflows.exceptions import NodeException
+from vellum.workflows.nodes.bases.base_subworkflow_node.node import BaseSubworkflowNode
+from vellum.workflows.outputs.base import BaseOutput
+from vellum.workflows.types.generics import StateType
+
+
+class SubworkflowDeploymentNode(BaseSubworkflowNode[StateType], Generic[StateType]):
+    """
+    Used to execute a Workflow Deployment.
+
+    subworkflow_inputs: EntityInputsInterface - The inputs for the Subworkflow
+    deployment: Union[UUID, str] - Either the Workflow Deployment's UUID or its name.
+    release_tag: str = LATEST_RELEASE_TAG - The release tag to use for the Workflow Execution
+    external_id: Optional[str] = OMIT - The external ID to use for the Workflow Execution
+    expand_meta: Optional[WorkflowExpandMetaRequest] = OMIT - Expandable execution fields to include in the respownse
+    metadata: Optional[Dict[str, Optional[Any]]] = OMIT - The metadata to use for the Workflow Execution
+    request_options: Optional[RequestOptions] = None - The request options to use for the Workflow Execution
+    """
+
+    # Either the Workflow Deployment's UUID or its name.
+    deployment: ClassVar[Union[UUID, str]]
+
+    release_tag: str = LATEST_RELEASE_TAG
+    external_id: Optional[str] = OMIT
+
+    expand_meta: Optional[WorkflowExpandMetaRequest] = OMIT
+    metadata: Optional[Dict[str, Optional[Any]]] = OMIT
+
+    request_options: Optional[RequestOptions] = None
+
+    def _compile_subworkflow_inputs(self) -> List[WorkflowRequestInputRequest]:
+        # TODO: We may want to consolidate with prompt deployment input compilation
+        # https://app.shortcut.com/vellum/story/4117
+
+        compiled_inputs: List[WorkflowRequestInputRequest] = []
+
+        for input_name, input_value in self.subworkflow_inputs.items():
+            if isinstance(input_value, str):
+                compiled_inputs.append(
+                    WorkflowRequestStringInputRequest(
+                        name=input_name,
+                        value=input_value,
+                    )
+                )
+            elif isinstance(input_value, list) and all(isinstance(message, ChatMessage) for message in input_value):
+                compiled_inputs.append(
+                    WorkflowRequestChatHistoryInputRequest(
+                        name=input_name,
+                        value=cast(List[ChatMessage], input_value),
+                    )
+                )
+            elif isinstance(input_value, dict):
+                compiled_inputs.append(
+                    WorkflowRequestJsonInputRequest(
+                        name=input_name,
+                        value=cast(Dict[str, Any], input_value),
+                    )
+                )
+            elif isinstance(input_value, float):
+                compiled_inputs.append(
+                    WorkflowRequestNumberInputRequest(
+                        name=input_name,
+                        value=input_value,
+                    )
+                )
+            else:
+                raise NodeException(
+                    message=f"Unrecognized input type for input '{input_name}'",
+                    code=VellumErrorCode.INVALID_INPUTS,
+                )
+
+        return compiled_inputs
+
+    def run(self) -> Iterator[BaseOutput]:
+        subworkflow_stream = self._context.vellum_client.execute_workflow_stream(
+            inputs=self._compile_subworkflow_inputs(),
+            workflow_deployment_id=str(self.deployment) if isinstance(self.deployment, UUID) else None,
+            workflow_deployment_name=self.deployment if isinstance(self.deployment, str) else None,
+            release_tag=self.release_tag,
+            external_id=self.external_id,
+            event_types=["WORKFLOW"],
+            metadata=self.metadata,
+            request_options=self.request_options,
+        )
+
+        outputs: Optional[List[WorkflowOutput]] = None
+        fulfilled_output_names: Set[str] = set()
+        for event in subworkflow_stream:
+            if event.type != "WORKFLOW":
+                continue
+            if event.data.state == "INITIATED":
+                continue
+            elif event.data.state == "STREAMING":
+                if event.data.output:
+                    if event.data.output.state == "STREAMING":
+                        yield BaseOutput(
+                            name=event.data.output.name,
+                            delta=event.data.output.delta,
+                        )
+                    elif event.data.output.state == "FULFILLED":
+                        yield BaseOutput(
+                            name=event.data.output.name,
+                            value=event.data.output.value,
+                        )
+                        fulfilled_output_names.add(event.data.output.name)
+            elif event.data.state == "FULFILLED":
+                outputs = event.data.outputs
+            elif event.data.state == "REJECTED":
+                error = event.data.error
+                if not error:
+                    raise NodeException(
+                        message="Expected to receive an error from REJECTED event",
+                        code=VellumErrorCode.INTERNAL_ERROR,
+                    )
+                elif error.code in VellumErrorCode._value2member_map_:
+                    raise NodeException(
+                        message=error.message,
+                        code=VellumErrorCode(error.code),
+                    )
+                else:
+                    raise NodeException(
+                        message=error.message,
+                        code=VellumErrorCode.INTERNAL_ERROR,
+                    )
+
+        if outputs is None:
+            raise NodeException(
+                message="Expected to receive outputs from Workflow Deployment",
+                code=VellumErrorCode.INTERNAL_ERROR,
+            )
+
+        # For any outputs somehow in our final fulfilled outputs array,
+        # but not fulfilled by the stream.
+        for output in outputs:
+            if output.name not in fulfilled_output_names:
+                yield BaseOutput(
+                    name=output.name,
+                    value=output.value,
+                )

vellum/workflows/nodes/displayable/tests/test_inline_text_prompt_node.py

@@ -0,0 +1,148 @@
+from uuid import uuid4
+from typing import Any, Iterator, List
+
+from vellum import (
+    ExecutePromptEvent,
+    FulfilledExecutePromptEvent,
+    InitiatedExecutePromptEvent,
+    PromptOutput,
+    PromptParameters,
+    RejectedExecutePromptEvent,
+    StringVellumValue,
+    VellumError,
+)
+
+from vellum.workflows.constants import UNDEF
+from vellum.workflows.errors import VellumError as WacVellumError
+from vellum.workflows.errors.types import VellumErrorCode
+from vellum.workflows.inputs import BaseInputs
+from vellum.workflows.nodes import InlinePromptNode
+from vellum.workflows.nodes.core.try_node.node import TryNode
+from vellum.workflows.state import BaseState
+from vellum.workflows.state.base import StateMeta
+
+
+def test_inline_text_prompt_node__basic(vellum_adhoc_prompt_client):
+    """Confirm that InlineTextPromptNodes output the expected text and results when run."""
+
+    # GIVEN a node that subclasses InlineTextPromptNode
+    class Inputs(BaseInputs):
+        input: str
+
+    class State(BaseState):
+        pass
+
+    class MyInlinePromptNode(InlinePromptNode):
+        ml_model = "gpt-4o"
+        prompt_inputs = {}
+        blocks = []
+
+    # AND a known response from invoking an inline prompt
+    expected_outputs: List[PromptOutput] = [
+        StringVellumValue(value="Hello, world!"),
+    ]
+
+    def generate_prompt_events(*args: Any, **kwargs: Any) -> Iterator[ExecutePromptEvent]:
+        execution_id = str(uuid4())
+        events: List[ExecutePromptEvent] = [
+            InitiatedExecutePromptEvent(execution_id=execution_id),
+            FulfilledExecutePromptEvent(
+                execution_id=execution_id,
+                outputs=expected_outputs,
+            ),
+        ]
+        yield from events
+
+    vellum_adhoc_prompt_client.adhoc_execute_prompt_stream.side_effect = generate_prompt_events
+
+    # WHEN the node is run
+    node = MyInlinePromptNode(
+        state=State(
+            meta=StateMeta(workflow_inputs=Inputs(input="Say something.")),
+        )
+    )
+    outputs = [o for o in node.run()]
+
+    # THEN the node should have produced the outputs we expect
+    results_output = outputs[0]
+    assert results_output.name == "results"
+    assert results_output.value == expected_outputs
+
+    text_output = outputs[1]
+    assert text_output.name == "text"
+    assert text_output.value == "Hello, world!"
+
+    # AND we should have made the expected call to Vellum search
+    vellum_adhoc_prompt_client.adhoc_execute_prompt_stream.assert_called_once_with(
+        blocks=[],
+        expand_meta=Ellipsis,
+        functions=Ellipsis,
+        input_values=[],
+        input_variables=[],
+        ml_model="gpt-4o",
+        parameters=PromptParameters(
+            stop=[],
+            temperature=0.0,
+            max_tokens=4096,
+            top_p=1.0,
+            top_k=0,
+            frequency_penalty=0.0,
+            presence_penalty=0.0,
+            logit_bias=None,
+            custom_parameters=None,
+        ),
+        request_options=None,
+    )
+
+
+def test_inline_text_prompt_node__catch_provider_error(vellum_adhoc_prompt_client):
+    """Confirm that InlineTextPromptNodes output the caught error upon Provider Error."""
+
+    # GIVEN a node that subclasses InlineTextPromptNode
+    class Inputs(BaseInputs):
+        input: str
+
+    class State(BaseState):
+        pass
+
+    @TryNode.wrap(on_error_code=VellumErrorCode.PROVIDER_ERROR)
+    class MyInlinePromptNode(InlinePromptNode):
+        ml_model = "gpt-4o"
+        prompt_inputs = {}
+        blocks = []
+
+    # AND a known response from invoking an inline prompt that fails
+    expected_error = VellumError(
+        message="OpenAI failed",
+        code="PROVIDER_ERROR",
+    )
+
+    def generate_prompt_events(*args: Any, **kwargs: Any) -> Iterator[ExecutePromptEvent]:
+        execution_id = str(uuid4())
+        events: List[ExecutePromptEvent] = [
+            InitiatedExecutePromptEvent(execution_id=execution_id),
+            RejectedExecutePromptEvent(
+                execution_id=execution_id,
+                error=expected_error,
+            ),
+        ]
+        yield from events
+
+    vellum_adhoc_prompt_client.adhoc_execute_prompt_stream.side_effect = generate_prompt_events
+
+    # WHEN the node is run
+    node = MyInlinePromptNode(
+        state=State(
+            meta=StateMeta(workflow_inputs=Inputs(input="Say something.")),
+        )
+    )
+    outputs = node.run()
+
+    # THEN the node should have produced the outputs we expect
+    # We need mypy support for annotations to remove these type ignores
+    # https://app.shortcut.com/vellum/story/4890
+    assert outputs.error == WacVellumError(  # type: ignore[attr-defined]
+        message="OpenAI failed",
+        code=VellumErrorCode.PROVIDER_ERROR,
+    )
+    assert outputs.text is UNDEF  # type: ignore[attr-defined]

vellum/workflows/nodes/displayable/tests/test_search_node_wth_text_output.py

@@ -0,0 +1,134 @@
+# flake8: noqa: E731, E501
+
+import pytest
+
+from vellum import (
+    SearchFiltersRequest,
+    SearchRequestOptionsRequest,
+    SearchResponse,
+    SearchResult,
+    SearchResultDocument,
+    SearchResultMergingRequest,
+    SearchWeightsRequest,
+)
+
+from vellum.workflows.inputs import BaseInputs
+from vellum.workflows.nodes.displayable.search_node import SearchNode as BaseSearchNode
+from vellum.workflows.state import BaseState
+from vellum.workflows.state.base import StateMeta
+
+
+@pytest.fixture
+def vellum_search_client(vellum_client):
+    return vellum_client.search
+
+
+def test_search_node_wth_text_output(vellum_search_client):
+    """Confirm that SearchNodes output the expected text and results when run."""
+
+    # GIVEN a node that subclasses SearchNode
+    class Inputs(BaseInputs):
+        query: str
+        document_index: str
+
+    class State(BaseState):
+        pass
+
+    class SearchNode(BaseSearchNode):
+        query = Inputs.query
+        document_index = Inputs.document_index
+
+    # AND a mock Vellum search client that returns the expected results
+    expected_results = [
+        SearchResult(
+            text="A request that is made by a consumer, by a consumer on behalf of the consumer's minor child, \nor by a natural person or a person registered with the Secretary of State, authorized by the \nconsumer to act on the consumer's behalf, and that the business can reasonably verify, pursuant \nto regulations adopted by the Attorney General pursuant to paragraph (7) of subdivision (a) of \nSection 1798.185 to be the consumer about whom the business has collected personal \ninformation. \nA business is not obligated to provide information to the consumer pursuant to \nSections 1798.110 and 1798.115 if the business cannot verify, pursuant this subdivision and \nregulations adopted by the Attorney General pursuant to paragraph (7) of subdivision (a) of \nSection 1798.185, that the consumer making the request is the consumer about whom the \nbusiness has collected information or is a person authorized by the consumer to act on such \nconsumer's behalf.",  # noqa: E501
+            score=0.8,
+            keywords=["Data Classification Policy - v1.pdf"],
+            document=SearchResultDocument(
+                id="e6d375ed-96fd-4d24-9f89-b4d5d10bca6b",
+                label="Data Classification Policy - v1.pdf",
+                external_id="Data Classification Policy - v1.pdf",
+                metadata={},
+            ),
+            meta=None,
+        ),
+        SearchResult(
+            text="To a Law Enforcement Official for Law Enforcement Purposes, under the following conditions: \nO \nPursuant to a process and as otherwise required by law, but only if the information sought is relevant \nand material, the request is specific and limited to amounts reasonably necessary, and it is not \npossible to use de-identified information. \nO \nAn order of a court or administrative tribunal (disclosure must be limited to PHI expressly \nauthorized by the order); and \nA subpoena, discovery request or other lawful process, not accompanied by a court order or \nadministrative tribunal, upon receipt of assurances that the individual has been given notice of the \nrequest, or that the party seeking the information has made reasonable efforts to receive a qualified \nprotective order. Information requested is limited information to identify or locate a suspect, fugitive, material\nwitness or missing person.",  # noqa: E501
+            score=0.6347101,
+            keywords=["Privacy, Use, and Disclosure Policy - v1.pdf"],
+            document=SearchResultDocument(
+                id="bd3da448-d94a-4cef-be54-48ffeb019b14",
+                label="Privacy, Use, and Disclosure Policy - v1.pdf",
+                external_id="Privacy, Use, and Disclosure Policy - v1.pdf",
+                metadata={},
+            ),
+            meta=None,
+        ),
+    ]
+    vellum_search_client.return_value = SearchResponse(results=expected_results)
+
+    # WHEN the node is run
+    node = SearchNode(
+        state=State(
+            meta=StateMeta(
+                workflow_inputs=Inputs(
+                    query="How often is employee training?",
+                    document_index="vellum-trust-center-policies",
+                )
+            ),
+        )
+    )
+    outputs = node.run()
+
+    # THEN the node should have produced the outputs we expect
+    assert (
+        outputs.text
+        == """\
+A request that is made by a consumer, by a consumer on behalf of the consumer's minor child, 
+or by a natural person or a person registered with the Secretary of State, authorized by the 
+consumer to act on the consumer's behalf, and that the business can reasonably verify, pursuant 
+to regulations adopted by the Attorney General pursuant to paragraph (7) of subdivision (a) of 
+Section 1798.185 to be the consumer about whom the business has collected personal 
+information. 
+A business is not obligated to provide information to the consumer pursuant to 
+Sections 1798.110 and 1798.115 if the business cannot verify, pursuant this subdivision and 
+regulations adopted by the Attorney General pursuant to paragraph (7) of subdivision (a) of 
+Section 1798.185, that the consumer making the request is the consumer about whom the 
+business has collected information or is a person authorized by the consumer to act on such 
+consumer's behalf.
+
+#####
+
+To a Law Enforcement Official for Law Enforcement Purposes, under the following conditions: 
+O 
+Pursuant to a process and as otherwise required by law, but only if the information sought is relevant 
+and material, the request is specific and limited to amounts reasonably necessary, and it is not 
+possible to use de-identified information. 
+O 
+An order of a court or administrative tribunal (disclosure must be limited to PHI expressly 
+authorized by the order); and 
+A subpoena, discovery request or other lawful process, not accompanied by a court order or 
+administrative tribunal, upon receipt of assurances that the individual has been given notice of the 
+request, or that the party seeking the information has made reasonable efforts to receive a qualified 
+protective order. Information requested is limited information to identify or locate a suspect, fugitive, material
+witness or missing person.\
+"""
+    )
+
+    assert outputs.results == expected_results
+
+    # AND we should have made the expected call to Vellum search
+    vellum_search_client.assert_called_once_with(
+        index_id=None,
+        index_name="vellum-trust-center-policies",
+        query="How often is employee training?",
+        options=SearchRequestOptionsRequest(
+            limit=8,
+            weights=SearchWeightsRequest(semantic_similarity=0.8, keywords=0.2),
+            result_merging=SearchResultMergingRequest(enabled=True),
+            filters=SearchFiltersRequest(
+                external_ids=None,
+                metadata=None,
+            ),
+        ),
+    )

vellum/workflows/nodes/displayable/tests/test_text_prompt_deployment_node.py

@@ -0,0 +1,80 @@
+from uuid import uuid4
+from typing import Any, Iterator, List
+
+from vellum import (
+    ExecutePromptEvent,
+    FulfilledExecutePromptEvent,
+    InitiatedExecutePromptEvent,
+    PromptOutput,
+    StringVellumValue,
+)
+
+from vellum.workflows.constants import OMIT
+from vellum.workflows.inputs import BaseInputs
+from vellum.workflows.nodes import PromptDeploymentNode
+from vellum.workflows.state import BaseState
+from vellum.workflows.state.base import StateMeta
+
+
+def test_text_prompt_deployment_node__basic(vellum_client):
+    """Confirm that TextPromptDeploymentNodes output the expected text and results when run."""
+
+    # GIVEN a node that subclasses TextPromptDeploymentNode
+    class Inputs(BaseInputs):
+        input: str
+
+    class State(BaseState):
+        pass
+
+    class MyPromptDeploymentNode(PromptDeploymentNode):
+        deployment = "my-deployment"
+        prompt_inputs = {}
+
+    # AND a known response from invoking a deployed prompt
+    expected_outputs: List[PromptOutput] = [
+        StringVellumValue(value="Hello, world!"),
+    ]
+
+    def generate_prompt_events(*args: Any, **kwargs: Any) -> Iterator[ExecutePromptEvent]:
+        execution_id = str(uuid4())
+        events: List[ExecutePromptEvent] = [
+            InitiatedExecutePromptEvent(execution_id=execution_id),
+            FulfilledExecutePromptEvent(
+                execution_id=execution_id,
+                outputs=expected_outputs,
+            ),
+        ]
+        yield from events
+
+    vellum_client.execute_prompt_stream.side_effect = generate_prompt_events
+
+    # WHEN the node is run
+    node = MyPromptDeploymentNode(
+        state=State(
+            meta=StateMeta(workflow_inputs=Inputs(input="Say something.")),
+        )
+    )
+    outputs = [o for o in node.run()]
+
+    # THEN the node should have produced the outputs we expect
+    results_output = outputs[0]
+    assert results_output.name == "results"
+    assert results_output.value == expected_outputs
+
+    text_output = outputs[1]
+    assert text_output.name == "text"
+    assert text_output.value == "Hello, world!"
+
+    # AND we should have made the expected call to Vellum search
+    vellum_client.execute_prompt_stream.assert_called_once_with(
+        expand_meta=OMIT,
+        expand_raw=OMIT,
+        external_id=OMIT,
+        inputs=[],
+        metadata=OMIT,
+        prompt_deployment_id=None,
+        prompt_deployment_name="my-deployment",
+        raw_overrides=OMIT,
+        release_tag="LATEST",
+        request_options=None,
+    )

vellum/workflows/nodes/utils.py

@@ -0,0 +1,27 @@
+from functools import cache
+from typing import Type
+
+from vellum.workflows.nodes import BaseNode
+from vellum.workflows.references import NodeReference
+from vellum.workflows.types.generics import NodeType
+
+
+@cache
+def get_wrapped_node(node: Type[NodeType]) -> Type[BaseNode]:
+    if hasattr(node, "subworkflow"):
+        subworkflow = node.subworkflow
+        if isinstance(subworkflow, NodeReference) and subworkflow.instance:
+            graph = subworkflow.instance.graph
+            if issubclass(graph, BaseNode):
+                return graph
+
+    raise TypeError("Wrapped subworkflow contains more than one node")
+
+
+def has_wrapped_node(node: Type[NodeType]) -> bool:
+    try:
+        get_wrapped_node(node)
+    except TypeError:
+        return False
+
+    return True

vellum/workflows/outputs/__init__.py

@@ -0,0 +1,6 @@
+from .base import BaseOutput, BaseOutputs
+
+__all__ = [
+    "BaseOutput",
+    "BaseOutputs",
+]