vellum-ai 0.12.13__py3-none-any.whl → 0.12.14__py3-none-any.whl

vellum/__init__.py

@@ -1,4 +1,7 @@
 # This file was auto-generated by Fern from our API Definition.
+from .plugins.utils import load_runtime_plugins
+
+load_runtime_plugins()
 
 from .types import (
     AdHocExecutePromptEvent,

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.12.13",
+            "X-Fern-SDK-Version": "0.12.14",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

vellum/plugins/pydantic.py

@@ -1,3 +1,4 @@
+from functools import lru_cache
 from typing import Any, Dict, Literal, Optional, Tuple, Union
 
 from pydantic.plugin import (
@@ -10,12 +11,20 @@ from pydantic.plugin import (
 )
 from pydantic_core import CoreSchema
 
-from vellum.workflows.descriptors.base import BaseDescriptor
+
+@lru_cache(maxsize=1)
+def import_base_descriptor():
+    """
+    We have to avoid importing from vellum.* in this file because it will cause a circular import.
+    """
+    from vellum.workflows.descriptors.base import BaseDescriptor
+
+    return BaseDescriptor
 
 
 # https://docs.pydantic.dev/2.8/concepts/plugins/#build-a-plugin
 class OnValidatePython(ValidatePythonHandlerProtocol):
-    tracked_descriptors: Dict[str, BaseDescriptor] = {}
+    tracked_descriptors: Dict[str, Any] = {}
 
     def on_enter(
         self,
@@ -31,6 +40,7 @@ class OnValidatePython(ValidatePythonHandlerProtocol):
             return
 
         self.tracked_descriptors = {}
+        BaseDescriptor = import_base_descriptor()
 
         for key, value in input.items():
             if isinstance(value, BaseDescriptor):

vellum/workflows/descriptors/tests/test_utils.py

@@ -2,6 +2,7 @@ import pytest
 
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.references.constant import ConstantValueReference
 from vellum.workflows.state.base import BaseState
 
 
@@ -73,6 +74,7 @@ class DummyNode(BaseNode[FixtureState]):
             True,
         ),
         (FixtureState.zeta["foo"], "bar"),
+        (ConstantValueReference(1), 1),
     ],
     ids=[
         "or",
@@ -116,6 +118,7 @@ class DummyNode(BaseNode[FixtureState]):
         "is_not_blank",
         "or_and",
         "accessor",
+        "constants",
     ],
 )
 def test_resolve_value__happy_path(descriptor, expected_value):

vellum/workflows/nodes/bases/base.py

@@ -214,6 +214,9 @@ class _BaseNodeExecutionMeta(type):
         return self_execution_class.node_class.__name__ == other_execution_class.node_class.__name__
 
 
+NodeRunResponse = Union[BaseOutputs, Iterator[BaseOutput]]
+
+
 class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
     __id__: UUID = uuid4_from_hash(__qualname__)
     state: StateType
@@ -350,7 +353,7 @@ class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
 
         self._inputs = MappingProxyType(all_inputs)
 
-    def run(self) -> Union[BaseOutputs, Iterator[BaseOutput]]:
+    def run(self) -> NodeRunResponse:
         return self.Outputs()
 
     def __repr__(self) -> str:

vellum/workflows/nodes/bases/base_adornment_node.py

@@ -0,0 +1,75 @@
+from typing import TYPE_CHECKING, Any, Dict, Generic, Optional, Tuple, Type
+
+from vellum.workflows.nodes.bases.base import BaseNode, BaseNodeMeta
+from vellum.workflows.outputs.base import BaseOutputs
+from vellum.workflows.references.output import OutputReference
+from vellum.workflows.types.generics import StateType
+
+if TYPE_CHECKING:
+    from vellum.workflows import BaseWorkflow
+
+
+class _BaseAdornmentNodeMeta(BaseNodeMeta):
+    def __new__(cls, name: str, bases: Tuple[Type, ...], dct: Dict[str, Any]) -> Any:
+        node_class = super().__new__(cls, name, bases, dct)
+
+        subworkflow_attribute = dct.get("subworkflow")
+        if not subworkflow_attribute:
+            return node_class
+
+        if not issubclass(node_class, BaseAdornmentNode):
+            raise ValueError("BaseAdornableNodeMeta can only be used on subclasses of BaseAdornableNode")
+
+        subworkflow_outputs = getattr(subworkflow_attribute, "Outputs")
+        if not issubclass(subworkflow_outputs, BaseOutputs):
+            raise ValueError("subworkflow.Outputs must be a subclass of BaseOutputs")
+
+        outputs_class = dct.get("Outputs")
+        if not outputs_class:
+            raise ValueError("Outputs class not found in base classes")
+
+        if not issubclass(outputs_class, BaseNode.Outputs):
+            raise ValueError("Outputs class must be a subclass of BaseNode.Outputs")
+
+        for descriptor in subworkflow_outputs:
+            node_class.__annotate_outputs_class__(outputs_class, descriptor)
+
+        return node_class
+
+    def __getattribute__(cls, name: str) -> Any:
+        try:
+            return super().__getattribute__(name)
+        except AttributeError:
+            if name != "__wrapped_node__" and issubclass(cls, BaseAdornmentNode):
+                return getattr(cls.__wrapped_node__, name)
+            raise
+
+    @property
+    def _localns(cls) -> Dict[str, Any]:
+        if not hasattr(cls, "SubworkflowInputs"):
+            return super()._localns
+
+        return {
+            **super()._localns,
+            "SubworkflowInputs": getattr(cls, "SubworkflowInputs"),
+        }
+
+
+class BaseAdornmentNode(
+    BaseNode[StateType],
+    Generic[StateType],
+    metaclass=_BaseAdornmentNodeMeta,
+):
+    """
+    A base node that enables the node to be used as an adornment - meaning it can wrap another node. The
+    wrapped node is stored in the `__wrapped_node__` attribute and is redefined as a single-node subworkflow.
+    """
+
+    __wrapped_node__: Optional[Type["BaseNode"]] = None
+    subworkflow: Type["BaseWorkflow"]
+
+    @classmethod
+    def __annotate_outputs_class__(cls, outputs_class: Type[BaseOutputs], reference: OutputReference) -> None:
+        # Subclasses of BaseAdornableNode can override this method to provider their own
+        # approach to annotating the outputs class based on the `subworkflow.Outputs`
+        setattr(outputs_class, reference.name, reference)

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

