vellum-ai 1.8.2__py3-none-any.whl → 1.8.4__py3-none-any.whl

vellum/__init__.py

@@ -612,6 +612,7 @@ from .client.types import (
     VideoPromptBlock,
     VideoVellumValue,
     VideoVellumValueRequest,
+    WorkflowDeploymentDisplayData,
     WorkflowDeploymentEventExecutionsResponse,
     WorkflowDeploymentHistoryItem,
     WorkflowDeploymentParentContext,
@@ -619,6 +620,7 @@ from .client.types import (
     WorkflowDeploymentRelease,
     WorkflowDeploymentReleaseWorkflowDeployment,
     WorkflowDeploymentReleaseWorkflowVersion,
+    WorkflowDisplayIcon,
     WorkflowError,
     WorkflowEvent,
     WorkflowEventError,
@@ -1368,6 +1370,7 @@ __all__ = [
     "VideoPromptBlock",
     "VideoVellumValue",
     "VideoVellumValueRequest",
+    "WorkflowDeploymentDisplayData",
     "WorkflowDeploymentEventExecutionsResponse",
     "WorkflowDeploymentHistoryItem",
     "WorkflowDeploymentParentContext",
@@ -1376,6 +1379,7 @@ __all__ = [
     "WorkflowDeploymentReleaseWorkflowDeployment",
     "WorkflowDeploymentReleaseWorkflowVersion",
     "WorkflowDeploymentsListRequestStatus",
+    "WorkflowDisplayIcon",
     "WorkflowError",
     "WorkflowEvent",
     "WorkflowEventError",

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.8.2",
+            "User-Agent": "vellum-ai/1.8.4",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "1.8.2",
+            "X-Fern-SDK-Version": "1.8.4",
             **(self.get_custom_headers() or {}),
         }
         if self._api_version is not None:

vellum/client/types/__init__.py

@@ -636,6 +636,7 @@ from .video_input_request import VideoInputRequest
 from .video_prompt_block import VideoPromptBlock
 from .video_vellum_value import VideoVellumValue
 from .video_vellum_value_request import VideoVellumValueRequest
+from .workflow_deployment_display_data import WorkflowDeploymentDisplayData
 from .workflow_deployment_event_executions_response import WorkflowDeploymentEventExecutionsResponse
 from .workflow_deployment_history_item import WorkflowDeploymentHistoryItem
 from .workflow_deployment_parent_context import WorkflowDeploymentParentContext
@@ -643,6 +644,7 @@ from .workflow_deployment_read import WorkflowDeploymentRead
 from .workflow_deployment_release import WorkflowDeploymentRelease
 from .workflow_deployment_release_workflow_deployment import WorkflowDeploymentReleaseWorkflowDeployment
 from .workflow_deployment_release_workflow_version import WorkflowDeploymentReleaseWorkflowVersion
+from .workflow_display_icon import WorkflowDisplayIcon
 from .workflow_error import WorkflowError
 from .workflow_event import WorkflowEvent
 from .workflow_event_error import WorkflowEventError
@@ -1332,6 +1334,7 @@ __all__ = [
     "VideoPromptBlock",
     "VideoVellumValue",
     "VideoVellumValueRequest",
+    "WorkflowDeploymentDisplayData",
     "WorkflowDeploymentEventExecutionsResponse",
     "WorkflowDeploymentHistoryItem",
     "WorkflowDeploymentParentContext",
@@ -1339,6 +1342,7 @@ __all__ = [
     "WorkflowDeploymentRelease",
     "WorkflowDeploymentReleaseWorkflowDeployment",
     "WorkflowDeploymentReleaseWorkflowVersion",
+    "WorkflowDisplayIcon",
     "WorkflowError",
     "WorkflowEvent",
     "WorkflowEventError",

vellum/client/types/integration_name.py

@@ -41,6 +41,7 @@ IntegrationName = typing.Union[
         "JIRA",
         "KLAVIYO",
         "PAGERDUTY",
+        "PARSERA",
         "PEOPLEDATALABS",
         "PERPLEXITY",
         "POSTHOG",

vellum/client/types/workflow_deployment_display_data.py

@@ -0,0 +1,27 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+from .workflow_display_icon import WorkflowDisplayIcon
+
+
+class WorkflowDeploymentDisplayData(UniversalBaseModel):
+    """
+    Workflow Deployment display data
+    """
+
+    icon: typing.Optional[WorkflowDisplayIcon] = pydantic.Field(default=None)
+    """
+    The icon associated with this Workflow Deployment.
+    """
+
+    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/workflow_deployment_read.py

@@ -10,6 +10,7 @@ from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel, update
 from .entity_status import EntityStatus
 from .environment_enum import EnvironmentEnum
 from .vellum_variable import VellumVariable
+from .workflow_deployment_display_data import WorkflowDeploymentDisplayData
 
 
 class WorkflowDeploymentRead(UniversalBaseModel):
@@ -63,6 +64,11 @@ class WorkflowDeploymentRead(UniversalBaseModel):
     A human-readable description of the workflow deployment
     """
 
+    display_data: typing.Optional[WorkflowDeploymentDisplayData] = pydantic.Field(default=None)
+    """
+    Information used to display this Workflow Deployment.
+    """
+
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
     else:

vellum/client/types/workflow_display_icon.py

@@ -0,0 +1,24 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+
+
+class WorkflowDisplayIcon(UniversalBaseModel):
+    """
+    Icon to be used alongside a Workflow
+    """
+
+    src: typing.Optional[str] = None
+    color: typing.Optional[str] = None
+
+    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/types/workflow_deployment_display_data.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.workflow_deployment_display_data import *

vellum/types/workflow_display_icon.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.workflow_display_icon import *

vellum/workflows/events/types.py

@@ -85,6 +85,14 @@ class ExternalParentContext(BaseParentContext):
     type: Literal["EXTERNAL"] = "EXTERNAL"
 
 
+class WorkflowDeploymentScheduledTriggerContext(BaseParentContext):
+    type: Literal["SCHEDULED"] = "SCHEDULED"
+
+
+class WorkflowDeploymentIntegrationTriggerContext(BaseParentContext):
+    type: Literal["INTEGRATION"] = "INTEGRATION"
+
+
 class SpanLink(UniversalBaseModel):
     trace_id: str
     type: Literal["TRIGGERED_BY", "PREVIOUS_SPAN", "ROOT_SPAN"]

vellum/workflows/expressions/concat.py

@@ -26,7 +26,10 @@ class ConcatExpression(BaseDescriptor[list], Generic[LHS, RHS]):
 
         if not isinstance(lval, list):
             raise InvalidExpressionException(f"Expected LHS to be a list, got {type(lval)}")
-        if not isinstance(rval, list):
-            raise InvalidExpressionException(f"Expected RHS to be a list, got {type(rval)}")
 
-        return lval + rval
+        # If RHS is a list, concatenate normally
+        if isinstance(rval, list):
+            return lval + rval
+        # If RHS is not a list, append it as a single item
+        else:
+            return lval + [rval]

vellum/workflows/expressions/tests/test_concat.py

@@ -38,16 +38,71 @@ def test_concat_expression_lhs_fail():
     assert "Expected LHS to be a list, got <class 'int'>" in str(exc_info.value)
 
 
-def test_concat_expression_rhs_fail():
-    # GIVEN a list lhs and a non-list rhs
+def test_concat_expression_with_single_item():
+    # GIVEN a list and a single item
     state = TestState()
     lhs_ref = ConstantValueReference([1, 2, 3])
-    rhs_ref = ConstantValueReference(False)
+    rhs_ref = ConstantValueReference(4)
     concat_expr = lhs_ref.concat(rhs_ref)
 
-    # WHEN we attempt to resolve the expression
-    with pytest.raises(InvalidExpressionException) as exc_info:
-        concat_expr.resolve(state)
+    # WHEN we resolve the expression
+    result = concat_expr.resolve(state)
 
-    # THEN an exception should be raised
-    assert "Expected RHS to be a list, got <class 'bool'>" in str(exc_info.value)
+    # THEN the item should be appended to the list
+    assert result == [1, 2, 3, 4]
+
+
+def test_concat_expression_with_string():
+    # GIVEN a list and a string item
+    state = TestState()
+    lhs_ref = ConstantValueReference(["hello", "world"])
+    rhs_ref = ConstantValueReference("!")
+    concat_expr = lhs_ref.concat(rhs_ref)
+
+    # WHEN we resolve the expression
+    result = concat_expr.resolve(state)
+
+    # THEN the string should be appended to the list
+    assert result == ["hello", "world", "!"]
+
+
+def test_concat_expression_with_none():
+    # GIVEN a list and None item
+    state = TestState()
+    lhs_ref = ConstantValueReference([1, 2])
+    rhs_ref = ConstantValueReference(None)
+    concat_expr = lhs_ref.concat(rhs_ref)
+
+    # WHEN we resolve the expression
+    result = concat_expr.resolve(state)
+
+    # THEN None should be appended to the list
+    assert result == [1, 2, None]
+
+
+def test_concat_expression_with_list_item():
+    # GIVEN a list and another list
+    state = TestState()
+    lhs_ref = ConstantValueReference([1, 2])
+    rhs_ref = ConstantValueReference([3, 4])
+    concat_expr = lhs_ref.concat(rhs_ref)
+
+    # WHEN we resolve the expression
+    result = concat_expr.resolve(state)
+
+    # THEN the lists should be concatenated normally
+    assert result == [1, 2, 3, 4]
+
+
+def test_concat_expression_empty_list():
+    # GIVEN an empty list and an item
+    state = TestState()
+    lhs_ref: ConstantValueReference[list] = ConstantValueReference([])
+    rhs_ref = ConstantValueReference("first")
+    concat_expr = lhs_ref.concat(rhs_ref)
+
+    # WHEN we resolve the expression
+    result = concat_expr.resolve(state)
+
+    # THEN the item should be appended to the empty list
+    assert result == ["first"]

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

@@ -99,6 +99,7 @@ class MapNode(BaseAdornmentNode[StateType], Generic[StateType, MapNodeItemType])
                     map_node_event = self._event_queue.get(block=False)
                     index = map_node_event[0]
                     subworkflow_event = map_node_event[1]
+
                     self._context._emit_subworkflow_event(subworkflow_event)
 
                     if not is_workflow_event(subworkflow_event):

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

@@ -1,5 +1,6 @@
 from abc import abstractmethod
-from typing import ClassVar, Generator, Generic, Iterator, List, Optional, Union
+from itertools import chain
+from typing import ClassVar, Generator, Generic, Iterator, List, Optional, Union, cast
 
 from vellum import AdHocExecutePromptEvent, ExecutePromptEvent, PromptOutput
 from vellum.client.core import RequestOptions
@@ -60,15 +61,26 @@ class BasePromptNode(BaseNode[StateType], Generic[StateType]):
         except ApiError as e:
             self._handle_api_error(e)
 
-        # We don't use the INITIATED event anyway, so we can just skip it
-        # and use the exception handling to catch other api level errors
         try:
-            next(prompt_event_stream)
+            first_event = next(prompt_event_stream)
         except ApiError as e:
             self._handle_api_error(e)
+        else:
+            if first_event.state == "REJECTED":
+                workflow_error = vellum_error_to_workflow_error(first_event.error)
+                raise NodeException.of(workflow_error)
+            if first_event.state != "INITIATED":
+                prompt_event_stream = cast(
+                    Union[Iterator[AdHocExecutePromptEvent], Iterator[ExecutePromptEvent]],
+                    chain([first_event], prompt_event_stream),
+                )
 
         outputs: Optional[List[PromptOutput]] = None
+        exception: Optional[NodeException] = None
         for event in prompt_event_stream:
+            if exception:
+                continue
+
             if event.state == "INITIATED":
                 continue
             elif event.state == "STREAMING":
@@ -78,7 +90,10 @@ class BasePromptNode(BaseNode[StateType], Generic[StateType]):
                 yield BaseOutput(name="results", value=event.outputs)
             elif event.state == "REJECTED":
                 workflow_error = vellum_error_to_workflow_error(event.error)
-                raise NodeException.of(workflow_error)
+                exception = NodeException.of(workflow_error)
+
+        if exception:
+            raise exception
 
         return outputs
 

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

@@ -1,3 +1,4 @@
+from itertools import chain
 import json
 from uuid import uuid4
 from typing import Callable, ClassVar, Generator, Generic, Iterator, List, Optional, Set, Tuple, Union
@@ -225,13 +226,16 @@ class BaseInlinePromptNode(BasePromptNode[StateType], Generic[StateType]):
         except ApiError as e:
             self._handle_api_error(e)
 
-        if not self.settings or (self.settings and self.settings.stream_enabled):
-            # We don't use the INITIATED event anyway, so we can just skip it
-            # and use the exception handling to catch other api level errors
-            try:
-                next(prompt_event_stream)
-            except ApiError as e:
-                self._handle_api_error(e)
+        try:
+            first_event = next(prompt_event_stream)
+        except ApiError as e:
+            self._handle_api_error(e)
+        else:
+            if first_event.state == "REJECTED":
+                workflow_error = vellum_error_to_workflow_error(first_event.error)
+                raise NodeException.of(workflow_error)
+            if first_event.state != "INITIATED":
+                prompt_event_stream = chain([first_event], prompt_event_stream)
 
         outputs: Optional[List[PromptOutput]] = None
         for event in prompt_event_stream:

vellum/workflows/nodes/displayable/bases/inline_prompt_node/tests/test_inline_prompt_node.py

@@ -25,6 +25,7 @@ from vellum import (
     PromptRequestStringInput,
     PromptRequestVideoInput,
     PromptSettings,
+    RejectedExecutePromptEvent,
     RichTextPromptBlock,
     StringVellumValue,
     VariablePromptBlock,
@@ -32,6 +33,7 @@ from vellum import (
     VellumAudioRequest,
     VellumDocument,
     VellumDocumentRequest,
+    VellumError,
     VellumImage,
     VellumImageRequest,
     VellumVideo,
@@ -896,3 +898,43 @@ def test_inline_prompt_node__json_output_with_markdown_code_blocks(vellum_adhoc_
     json_output = outputs[2]
     assert json_output.name == "json"
     assert json_output.value == expected_json
+
+
+def test_inline_prompt_node__provider_error_from_api(vellum_adhoc_prompt_client):
+    """
+    Tests that InlinePromptNode raises NodeException with PROVIDER_ERROR code when first event is REJECTED.
+    """
+
+    # GIVEN an InlinePromptNode with basic configuration
+    class TestNode(InlinePromptNode):
+        ml_model = "test-model"
+        blocks = []
+        prompt_inputs = {}
+
+    # AND the API returns a REJECTED event as the first event with a provider error
+    provider_error = VellumError(
+        code="PROVIDER_ERROR",
+        message="Provider rate limit exceeded",
+    )
+
+    def generate_prompt_events(*args: Any, **kwargs: Any) -> Iterator[ExecutePromptEvent]:
+        execution_id = str(uuid4())
+        events: List[ExecutePromptEvent] = [
+            RejectedExecutePromptEvent(
+                execution_id=execution_id,
+                error=provider_error,
+            ),
+        ]
+        yield from events
+
+    vellum_adhoc_prompt_client.adhoc_execute_prompt_stream.side_effect = generate_prompt_events
+
+    # WHEN the node is run
+    node = TestNode()
+
+    # THEN it should raise a NodeException with PROVIDER_ERROR error code
+    with pytest.raises(NodeException) as excinfo:
+        list(node.run())
+
+    # AND the exception should have the correct error code
+    assert excinfo.value.code == WorkflowErrorCode.PROVIDER_ERROR

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

@@ -1,6 +1,6 @@
 import json
-from uuid import UUID
-from typing import TYPE_CHECKING, Any, ClassVar, Dict, Generic, Iterator, List, Optional, Set, Union, cast
+from uuid import UUID, uuid4
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, Generic, Iterator, List, Optional, Set, Type, Union, cast
 
 from vellum import (
     ChatMessage,
@@ -19,12 +19,13 @@ from vellum.workflows.constants import LATEST_RELEASE_TAG, OMIT, undefined
 from vellum.workflows.context import execution_context, get_execution_context, get_parent_context
 from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.errors.types import workflow_event_error_to_workflow_error
-from vellum.workflows.events.types import default_serializer
+from vellum.workflows.events.types import WorkflowDeploymentParentContext, default_serializer
 from vellum.workflows.events.workflow import is_workflow_event
 from vellum.workflows.exceptions import NodeException, WorkflowInitializationException
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.outputs.base import BaseOutput
+from vellum.workflows.state.context import WorkflowContext, WorkflowDeploymentMetadata
 from vellum.workflows.types.core import EntityInputsInterface, MergeBehavior
 from vellum.workflows.types.generics import StateType
 from vellum.workflows.workflows.event_filters import all_workflow_event_filter
@@ -155,69 +156,95 @@ class SubworkflowDeploymentNode(BaseNode[StateType], Generic[StateType]):
             filtered_inputs = {k: v for k, v in self.subworkflow_inputs.items() if v is not None}
             return inputs_class(**filtered_inputs)
 
-    def _run_resolved_workflow(self, resolved_workflow: "BaseWorkflow") -> Iterator[BaseOutput]:
+    def _run_resolved_workflow(
+        self,
+        workflow_class: Type["BaseWorkflow"],
+        deployment_metadata: Optional[WorkflowDeploymentMetadata],
+    ) -> Iterator[BaseOutput]:
         """Execute resolved workflow directly (similar to InlineSubworkflowNode)."""
-        with execution_context(parent_context=get_parent_context()):
+        # Construct the parent context hierarchy for the subworkflow
+        parent_context = get_parent_context()
+
+        # If we have deployment metadata, wrap the parent context with WorkflowDeploymentParentContext
+        if deployment_metadata:
+            parent_context = WorkflowDeploymentParentContext(
+                span_id=uuid4(),
+                deployment_id=deployment_metadata.deployment_id,
+                deployment_name=deployment_metadata.deployment_name,
+                deployment_history_item_id=deployment_metadata.deployment_history_item_id,
+                release_tag_id=deployment_metadata.release_tag_id,
+                release_tag_name=deployment_metadata.release_tag_name,
+                workflow_version_id=deployment_metadata.workflow_version_id,
+                external_id=self.external_id if self.external_id is not OMIT else None,
+                metadata=self.metadata if self.metadata is not OMIT else None,
+                parent=parent_context,
+            )
+
+        with execution_context(parent_context=parent_context):
+            # Instantiate the workflow inside the execution context so it captures the correct parent context
+            resolved_workflow = workflow_class(
+                context=WorkflowContext.create_from(self._context), parent_state=self.state
+            )
             subworkflow_stream = resolved_workflow.stream(
                 inputs=self._compile_subworkflow_inputs_for_direct_invocation(resolved_workflow),
                 event_filter=all_workflow_event_filter,
                 node_output_mocks=self._context._get_all_node_output_mocks(),
             )
 
-        try:
-            first_event = next(subworkflow_stream)
-            self._context._emit_subworkflow_event(first_event)
-        except WorkflowInitializationException as e:
-            hashed_module = e.definition.__module__
-            raise NodeException(
-                message=e.message,
-                code=e.code,
-                raw_data={"hashed_module": hashed_module},
-            ) from e
-
-        outputs = None
-        exception = None
-        fulfilled_output_names: Set[str] = set()
+            try:
+                first_event = next(subworkflow_stream)
+                self._context._emit_subworkflow_event(first_event)
+            except WorkflowInitializationException as e:
+                hashed_module = e.definition.__module__
+                raise NodeException(
+                    message=e.message,
+                    code=e.code,
+                    raw_data={"hashed_module": hashed_module},
+                ) from e
+
+            outputs = None
+            exception = None
+            fulfilled_output_names: Set[str] = set()
+
+            for event in subworkflow_stream:
+                self._context._emit_subworkflow_event(event)
+                if exception:
+                    continue
+
+                if not is_workflow_event(event):
+                    continue
+                if event.workflow_definition != resolved_workflow.__class__:
+                    continue
+
+                if event.name == "workflow.execution.streaming":
+                    if event.output.is_fulfilled:
+                        fulfilled_output_names.add(event.output.name)
+                    yield event.output
+                elif event.name == "workflow.execution.fulfilled":
+                    outputs = event.outputs
+                elif event.name == "workflow.execution.rejected":
+                    exception = NodeException.of(event.error)
+                elif event.name == "workflow.execution.paused":
+                    exception = NodeException(
+                        code=WorkflowErrorCode.INVALID_OUTPUTS,
+                        message="Subworkflow unexpectedly paused",
+                    )
 
-        for event in subworkflow_stream:
-            self._context._emit_subworkflow_event(event)
             if exception:
-                continue
+                raise exception
 
-            if not is_workflow_event(event):
-                continue
-            if event.workflow_definition != resolved_workflow.__class__:
-                continue
-
-            if event.name == "workflow.execution.streaming":
-                if event.output.is_fulfilled:
-                    fulfilled_output_names.add(event.output.name)
-                yield event.output
-            elif event.name == "workflow.execution.fulfilled":
-                outputs = event.outputs
-            elif event.name == "workflow.execution.rejected":
-                exception = NodeException.of(event.error)
-            elif event.name == "workflow.execution.paused":
-                exception = NodeException(
+            if outputs is None:
+                raise NodeException(
+                    message="Expected to receive outputs from Workflow Deployment",
                     code=WorkflowErrorCode.INVALID_OUTPUTS,
-                    message="Subworkflow unexpectedly paused",
                 )
 
-        if exception:
-            raise exception
-
-        if outputs is None:
-            raise NodeException(
-                message="Expected to receive outputs from Workflow Deployment",
-                code=WorkflowErrorCode.INVALID_OUTPUTS,
-            )
-
-        for output_descriptor, output_value in outputs:
-            if output_descriptor.name not in fulfilled_output_names:
-                yield BaseOutput(
-                    name=output_descriptor.name,
-                    value=output_value,
-                )
+            for output_descriptor, output_value in outputs:
+                if output_descriptor.name not in fulfilled_output_names:
+                    yield BaseOutput(
+                        name=output_descriptor.name,
+                        value=output_value,
+                    )
 
     def run(self) -> Iterator[BaseOutput]:
         execution_context = get_execution_context()
@@ -248,11 +275,12 @@ class SubworkflowDeploymentNode(BaseNode[StateType], Generic[StateType]):
                 message="Expected deployment name to be provided for subworkflow execution.",
             )
 
-        resolved_workflow = self._context.resolve_workflow_deployment(
+        resolved_result = self._context.resolve_workflow_deployment(
             deployment_name=deployment_name, release_tag=self.release_tag, state=self.state
         )
-        if resolved_workflow:
-            yield from self._run_resolved_workflow(resolved_workflow)
+        if resolved_result:
+            workflow_class, deployment_metadata = resolved_result
+            yield from self._run_resolved_workflow(workflow_class, deployment_metadata)
             return
 
         try:

vellum/workflows/nodes/experimental/__init__.py

@@ -1,3 +1 @@
-from .openai_chat_completion_node import OpenAIChatCompletionNode
-
-__all__ = ["OpenAIChatCompletionNode"]
+__all__: list[str] = []