@@ -1,6 +1,7 @@
 from uuid import UUID
 from typing import Optional
 
+from vellum.client.types.string_vellum_value_request import StringVellumValueRequest
 from vellum.core.pydantic_utilities import UniversalBaseModel
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases.base import BaseNode
@@ -135,3 +136,15 @@ def test_base_node__default_id():
 
     # THEN it should equal the hash of `test_base_node__default_id.<locals>.MyNode`
     assert my_id == UUID("8e71bea7-ce68-492f-9abe-477c788e6273")
+
+
+def test_base_node__node_resolution__descriptor_in_fern_pydantic():
+    class State(BaseState):
+        foo: str
+
+    class SomeNode(BaseNode):
+        model = StringVellumValueRequest(value=State.foo)
+
+    node = SomeNode(state=State(foo="bar"))
+
+    assert node.model.value == "bar"

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

@@ -10,6 +10,7 @@ from vellum.workflows.state.base import BaseState
 from vellum.workflows.state.context import WorkflowContext
 from vellum.workflows.types.core import EntityInputsInterface
 from vellum.workflows.types.generics import StateType, WorkflowInputsType
+from vellum.workflows.workflows.event_filters import all_workflow_event_filter
 
 if TYPE_CHECKING:
     from vellum.workflows.workflows.base import BaseWorkflow
@@ -36,6 +37,7 @@ class InlineSubworkflowNode(BaseNode[StateType], Generic[StateType, WorkflowInpu
             )
             subworkflow_stream = subworkflow.stream(
                 inputs=self._compile_subworkflow_inputs(),
+                event_filter=all_workflow_event_filter,
             )
 
         outputs: Optional[BaseOutputs] = None

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

@@ -9,21 +9,21 @@ from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.events.types import ParentContext
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.inputs.base import BaseInputs
-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 import BaseOutputs
-from vellum.workflows.state.base import BaseState
+from vellum.workflows.references.output import OutputReference
 from vellum.workflows.state.context import WorkflowContext
-from vellum.workflows.types.generics import NodeType, StateType
+from vellum.workflows.types.generics import StateType
 from vellum.workflows.workflows.event_filters import all_workflow_event_filter
 
 if TYPE_CHECKING:
-    from vellum.workflows import BaseWorkflow
     from vellum.workflows.events.workflow import WorkflowEvent
 
 MapNodeItemType = TypeVar("MapNodeItemType")
 
 
-class MapNode(BaseNode, Generic[StateType, MapNodeItemType]):
+class MapNode(BaseAdornmentNode[StateType], Generic[StateType, MapNodeItemType]):
     """
     Used to map over a list of items and execute a Subworkflow on each iteration.
 
@@ -33,11 +33,10 @@ class MapNode(BaseNode, Generic[StateType, MapNodeItemType]):
     """
 
     items: List[MapNodeItemType]
-    subworkflow: Type["BaseWorkflow"]
     concurrency: Optional[int] = None
 
-    class Outputs(BaseOutputs):
-        mapped_items: list
+    class Outputs(BaseAdornmentNode.Outputs):
+        pass
 
     class SubworkflowInputs(BaseInputs):
         # TODO: Both type: ignore's below are believed to be incorrect and both have the following error:
@@ -54,6 +53,7 @@ class MapNode(BaseNode, Generic[StateType, MapNodeItemType]):
             mapped_items[output_descripter.name] = [None] * len(self.items)
 
         self._event_queue: Queue[Tuple[int, WorkflowEvent]] = Queue()
+        self._concurrency_queue: Queue[Thread] = Queue()
         fulfilled_iterations: List[bool] = []
         for index, item in enumerate(self.items):
             fulfilled_iterations.append(False)
@@ -66,11 +66,21 @@ class MapNode(BaseNode, Generic[StateType, MapNodeItemType]):
                     "parent_context": parent_context,
                 },
             )
-            thread.start()
+            if self.concurrency is None:
+                thread.start()
+            else:
+                self._concurrency_queue.put(thread)
+
+        if self.concurrency is not None:
+            concurrency_count = 0
+            while concurrency_count < self.concurrency:
+                is_empty = self._start_thread()
+                if is_empty:
+                    break
+
+                concurrency_count += 1
 
         try:
-            # We should consolidate this logic with the logic workflow runner uses
-            # https://app.shortcut.com/vellum/story/4736
             while map_node_event := self._event_queue.get():
                 index = map_node_event[0]
                 terminal_event = map_node_event[1]
@@ -86,6 +96,9 @@ class MapNode(BaseNode, Generic[StateType, MapNodeItemType]):
                     fulfilled_iterations[index] = True
                     if all(fulfilled_iterations):
                         break
+
+                    if self.concurrency is not None:
+                        self._start_thread()
                 elif terminal_event.name == "workflow.execution.paused":
                     raise NodeException(
                         code=WorkflowErrorCode.INVALID_OUTPUTS,
@@ -98,7 +111,12 @@ class MapNode(BaseNode, Generic[StateType, MapNodeItemType]):
                     )
         except Empty:
             pass
-        return self.Outputs(**mapped_items)
+
+        outputs = self.Outputs()
+        for output_name, output_list in mapped_items.items():
+            setattr(outputs, output_name, output_list)
+
+        return outputs
 
     def _context_run_subworkflow(
         self, *, item: MapNodeItemType, index: int, parent_context: Optional[ParentContext] = None
@@ -109,7 +127,10 @@ class MapNode(BaseNode, Generic[StateType, MapNodeItemType]):
 
     def _run_subworkflow(self, *, item: MapNodeItemType, index: int) -> None:
         context = WorkflowContext(vellum_client=self._context.vellum_client)
-        subworkflow = self.subworkflow(parent_state=self.state, context=context)
+        subworkflow = self.subworkflow(
+            parent_state=self.state,
+            context=context,
+        )
         events = subworkflow.stream(
             inputs=self.SubworkflowInputs(index=index, item=item, all_items=self.items),
             event_filter=all_workflow_event_filter,
@@ -118,6 +139,14 @@ class MapNode(BaseNode, Generic[StateType, MapNodeItemType]):
         for event in events:
             self._event_queue.put((index, event))
 
+    def _start_thread(self) -> bool:
+        if self._concurrency_queue.empty():
+            return False
+
+        thread = self._concurrency_queue.get()
+        thread.start()
+        return True
+
     @overload
     @classmethod
     def wrap(cls, items: List[MapNodeItemType]) -> Callable[..., Type["MapNode[StateType, MapNodeItemType]"]]: ...
@@ -134,37 +163,12 @@ class MapNode(BaseNode, Generic[StateType, MapNodeItemType]):
     def wrap(
         cls, items: Union[List[MapNodeItemType], BaseDescriptor[List[MapNodeItemType]]]
     ) -> Callable[..., Type["MapNode[StateType, MapNodeItemType]"]]:
-        _items = items
+        return create_adornment(cls, attributes={"items": items})
 
-        def decorator(inner_cls: Type[NodeType]) -> Type["MapNode[StateType, MapNodeItemType]"]:
-            # Investigate how to use dependency injection to avoid circular imports
-            # https://app.shortcut.com/vellum/story/4116
-            from vellum.workflows import BaseWorkflow
-
-            class Subworkflow(BaseWorkflow[MapNode.SubworkflowInputs, BaseState]):
-                graph = inner_cls
-
-                # mypy is wrong here, this works and is defined
-                class Outputs(inner_cls.Outputs):  # type: ignore[name-defined]
-                    pass
-
-            class WrappedNodeOutputs(BaseOutputs):
-                pass
-
-            WrappedNodeOutputs.__annotations__ = {
-                # TODO: We'll need to infer the type T of Subworkflow.Outputs[name] so we could do List[T] here
-                # https://app.shortcut.com/vellum/story/4119
-                descriptor.name: List
-                for descriptor in inner_cls.Outputs
-            }
-
-            class WrappedNode(MapNode[StateType, MapNodeItemType]):
-                items = _items
-                subworkflow = Subworkflow
-
-                class Outputs(WrappedNodeOutputs):
-                    pass
-
-            return WrappedNode
+    @classmethod
+    def __annotate_outputs_class__(cls, outputs_class: Type[BaseOutputs], reference: OutputReference) -> None:
+        parameter_type = reference.types[0]
+        annotation = List[parameter_type]  # type: ignore[valid-type]
 
-        return decorator
+        previous_annotations = {prev: annotation for prev in outputs_class.__annotations__ if not prev.startswith("_")}
+        outputs_class.__annotations__ = {**previous_annotations, reference.name: annotation}

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

@@ -1,27 +1,16 @@
-from typing import TYPE_CHECKING, Any, Callable, Dict, Generic, Optional, Type
+from typing import Callable, Generic, Optional, Type
 
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases import BaseNode
-from vellum.workflows.nodes.bases.base import BaseNodeMeta
-from vellum.workflows.state.base import BaseState
+from vellum.workflows.nodes.bases.base_adornment_node import BaseAdornmentNode
+from vellum.workflows.nodes.utils import create_adornment
+from vellum.workflows.state.context import WorkflowContext
 from vellum.workflows.types.generics import StateType
 
-if TYPE_CHECKING:
-    from vellum.workflows import BaseWorkflow
 
-
-class _RetryNodeMeta(BaseNodeMeta):
-    @property
-    def _localns(cls) -> Dict[str, Any]:
-        return {
-            **super()._localns,
-            "SubworkflowInputs": getattr(cls, "SubworkflowInputs"),
-        }
-
-
-class RetryNode(BaseNode[StateType], Generic[StateType], metaclass=_RetryNodeMeta):
+class RetryNode(BaseAdornmentNode[StateType], Generic[StateType]):
     """
     Used to retry a Subworkflow a specified number of times.
 
@@ -32,7 +21,6 @@ class RetryNode(BaseNode[StateType], Generic[StateType], metaclass=_RetryNodeMet
 
     max_attempts: int
     retry_on_error_code: Optional[WorkflowErrorCode] = None
-    subworkflow: Type["BaseWorkflow[SubworkflowInputs, BaseState]"]
 
     class SubworkflowInputs(BaseInputs):
         attempt_number: int
@@ -41,9 +29,10 @@ class RetryNode(BaseNode[StateType], Generic[StateType], metaclass=_RetryNodeMet
         last_exception = Exception("max_attempts must be greater than 0")
         for index in range(self.max_attempts):
             attempt_number = index + 1
+            context = WorkflowContext(vellum_client=self._context.vellum_client)
             subworkflow = self.subworkflow(
                 parent_state=self.state,
-                context=self._context,
+                context=context,
             )
             terminal_event = subworkflow.run(
                 inputs=self.SubworkflowInputs(attempt_number=attempt_number),
@@ -78,30 +67,6 @@ Message: {terminal_event.error.message}""",
     def wrap(
         cls, max_attempts: int, retry_on_error_code: Optional[WorkflowErrorCode] = None
     ) -> Callable[..., Type["RetryNode"]]:
-        _max_attempts = max_attempts
-        _retry_on_error_code = retry_on_error_code
-
-        def decorator(inner_cls: Type[BaseNode]) -> Type["RetryNode"]:
-            # Investigate how to use dependency injection to avoid circular imports
-            # https://app.shortcut.com/vellum/story/4116
-            from vellum.workflows import BaseWorkflow
-
-            class Subworkflow(BaseWorkflow[RetryNode.SubworkflowInputs, BaseState]):
-                graph = inner_cls
-
-                # mypy is wrong here, this works and is defined
-                class Outputs(inner_cls.Outputs):  # type: ignore[name-defined]
-                    pass
-
-            class WrappedNode(RetryNode[StateType]):
-                max_attempts = _max_attempts
-                retry_on_error_code = _retry_on_error_code
-
-                subworkflow = Subworkflow
-
-                class Outputs(Subworkflow.Outputs):
-                    pass
-
-            return WrappedNode
-
-        return decorator
+        return create_adornment(
+            cls, attributes={"max_attempts": max_attempts, "retry_on_error_code": retry_on_error_code}
+        )

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

@@ -1,61 +1,18 @@
-import sys
-from types import ModuleType
-from typing import TYPE_CHECKING, Any, Callable, Dict, Generic, Iterator, Optional, Set, Tuple, Type, TypeVar
+from typing import Callable, Generic, Iterator, Optional, Set, Type
 
 from vellum.workflows.errors.types import WorkflowError, WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases import BaseNode
-from vellum.workflows.nodes.bases.base import BaseNodeMeta
-from vellum.workflows.nodes.utils import ADORNMENT_MODULE_NAME
+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
+from vellum.workflows.references.output import OutputReference
 from vellum.workflows.state.context import WorkflowContext
 from vellum.workflows.types.generics import StateType
 from vellum.workflows.workflows.event_filters import all_workflow_event_filter
 
-if TYPE_CHECKING:
-    from vellum.workflows import BaseWorkflow
 
-Subworkflow = Type["BaseWorkflow"]
-_T = TypeVar("_T", bound=BaseOutputs)
-
-
-class _TryNodeMeta(BaseNodeMeta):
-    def __new__(cls, name: str, bases: Tuple[Type, ...], dct: Dict[str, Any]) -> Any:
-        node_class = super().__new__(cls, name, bases, dct)
-
-        subworkflow_attribute = dct.get("subworkflow")
-        if not subworkflow_attribute:
-            return node_class
-
-        subworkflow_outputs = getattr(subworkflow_attribute, "Outputs")
-        if not issubclass(subworkflow_outputs, BaseOutputs):
-            raise ValueError("subworkflow.Outputs must be a subclass of BaseOutputs")
-
-        outputs_class = dct.get("Outputs")
-        if not outputs_class:
-            raise ValueError("Outputs class not found in base classes")
-
-        if not issubclass(outputs_class, BaseNode.Outputs):
-            raise ValueError("Outputs class must be a subclass of BaseNode.Outputs")
-
-        for descriptor in subworkflow_outputs:
-            if descriptor.name == "error":
-                raise ValueError("`error` is a reserved name for TryNode.Outputs")
-
-            setattr(outputs_class, descriptor.name, descriptor)
-
-        return node_class
-
-    def __getattribute__(cls, name: str) -> Any:
-        try:
-            return super().__getattribute__(name)
-        except AttributeError:
-            if name != "__wrapped_node__" and issubclass(cls, TryNode):
-                return getattr(cls.__wrapped_node__, name)
-            raise
-
-
-class TryNode(BaseNode[StateType], Generic[StateType], metaclass=_TryNodeMeta):
+class TryNode(BaseAdornmentNode[StateType], Generic[StateType]):
     """
     Used to execute a Subworkflow and handle errors.
 
@@ -63,9 +20,7 @@ class TryNode(BaseNode[StateType], Generic[StateType], metaclass=_TryNodeMeta):
     subworkflow: Type["BaseWorkflow"] - The Subworkflow to execute
     """
 
-    __wrapped_node__: Optional[Type["BaseNode"]] = None
     on_error_code: Optional[WorkflowErrorCode] = None
-    subworkflow: Type["BaseWorkflow"]
 
     class Outputs(BaseNode.Outputs):
         error: Optional[WorkflowError] = None
@@ -129,38 +84,11 @@ Message: {event.error.message}""",
 
     @classmethod
     def wrap(cls, on_error_code: Optional[WorkflowErrorCode] = None) -> Callable[..., Type["TryNode"]]:
-        _on_error_code = on_error_code
-
-        def decorator(inner_cls: Type[BaseNode]) -> Type["TryNode"]:
-            # Investigate how to use dependency injection to avoid circular imports
-            # https://app.shortcut.com/vellum/story/4116
-            from vellum.workflows import BaseWorkflow
-
-            inner_cls._is_wrapped_node = True
-
-            class Subworkflow(BaseWorkflow):
-                graph = inner_cls
-
-                # mypy is wrong here, this works and is defined
-                class Outputs(inner_cls.Outputs):  # type: ignore[name-defined]
-                    pass
-
-            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)
-
-            # We use a dynamic wrapped node class to be uniquely tied to this `inner_cls` node during serialization
-            WrappedNode = type(
-                cls.__name__,
-                (TryNode,),
-                {
-                    "__wrapped_node__": inner_cls,
-                    "__module__": dynamic_module,
-                    "on_error_code": _on_error_code,
-                    "subworkflow": Subworkflow,
-                    "Ports": type("Ports", (TryNode.Ports,), {port.name: port.copy() for port in inner_cls.Ports}),
-                },
-            )
-            return WrappedNode
+        return create_adornment(cls, attributes={"on_error_code": on_error_code})
+
+    @classmethod
+    def __annotate_outputs_class__(cls, outputs_class: Type[BaseOutputs], reference: OutputReference) -> None:
+        if reference.name == "error":
+            raise ValueError("`error` is a reserved name for TryNode.Outputs")
 
-        return decorator
+        setattr(outputs_class, reference.name, reference)

vellum/workflows/nodes/utils.py

@@ -1,5 +1,7 @@
 from functools import cache
-from typing import Type
+import sys
+from types import ModuleType
+from typing import Any, Callable, Optional, Type, TypeVar
 
 from vellum.workflows.nodes import BaseNode
 from vellum.workflows.ports.port import Port
@@ -42,3 +44,44 @@ def has_wrapped_node(node: Type[NodeType]) -> bool:
         return False
 
     return True
+
+
+AdornableNode = TypeVar("AdornableNode", bound=BaseNode)
+
+
+def create_adornment(
+    adornable_cls: Type[AdornableNode], attributes: Optional[dict[str, Any]] = None
+) -> Callable[..., Type["AdornableNode"]]:
+    def decorator(inner_cls: Type[BaseNode]) -> Type["AdornableNode"]:
+        # Investigate how to use dependency injection to avoid circular imports
+        # https://app.shortcut.com/vellum/story/4116
+        from vellum.workflows import BaseWorkflow
+
+        inner_cls._is_wrapped_node = True
+
+        class Subworkflow(BaseWorkflow):
+            graph = inner_cls
+
+            # mypy is wrong here, this works and is defined
+            class Outputs(inner_cls.Outputs):  # type: ignore[name-defined]
+                pass
+
+        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)
+
+        # We use a dynamic wrapped node class to be uniquely tied to this `inner_cls` node during serialization
+        WrappedNode = type(
+            adornable_cls.__name__,
+            (adornable_cls,),
+            {
+                "__wrapped_node__": inner_cls,
+                "__module__": dynamic_module,
+                "subworkflow": Subworkflow,
+                "Ports": type("Ports", (adornable_cls.Ports,), {port.name: port.copy() for port in inner_cls.Ports}),
+                **(attributes or {}),
+            },
+        )
+        return WrappedNode
+
+    return decorator

vellum/workflows/references/constant.py

@@ -0,0 +1,21 @@
+from typing import TYPE_CHECKING, Generic, TypeVar
+
+from vellum.workflows.descriptors.base import BaseDescriptor
+
+if TYPE_CHECKING:
+    from vellum.workflows.state.base import BaseState
+
+_T = TypeVar("_T")
+
+
+class ConstantValueReference(BaseDescriptor[_T], Generic[_T]):
+    def __init__(
+        self,
+        value: _T,
+    ) -> None:
+        self._value = value
+        types = (type(self._value),)
+        super().__init__(name=str(self._value), types=types)
+
+    def resolve(self, state: "BaseState") -> _T:
+        return self._value

vellum/workflows/runner/runner.py

@@ -44,11 +44,13 @@ from vellum.workflows.events.workflow import (
 )
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases import BaseNode
+from vellum.workflows.nodes.bases.base import NodeRunResponse
 from vellum.workflows.outputs import BaseOutputs
 from vellum.workflows.outputs.base import BaseOutput
 from vellum.workflows.ports.port import Port
 from vellum.workflows.references import ExternalInputReference, OutputReference
 from vellum.workflows.state.base import BaseState
+from vellum.workflows.types.cycle_map import CycleMap
 from vellum.workflows.types.generics import OutputsType, StateType, WorkflowInputsType
 
 if TYPE_CHECKING:
@@ -124,9 +126,7 @@ class WorkflowRunner(Generic[StateType]):
 
         self._dependencies: Dict[Type[BaseNode], Set[Type[BaseNode]]] = defaultdict(set)
         self._state_forks: Set[StateType] = {self._initial_state}
-        self._mocks_by_node_outputs_class = (
-            {mock.__class__: mock for mock in node_output_mocks} if node_output_mocks else {}
-        )
+        self._mocks_by_node_outputs_class = CycleMap(items=node_output_mocks or [], key_by=lambda mock: mock.__class__)
 
         self._active_nodes_by_execution_id: Dict[UUID, BaseNode[StateType]] = {}
         self._cancel_signal = cancel_signal
@@ -182,6 +182,7 @@ class WorkflowRunner(Generic[StateType]):
                 node_definition=node.__class__,
                 parent=parent_context,
             )
+            node_run_response: NodeRunResponse
             if node.Outputs not in self._mocks_by_node_outputs_class:
                 with execution_context(parent_context=updated_parent_context):
                     node_run_response = node.run()

vellum/workflows/types/cycle_map.py

@@ -0,0 +1,34 @@
+from typing import Callable, Dict, Generic, List, TypeVar
+
+_K = TypeVar("_K")
+_T = TypeVar("_T")
+
+
+class CycleMap(Generic[_K, _T]):
+    """
+    A map that cycles through a list of items for each key.
+    """
+
+    def __init__(self, items: List[_T], key_by: Callable[[_T], _K]):
+        self._items: Dict[_K, List[_T]] = {}
+        for item in items:
+            self._add_item(key_by(item), item)
+
+    def _add_item(self, key: _K, item: _T):
+        if key not in self._items:
+            self._items[key] = []
+        self._items[key].append(item)
+
+    def _get_item(self, key: _K) -> _T:
+        item = self._items[key].pop(0)
+        self._items[key].append(item)
+        return item
+
+    def __getitem__(self, key: _K) -> _T:
+        return self._get_item(key)
+
+    def __setitem__(self, key: _K, value: _T):
+        self._add_item(key, value)
+
+    def __contains__(self, key: _K) -> bool:
+        return key in self._items

vellum/workflows/workflows/base.py

@@ -1,16 +1,7 @@
-# flake8: noqa: E402
-
-import importlib
-import inspect
-
-from vellum.plugins.utils import load_runtime_plugins
-from vellum.workflows.utils.uuids import uuid4_from_hash
-from vellum.workflows.workflows.event_filters import workflow_event_filter
-
-load_runtime_plugins()
-
 from datetime import datetime
 from functools import lru_cache
+import importlib
+import inspect
 from threading import Event as ThreadingEvent
 from uuid import UUID, uuid4
 from typing import (
@@ -79,6 +70,8 @@ from vellum.workflows.state.context import WorkflowContext
 from vellum.workflows.state.store import Store
 from vellum.workflows.types.generics import StateType, WorkflowInputsType
 from vellum.workflows.types.utils import get_original_base
+from vellum.workflows.utils.uuids import uuid4_from_hash
+from vellum.workflows.workflows.event_filters import workflow_event_filter
 
 
 class _BaseWorkflowMeta(type):

{vellum_ai-0.12.13.dist-info → vellum_ai-0.12.14.dist-info}/METADATA

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

{vellum_ai-0.12.13.dist-info → vellum_ai-0.12.14.dist-info}/RECORD

@@ -72,12 +72,14 @@ vellum_ee/workflows/display/workflows/__init__.py,sha256=kapXsC67VJcgSuiBMa86Fde
 vellum_ee/workflows/display/workflows/base_workflow_display.py,sha256=ydAbFMzcY2LURINZbXYm9BAXZdIa3-7rQ86Kupo7qcA,12804
 vellum_ee/workflows/display/workflows/get_vellum_workflow_display_class.py,sha256=AMxNnTm2z3LIR5rqxoCAfuy37F2FTuSRDVtKUoezO8M,1184
 vellum_ee/workflows/display/workflows/vellum_workflow_display.py,sha256=GhIviEMDWNw1p8z20ta08T5PeNCVJs5p2hrOX1uyNxg,17066
-vellum/__init__.py,sha256=FTKuzi4UX1MAYpZnW-JbtU8WgOzUIfolgajVVR96LGs,35552
+vellum_ee/workflows/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vellum_ee/workflows/server/virtual_file_loader.py,sha256=sQQFqn7xI0GfUlypWkVFl-X5ShXTh9bXq8N6qlQvSoE,1452
+vellum/__init__.py,sha256=eS4rbj1wrussRENYQRA1GZ5JgcbIlqDad_ARuOihIYE,35624
 vellum/client/README.md,sha256=JkCJjmMZl4jrPj46pkmL9dpK4gSzQQmP5I7z4aME4LY,4749
 vellum/client/__init__.py,sha256=z59nOGe27vMDqsU-ljfULBwC5J4nyrqFunhmo8xnxbU,111521
 vellum/client/core/__init__.py,sha256=SQ85PF84B9MuKnBwHNHWemSGuy-g_515gFYNFhvEE0I,1438
 vellum/client/core/api_error.py,sha256=RE8LELok2QCjABadECTvtDp7qejA1VmINCh6TbqPwSE,426
-vellum/client/core/client_wrapper.py,sha256=vjueLRJ8AxJ_TUVQkuXwAW-kVfBfyveLY3BAgl-dZqE,1869
+vellum/client/core/client_wrapper.py,sha256=eCp0imbOxsKZE981B9ikNz1dw1PL356Io3515uO93DY,1869
 vellum/client/core/datetime_utils.py,sha256=nBys2IsYrhPdszxGKCNRPSOCwa-5DWOHG95FB8G9PKo,1047
 vellum/client/core/file.py,sha256=X9IbmkZmB2bB_DpmZAO3crWdXagOakAyn6UCOCImCPg,2322
 vellum/client/core/http_client.py,sha256=R0pQpCppnEtxccGvXl4uJ76s7ro_65Fo_erlNNLp_AI,19228
@@ -656,7 +658,7 @@ vellum/evaluations/utils/env.py,sha256=Xj_nxsoU5ox06EOTjRopR4lrigQI6Le6qbWGltYoE
 vellum/evaluations/utils/exceptions.py,sha256=dXMAkzqbHV_AP5FjjbegPlfUE0zQDlpA3qOsoOJUxfg,49
 vellum/evaluations/utils/paginator.py,sha256=rEED_BJAXAM6tM1yMwHePNzszjq_tTq4NbQvi1jWQ_Q,697
 vellum/plugins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/plugins/pydantic.py,sha256=EbI0pJMhUS9rLPSkzmAELfnCHrWCJzOrU06T8ommwdw,2334
+vellum/plugins/pydantic.py,sha256=dNtZWHo-IdseG52C2RoTanxyTJg0AhPZrH-9lbNqwYg,2604
 vellum/plugins/utils.py,sha256=U9ZY9KdE3RRvbcG01hXxu9CvfJD6Fo7nJDgcHjQn0FI,606
 vellum/plugins/vellum_mypy.py,sha256=VC15EzjTsXOb9uF1bky4rcxePP-0epMVmCsLB2z4Dh8,24816
 vellum/prompts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -1218,7 +1220,7 @@ vellum/workflows/constants.py,sha256=Z0W4YlqfSlSgWC11PrVUPs6ZOBeIaQ78E_90J1hohiw
 vellum/workflows/context.py,sha256=R8qdsFbD_0p7B6PWnyvSrZ_aOgMtGw-_uk0P0UAmwLA,1230
 vellum/workflows/descriptors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/descriptors/base.py,sha256=BhYd5O9_3fjS_Vet9Q2_kyUJCySHGVM_HWaOBtctkNA,14320
-vellum/workflows/descriptors/tests/test_utils.py,sha256=bjWNlmyCmtpDZmIzwYmS1Yh7kulmMO6LgNJFYVFCg4o,4377
+vellum/workflows/descriptors/tests/test_utils.py,sha256=1CFx6Yejrg_AlwSO6kqGjuav4-ZubCLN0u4NtR3KgCk,4510
 vellum/workflows/descriptors/utils.py,sha256=lO_dbr5g3PXpHPtVBkdguAK4-1qayZ7RXjl3BgAhrMM,3795
 vellum/workflows/edges/__init__.py,sha256=wSkmAnz9xyi4vZwtDbKxwlplt2skD7n3NsxkvR_pUus,50
 vellum/workflows/edges/edge.py,sha256=N0SnY3gKVuxImPAdCbPMPlHJIXbkQ3fwq_LbJRvVMFc,677
@@ -1273,29 +1275,30 @@ vellum/workflows/inputs/base.py,sha256=1kMgr0WqCYdWUqgFvgSoAMw2067FAlgwhGXLgbIOr
 vellum/workflows/logging.py,sha256=_a217XogktV4Ncz6xKFz7WfYmZAzkfVRVuC0rWob8ls,437
 vellum/workflows/nodes/__init__.py,sha256=aVdQVv7Y3Ro3JlqXGpxwaU2zrI06plDHD2aumH5WUIs,1157
 vellum/workflows/nodes/bases/__init__.py,sha256=cniHuz_RXdJ4TQgD8CBzoiKDiPxg62ErdVpCbWICX64,58
-vellum/workflows/nodes/bases/base.py,sha256=_Ms_Yov6sIsgWnKb0OWnOG7liqgjFSat0y1OIX36hFA,14235
+vellum/workflows/nodes/bases/base.py,sha256=RREFzYPxemKUvQc0NfnwQmby-p_BE3O-TbVWKbQFdfs,14271
+vellum/workflows/nodes/bases/base_adornment_node.py,sha256=eFTgsPCYb3eyGS0-kw7C6crFnwFx437R5wh9-8bWYts,2905
 vellum/workflows/nodes/bases/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/nodes/bases/tests/test_base_node.py,sha256=ghpLm_ljNBxWs43GlvIId47hOVwKU50XpvZxmlg6_8g,3439
+vellum/workflows/nodes/bases/tests/test_base_node.py,sha256=51CueFVty9XYASC0rKr1cXWejho5WElmhfhp6cCONy0,3811
 vellum/workflows/nodes/core/__init__.py,sha256=5zDMCmyt1v0HTJzlUBwq3U9L825yZGZhT9JL18-mRR4,455
 vellum/workflows/nodes/core/error_node/__init__.py,sha256=g7RRnlHhqu4qByfLjBwCunmgGA8dI5gNsjS3h6TwlSI,60
 vellum/workflows/nodes/core/error_node/node.py,sha256=MFHU5vITYSK-L9CuMZ49In2ZeNLWnhZD0f8r5dWvb5Y,1270
 vellum/workflows/nodes/core/inline_subworkflow_node/__init__.py,sha256=nKNEH1QTl-1PcvmYoqSWEl0-t6gAur8GLTXHzklRQfM,84
-vellum/workflows/nodes/core/inline_subworkflow_node/node.py,sha256=btscTP3T5VzvuNpbzaUlRZ1ahMkTox0Vyv17tI7YFUw,3467
+vellum/workflows/nodes/core/inline_subworkflow_node/node.py,sha256=zyKvpeNoD2D7vtGbNuvqXUxVgtkmSbk1XQExwX9KUf8,3602
 vellum/workflows/nodes/core/inline_subworkflow_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/core/inline_subworkflow_node/tests/test_node.py,sha256=99LLPgHMqohGL-G4KqOSjeVlDR_FH8Rv1gtRii85MC4,1143
 vellum/workflows/nodes/core/map_node/__init__.py,sha256=MXpZYmGfhsMJHqqlpd64WiJRtbAtAMQz-_3fCU_cLV0,56
-vellum/workflows/nodes/core/map_node/node.py,sha256=5Bqi0co1T9Ex_sTlyTDMGahwsUWd9NCO0vTY6UqsZeQ,7286
+vellum/workflows/nodes/core/map_node/node.py,sha256=DTMoGqtR8MyfZ8jy8apNoN-4KFFFHywo87pfpqyBVEw,7322
 vellum/workflows/nodes/core/map_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/core/map_node/tests/test_node.py,sha256=RHSZs7t6mW3UWvRrXnHZqaXVdRT2ZquOK_YHJ-gzXsU,1871
 vellum/workflows/nodes/core/retry_node/__init__.py,sha256=lN2bIy5a3Uzhs_FYCrooADyYU6ZGShtvLKFWpelwPvo,60
-vellum/workflows/nodes/core/retry_node/node.py,sha256=IjNcpzFmHyBUjOHEoULLbKf85B5Dva2XNR6jxPxZeoc,4223
+vellum/workflows/nodes/core/retry_node/node.py,sha256=lAABgo2E_pWkzOYUBGzC1SnywgwtGuJojwT602fKCUc,3153
 vellum/workflows/nodes/core/retry_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/core/retry_node/tests/test_node.py,sha256=QXTnHwmJHISxXjvZMeuuEo0iVugVMJyaJoggI8yKXfI,3132
 vellum/workflows/nodes/core/templating_node/__init__.py,sha256=GmyuYo81_A1_Bz6id69ozVFS6FKiuDsZTiA3I6MaL2U,70
 vellum/workflows/nodes/core/templating_node/node.py,sha256=N-NOBd-UY91qO9orCcW4KEbhNvDQivZPA-PCxs-M0RM,4204
 vellum/workflows/nodes/core/templating_node/tests/test_templating_node.py,sha256=nW_kyJ9RAqz45_kJE_rlhOOvbV4OO3hecP-P-ydQpkw,2845
 vellum/workflows/nodes/core/try_node/__init__.py,sha256=JVD4DrldTIqFQQFrubs9KtWCCc0YCAc7Fzol5ZWIWeM,56
-vellum/workflows/nodes/core/try_node/node.py,sha256=e4gavIJ9AHM0JCKOrBIeKC4aHxmJK3j17XTBaipqfpc,6637
+vellum/workflows/nodes/core/try_node/node.py,sha256=_lTmSYCiz7lktaxpNWUCglNi8_5Sfy8Rpiov5SeKVMw,3920
 vellum/workflows/nodes/core/try_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/core/try_node/tests/test_node.py,sha256=Wc2kLl-MkffsBxl3IiFaqLd16e2Iosxhk7qBnojPvQg,4092
 vellum/workflows/nodes/displayable/__init__.py,sha256=6F_4DlSwvHuilWnIalp8iDjjDXl0Nmz4QzJV2PYe5RI,1023
@@ -1346,7 +1349,7 @@ vellum/workflows/nodes/experimental/README.md,sha256=eF6DfIL8t-HbF9-mcofOMymKrra
 vellum/workflows/nodes/experimental/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/experimental/openai_chat_completion_node/__init__.py,sha256=lsyD9laR9p7kx5-BXGH2gUTM242UhKy8SMV0SR6S2iE,90
 vellum/workflows/nodes/experimental/openai_chat_completion_node/node.py,sha256=1EGeiaT-Zoo6pttQFKKBcdf3dmhAbjKGaErYD5FFwlc,10185
-vellum/workflows/nodes/utils.py,sha256=EZt7CzJmgQBR_GWFpZr8d-oaoti3tolTd2Cv9wm7dKo,1087
+vellum/workflows/nodes/utils.py,sha256=chSsmKe_BsvMIJpzSxO5TWYlr3sAuxiwkfB5azkuN5Q,2715
 vellum/workflows/outputs/__init__.py,sha256=AyZ4pRh_ACQIGvkf0byJO46EDnSix1ZCAXfvh-ms1QE,94
 vellum/workflows/outputs/base.py,sha256=a7W6rNSDSawwGAXYjNTF2iHb9lnZu7WFSOagZIyy__k,7976
 vellum/workflows/ports/__init__.py,sha256=bZuMt-R7z5bKwpu4uPW7LlJeePOQWmCcDSXe5frUY5g,101
@@ -1354,6 +1357,7 @@ vellum/workflows/ports/node_ports.py,sha256=g4A-8iUAvEJSkaWppbvzAR8XU02R9U-qLN4r
 vellum/workflows/ports/port.py,sha256=rc3GB7dDQCUs0IbY08a92-31YzJHQgBeww13brSJ2Js,3172
 vellum/workflows/ports/utils.py,sha256=pEjVNJKw9LhD_cFN-o0MWBOW2ejno7jv26qqzjLxwS4,1662
 vellum/workflows/references/__init__.py,sha256=glHFC1VfXmcbNvH5VzFbkT03d8_D7MMcvEcsUBrzLIs,591
+vellum/workflows/references/constant.py,sha256=6yUT4q1sMj1hkI_tzzQ9AYcmeeDYFUNCqUq_W2DN0S8,540
 vellum/workflows/references/environment_variable.py,sha256=7FFtiKfc4eyVkkfUbhc666OBNDqvFlMoNQEYmGpEVVE,661
 vellum/workflows/references/execution_count.py,sha256=JILHqt8ELdc9ct-WsVCA5X-rKiP1rmJODw-XTf4kpHI,722
 vellum/workflows/references/external_input.py,sha256=XHugauKYvAmsGoFnjgJh00FcXjSMIqBvRun_CZuJD64,1662
@@ -1367,7 +1371,7 @@ vellum/workflows/references/workflow_input.py,sha256=86IuhlBz-9cGxeUzizyjdp482aj
 vellum/workflows/resolvers/__init__.py,sha256=eH6hTvZO4IciDaf_cf7aM2vs-DkBDyJPycOQevJxQnI,82
 vellum/workflows/resolvers/base.py,sha256=WHra9LRtlTuB1jmuNqkfVE2JUgB61Cyntn8f0b0WZg4,411
 vellum/workflows/runner/__init__.py,sha256=i1iG5sAhtpdsrlvwgH6B-m49JsINkiWyPWs8vyT-bqM,72
-vellum/workflows/runner/runner.py,sha256=DuFvMyejwdIdapQDHrfVtouaifLEZ02WYPARmK3UqdE,28006
+vellum/workflows/runner/runner.py,sha256=wS9GulRM8f77sQ9-FlDpHjQJgoMLt0cTDRSTpucTyr0,28139
 vellum/workflows/sandbox.py,sha256=GVJzVjMuYzOBnSrboB0_6MMRZWBluAyQ2o7syeaeBd0,2235
 vellum/workflows/state/__init__.py,sha256=yUUdR-_Vl7UiixNDYQZ-GEM_kJI9dnOia75TtuNEsnE,60
 vellum/workflows/state/base.py,sha256=jpSzF1OQd3-fqi6dMGlNsQl-7JnJxCdzWIigmX8Wz-I,14425
@@ -1380,6 +1384,7 @@ vellum/workflows/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3
 vellum/workflows/tests/test_sandbox.py,sha256=JKwaluI-lODQo7Ek9sjDstjL_WTdSqUlVik6ZVTfVOA,1826
 vellum/workflows/types/__init__.py,sha256=KxUTMBGzuRCfiMqzzsykOeVvrrkaZmTTo1a7SLu8gRM,68
 vellum/workflows/types/core.py,sha256=D2NcSBwGgWj_mtXZqe3KnEQcb5qd5HzqAwnxwmlCfCw,899
+vellum/workflows/types/cycle_map.py,sha256=-ZMQsKzZBpCi0bchJrkuN_dtCFuz9uFABy7Fq2PI58E,928
 vellum/workflows/types/generics.py,sha256=ZkfoRhWs042i5IjA99v2wIhmh1u-Wieo3LzosgGWJVk,600
 vellum/workflows/types/stack.py,sha256=RDSGLkcV612ge8UuAH9TZiEGXxJt0Av2-H5rfzrTVVI,1014
 vellum/workflows/types/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -1397,10 +1402,10 @@ vellum/workflows/utils/uuids.py,sha256=DFzPv9RCvsKhvdTEIQyfSek2A31D6S_QcmeLPbgrg
 vellum/workflows/utils/vellum_variables.py,sha256=g5xHYB8etfHE32ek19nP6Anf8NyjhmUtOwO2KmQ5xZU,3111
 vellum/workflows/vellum_client.py,sha256=ODrq_TSl-drX2aezXegf7pizpWDVJuTXH-j6528t75s,683
 vellum/workflows/workflows/__init__.py,sha256=KY45TqvavCCvXIkyCFMEc0dc6jTMOUci93U2DUrlZYc,66
-vellum/workflows/workflows/base.py,sha256=TLk5NiDB8N_Ytkzj_T8o-E4WpTUH8qJYZcoOk2xR3mo,18986
+vellum/workflows/workflows/base.py,sha256=qdZYQq-jjdr0fYT0FCfmFuI5ypE3pANupgYcOqqML0o,18884
 vellum/workflows/workflows/event_filters.py,sha256=GSxIgwrX26a1Smfd-6yss2abGCnadGsrSZGa7t7LpJA,2008
-vellum_ai-0.12.13.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
-vellum_ai-0.12.13.dist-info/METADATA,sha256=uXAzy9xHbkmecOGR1GasDk6auS-Hbl12VwdAgqAuo5c,5161
-vellum_ai-0.12.13.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-vellum_ai-0.12.13.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
-vellum_ai-0.12.13.dist-info/RECORD,,
+vellum_ai-0.12.14.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
+vellum_ai-0.12.14.dist-info/METADATA,sha256=pMVsOWid4kf15trT9SP0w9_wfPpc-E6i4dV8rsUAfSc,5161
+vellum_ai-0.12.14.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+vellum_ai-0.12.14.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
+vellum_ai-0.12.14.dist-info/RECORD,,

vellum_ee/workflows/server/virtual_file_loader.py

@@ -0,0 +1,42 @@
+import importlib
+
+
+class VirtualFileLoader(importlib.abc.Loader):
+    def __init__(self, code: str, is_package: bool):
+        self.code = code
+        self.is_package = is_package
+
+    def create_module(self, spec):
+        return None  # use default module creation
+
+    def exec_module(self, module):
+        if not self.is_package:
+            exec(self.code, module.__dict__)
+
+
+class VirtualFileFinder(importlib.abc.MetaPathFinder, importlib.abc.Loader):
+    def __init__(self, files: dict[str, str], namespace: str):
+        self.files = files
+        self.namespace = namespace
+
+    def find_spec(self, fullname, path, target=None):
+        # Do the namespacing on the fly to avoid having to copy the file dict
+        prefixed_name = fullname if fullname.startswith(self.namespace) else f"{self.namespace}.{fullname}"
+
+        key_name = "__init__" if fullname == self.namespace else fullname.replace(f"{self.namespace}.", "")
+
+        files_key = f"{key_name.replace('.', '/')}.py"
+        if not self.files.get(files_key):
+            files_key = f"{key_name.replace('.', '/')}/__init__.py"
+
+        file = self.files.get(files_key)
+        is_package = "__init__" in files_key
+
+        if file:
+            return importlib.machinery.ModuleSpec(
+                prefixed_name,
+                VirtualFileLoader(file, is_package),
+                origin=prefixed_name,
+                is_package=is_package,
+            )
+        return None