vellum-ai 0.12.0__tar.gz → 0.12.2__tar.gz

{vellum_ai-0.12.0 → vellum_ai-0.12.2}/PKG-INFO

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

{vellum_ai-0.12.0 → vellum_ai-0.12.2}/ee/vellum_cli/push.py

@@ -80,6 +80,9 @@ def push_command(
         module_dir = workflow_config.module.replace(".", os.path.sep)
         for root, _, files in os.walk(module_dir):
             for filename in files:
+                if not filename.endswith(".py"):
+                    continue
+
                 file_path = os.path.join(root, filename)
                 # Get path relative to module_dir for tar archive
                 relative_path = os.path.relpath(file_path, module_dir)

{vellum_ai-0.12.0 → vellum_ai-0.12.2}/ee/vellum_ee/workflows/display/nodes/base_node_vellum_display.py

@@ -1,6 +1,7 @@
 from uuid import UUID
 from typing import ClassVar, Dict, Optional
 
+from vellum.workflows.nodes.utils import get_unadorned_node
 from vellum.workflows.ports import Port
 from vellum.workflows.types.generics import NodeType
 from vellum.workflows.utils.uuids import uuid4_from_hash
@@ -40,6 +41,8 @@ class BaseNodeVellumDisplay(BaseNodeDisplay[NodeType]):
         return self.get_target_handle_id()
 
     def get_source_handle_id(self, port_displays: Dict[Port, PortDisplay]) -> UUID:
-        default_port = self._node.Ports.default
+        unadorned_node = get_unadorned_node(self._node)
+        default_port = unadorned_node.Ports.default
+
         default_port_display = port_displays[default_port]
         return default_port_display.id

{vellum_ai-0.12.0 → vellum_ai-0.12.2}/ee/vellum_ee/workflows/display/nodes/vellum/inline_prompt_node.py

@@ -1,9 +1,8 @@
 from uuid import UUID
-from typing import ClassVar, Dict, Generic, List, Optional, Tuple, Type, TypeVar, Union, cast
+from typing import ClassVar, Dict, Generic, List, Optional, Tuple, Type, TypeVar, Union
 
 from vellum import PromptBlock, RichTextChildBlock, VellumVariable
 from vellum.workflows.nodes import InlinePromptNode
-from vellum.workflows.references import OutputReference
 from vellum.workflows.types.core import JsonObject
 from vellum.workflows.utils.uuids import uuid4_from_hash
 from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
@@ -30,8 +29,8 @@ class BaseInlinePromptNodeDisplay(BaseNodeVellumDisplay[_InlinePromptNodeType],
         node_inputs, prompt_inputs = self._generate_node_and_prompt_inputs(node_id, node, display_context)
         input_variable_id_by_name = {prompt_input.key: prompt_input.id for prompt_input in prompt_inputs}
 
-        _, output_display = display_context.node_output_displays[cast(OutputReference, node.Outputs.text)]
-        _, array_display = display_context.node_output_displays[cast(OutputReference, node.Outputs.results)]
+        _, output_display = display_context.node_output_displays[node.Outputs.text]
+        _, array_display = display_context.node_output_displays[node.Outputs.results]
         node_blocks = raise_if_descriptor(node.blocks)
 
         return {

{vellum_ai-0.12.0 → vellum_ai-0.12.2}/ee/vellum_ee/workflows/display/nodes/vellum/try_node.py

@@ -1,11 +1,13 @@
 from uuid import UUID
-from typing import Any, ClassVar, Generic, Optional, TypeVar
+from typing import Any, Callable, ClassVar, Generic, Optional, Type, TypeVar, cast
 
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.nodes.core.try_node.node import TryNode
 from vellum.workflows.nodes.utils import ADORNMENT_MODULE_NAME, get_wrapped_node
 from vellum.workflows.types.core import JsonObject
+from vellum.workflows.types.utils import get_original_base
 from vellum.workflows.utils.uuids import uuid4_from_hash
+from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
 from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
 from vellum_ee.workflows.display.nodes.get_node_display_class import get_node_display_class
 from vellum_ee.workflows.display.nodes.utils import raise_if_descriptor
@@ -54,3 +56,43 @@ class BaseTryNodeDisplay(BaseNodeVellumDisplay[_TryNodeType], Generic[_TryNodeTy
                 serialized_node_definition["name"] = node.__name__
 
         return serialized_node
+
+    @classmethod
+    def wrap(cls, error_output_id: Optional[UUID] = None) -> Callable[..., Type["BaseTryNodeDisplay"]]:
+        _error_output_id = error_output_id
+
+        NodeDisplayType = TypeVar("NodeDisplayType", bound=BaseNodeDisplay)
+
+        def decorator(inner_cls: Type[NodeDisplayType]) -> Type[NodeDisplayType]:
+            node_class = inner_cls.infer_node_class()
+            wrapped_node_class = cast(Type[BaseNode], node_class.__wrapped_node__)
+
+            # Mypy gets mad about dynamic parameter types like this, but it's fine
+            class TryNodeDisplay(BaseTryNodeDisplay[node_class]):  # type: ignore[valid-type]
+                error_output_id = _error_output_id
+
+            setattr(inner_cls, "__adorned_by__", TryNodeDisplay)
+
+            # We must edit the node display class to use __wrapped_node__ everywhere it
+            # references the adorned node class, which is three places:
+
+            # 1. The node display class' parameterized type
+            original_base_node_display = get_original_base(inner_cls)
+            original_base_node_display.__args__ = (wrapped_node_class,)
+            inner_cls._node_display_registry[wrapped_node_class] = inner_cls
+
+            # 2. The node display class' output displays
+            old_outputs = list(inner_cls.output_display.keys())
+            for old_output in old_outputs:
+                new_output = getattr(wrapped_node_class.Outputs, old_output.name)
+                inner_cls.output_display[new_output] = inner_cls.output_display.pop(old_output)
+
+            # 3. The node display class' port displays
+            old_ports = list(inner_cls.port_displays.keys())
+            for old_port in old_ports:
+                new_port = getattr(wrapped_node_class.Ports, old_port.name)
+                inner_cls.port_displays[new_port] = inner_cls.port_displays.pop(old_port)
+
+            return inner_cls
+
+        return decorator

{vellum_ai-0.12.0 → vellum_ai-0.12.2}/ee/vellum_ee/workflows/display/workflows/vellum_workflow_display.py

@@ -6,7 +6,7 @@ from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.edges import Edge
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.displayable.final_output_node import FinalOutputNode
-from vellum.workflows.nodes.utils import get_wrapped_node, has_wrapped_node
+from vellum.workflows.nodes.utils import get_unadorned_node, get_unadorned_port, get_wrapped_node, has_wrapped_node
 from vellum.workflows.ports import Port
 from vellum.workflows.references import WorkflowInputReference
 from vellum.workflows.references.output import OutputReference
@@ -352,17 +352,12 @@ class VellumWorkflowDisplay(
         port_displays: Dict[Port, PortDisplay],
         overrides: Optional[EdgeVellumDisplayOverrides] = None,
     ) -> EdgeVellumDisplay:
-        source_node = edge.from_port.node_class
-        target_node = edge.to_node
-
-        if has_wrapped_node(source_node):
-            source_node = get_wrapped_node(source_node)
-
-        if has_wrapped_node(target_node):
-            target_node = get_wrapped_node(target_node)
+        source_node = get_unadorned_node(edge.from_port.node_class)
+        target_node = get_unadorned_node(edge.to_node)
 
         source_node_id = node_displays[source_node].node_id
-        source_handle_id = port_displays[edge.from_port].id
+        from_port = get_unadorned_port(edge.from_port)
+        source_handle_id = port_displays[from_port].id
 
         target_node_display = node_displays[target_node]
         target_node_id = target_node_display.node_id

{vellum_ai-0.12.0 → vellum_ai-0.12.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "vellum-ai"
-version = "0.12.0"
+version = "0.12.2"
 description = ""
 readme = "README.md"
 authors = []

{vellum_ai-0.12.0 → vellum_ai-0.12.2}/src/vellum/client/core/client_wrapper.py

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

{vellum_ai-0.12.0 → vellum_ai-0.12.2}/src/vellum/workflows/events/node.py

@@ -10,7 +10,7 @@ from vellum.workflows.ports.port import Port
 from vellum.workflows.references.node import NodeReference
 from vellum.workflows.types.generics import OutputsType
 
-from .types import BaseEvent, default_serializer, serialize_type_encoder
+from .types import BaseEvent, default_serializer, serialize_type_encoder_with_id
 
 if TYPE_CHECKING:
     from vellum.workflows.nodes.bases import BaseNode
@@ -21,7 +21,7 @@ class _BaseNodeExecutionBody(UniversalBaseModel):
 
     @field_serializer("node_definition")
     def serialize_node_definition(self, node_definition: Type, _info: Any) -> Dict[str, Any]:
-        return serialize_type_encoder(node_definition)
+        return serialize_type_encoder_with_id(node_definition)
 
     # Couldn't get this to work with model_config.exclude_none or model_config.exclude_defaults
     # so we're excluding null invoked_ports manually here for now

{vellum_ai-0.12.0 → vellum_ai-0.12.2}/src/vellum/workflows/events/tests/test_event.py

@@ -28,6 +28,7 @@ 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.base import BaseState
+from vellum.workflows.utils.uuids import uuid4_from_hash
 from vellum.workflows.workflows.base import BaseWorkflow
 
 
@@ -48,6 +49,8 @@ class MockWorkflow(BaseWorkflow[MockInputs, BaseState]):
 
 name_parts = __name__.split(".")
 module_root = name_parts[: name_parts.index("events")]
+mock_workflow_uuid = str(uuid4_from_hash(MockWorkflow.__qualname__))
+mock_node_uuid = str(uuid4_from_hash(MockNode.__qualname__))
 
 
 @pytest.mark.parametrize(
@@ -73,6 +76,7 @@ module_root = name_parts[: name_parts.index("events")]
                 "name": "workflow.execution.initiated",
                 "body": {
                     "workflow_definition": {
+                        "id": mock_workflow_uuid,
                         "name": "MockWorkflow",
                         "module": module_root + ["events", "tests", "test_event"],
                     },
@@ -113,6 +117,7 @@ module_root = name_parts[: name_parts.index("events")]
                 "name": "node.execution.initiated",
                 "body": {
                     "node_definition": {
+                        "id": mock_node_uuid,
                         "name": "MockNode",
                         "module": module_root + ["events", "tests", "test_event"],
                     },
@@ -122,11 +127,13 @@ module_root = name_parts[: name_parts.index("events")]
                 },
                 "parent": {
                     "node_definition": {
+                        "id": mock_node_uuid,
                         "name": "MockNode",
                         "module": module_root + ["events", "tests", "test_event"],
                     },
                     "parent": {
                         "workflow_definition": {
+                            "id": mock_workflow_uuid,
                             "name": "MockWorkflow",
                             "module": module_root + ["events", "tests", "test_event"],
                         },
@@ -162,6 +169,7 @@ module_root = name_parts[: name_parts.index("events")]
                 "name": "workflow.execution.streaming",
                 "body": {
                     "workflow_definition": {
+                        "id": mock_workflow_uuid,
                         "name": "MockWorkflow",
                         "module": module_root + ["events", "tests", "test_event"],
                     },
@@ -195,6 +203,7 @@ module_root = name_parts[: name_parts.index("events")]
                 "name": "workflow.execution.fulfilled",
                 "body": {
                     "workflow_definition": {
+                        "id": mock_workflow_uuid,
                         "name": "MockWorkflow",
                         "module": module_root + ["events", "tests", "test_event"],
                     },
@@ -228,6 +237,7 @@ module_root = name_parts[: name_parts.index("events")]
                 "name": "workflow.execution.rejected",
                 "body": {
                     "workflow_definition": {
+                        "id": mock_workflow_uuid,
                         "name": "MockWorkflow",
                         "module": module_root + ["events", "tests", "test_event"],
                     },
@@ -262,6 +272,7 @@ module_root = name_parts[: name_parts.index("events")]
                 "name": "node.execution.streaming",
                 "body": {
                     "node_definition": {
+                        "id": mock_node_uuid,
                         "name": "MockNode",
                         "module": module_root + ["events", "tests", "test_event"],
                     },
@@ -296,6 +307,7 @@ module_root = name_parts[: name_parts.index("events")]
                 "name": "node.execution.fulfilled",
                 "body": {
                     "node_definition": {
+                        "id": mock_node_uuid,
                         "name": "MockNode",
                         "module": module_root + ["events", "tests", "test_event"],
                     },

{vellum_ai-0.12.0 → vellum_ai-0.12.2}/src/vellum/workflows/events/types.py

@@ -28,6 +28,15 @@ def serialize_type_encoder(obj: type) -> Dict[str, Any]:
     }
 
 
+def serialize_type_encoder_with_id(obj: type) -> Dict[str, Any]:
+    if not hasattr(obj, "__id__"):
+        raise AttributeError(f"The object of type '{type(obj).__name__}' must have an '__id__' attribute.")
+    return {
+        "id": getattr(obj, "__id__"),
+        **serialize_type_encoder(obj),
+    }
+
+
 def default_serializer(obj: Any) -> Any:
     return json.loads(
         json.dumps(
@@ -38,17 +47,18 @@ def default_serializer(obj: Any) -> Any:
 
 
 class CodeResourceDefinition(UniversalBaseModel):
+    id: UUID
     name: str
     module: List[str]
 
     @staticmethod
     def encode(obj: type) -> "CodeResourceDefinition":
-        return CodeResourceDefinition(**serialize_type_encoder(obj))
+        return CodeResourceDefinition(**serialize_type_encoder_with_id(obj))
 
 
 VellumCodeResourceDefinition = Annotated[
     CodeResourceDefinition,
-    BeforeValidator(lambda d: (d if type(d) is dict else serialize_type_encoder(d))),
+    BeforeValidator(lambda d: (d if type(d) is dict else serialize_type_encoder_with_id(d))),
 ]
 
 

{vellum_ai-0.12.0 → vellum_ai-0.12.2}/src/vellum/workflows/events/workflow.py

@@ -16,7 +16,7 @@ from .node import (
     NodeExecutionResumedEvent,
     NodeExecutionStreamingEvent,
 )
-from .types import BaseEvent, default_serializer, serialize_type_encoder
+from .types import BaseEvent, default_serializer, serialize_type_encoder_with_id
 
 if TYPE_CHECKING:
     from vellum.workflows.workflows.base import BaseWorkflow
@@ -27,7 +27,7 @@ class _BaseWorkflowExecutionBody(UniversalBaseModel):
 
     @field_serializer("workflow_definition")
     def serialize_workflow_definition(self, workflow_definition: Type, _info: Any) -> Dict[str, Any]:
-        return serialize_type_encoder(workflow_definition)
+        return serialize_type_encoder_with_id(workflow_definition)
 
 
 class _BaseWorkflowEvent(BaseEvent):

{vellum_ai-0.12.0 → vellum_ai-0.12.2}/src/vellum/workflows/nodes/utils.py

@@ -2,11 +2,30 @@ from functools import cache
 from typing import Type
 
 from vellum.workflows.nodes import BaseNode
+from vellum.workflows.ports.port import Port
 from vellum.workflows.types.generics import NodeType
 
 ADORNMENT_MODULE_NAME = "<adornment>"
 
 
+@cache
+def get_unadorned_node(node: Type[BaseNode]) -> Type[BaseNode]:
+    wrapped_node = getattr(node, "__wrapped_node__", None)
+    if wrapped_node is not None:
+        return get_unadorned_node(wrapped_node)
+
+    return node
+
+
+@cache
+def get_unadorned_port(port: Port) -> Port:
+    unadorned_node = get_unadorned_node(port.node_class)
+    if unadorned_node == port.node_class:
+        return port
+
+    return getattr(unadorned_node.Ports, port.name)
+
+
 @cache
 def get_wrapped_node(node: Type[NodeType]) -> Type[BaseNode]:
     wrapped_node = getattr(node, "__wrapped_node__", None)

{vellum_ai-0.12.0 → vellum_ai-0.12.2}/src/vellum/workflows/workflows/base.py

@@ -4,6 +4,7 @@ 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()
@@ -11,7 +12,7 @@ load_runtime_plugins()
 from datetime import datetime
 from functools import lru_cache
 from threading import Event as ThreadingEvent
-from uuid import uuid4
+from uuid import UUID, uuid4
 from typing import (
     Any,
     Callable,
@@ -85,13 +86,17 @@ class _BaseWorkflowMeta(type):
         if "graph" not in dct:
             dct["graph"] = set()
 
-        return super().__new__(mcs, name, bases, dct)
+        cls = super().__new__(mcs, name, bases, dct)
+        workflow_class = cast(Type["BaseWorkflow"], cls)
+        workflow_class.__id__ = uuid4_from_hash(workflow_class.__qualname__)
+        return workflow_class
 
 
 GraphAttribute = Union[Type[BaseNode], Graph, Set[Type[BaseNode]], Set[Graph]]
 
 
 class BaseWorkflow(Generic[WorkflowInputsType, StateType], metaclass=_BaseWorkflowMeta):
+    __id__: UUID = uuid4_from_hash(__qualname__)
     graph: ClassVar[GraphAttribute]
     emitters: List[BaseWorkflowEmitter]
     resolvers: List[BaseWorkflowResolver]

{vellum_ai-0.12.0 → vellum_ai-0.12.2}/src/vellum/workflows/workflows/event_filters.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING, Type
 
-from vellum.workflows.events.types import CodeResourceDefinition
+from vellum.workflows.events.types import VellumCodeResourceDefinition
 
 if TYPE_CHECKING:
     from vellum.workflows.events.workflow import WorkflowEvent
@@ -47,7 +47,7 @@ def root_workflow_event_filter(workflow_definition: Type["BaseWorkflow"], event:
         return False
 
     event_parent_definition = event.parent.workflow_definition
-    current_workflow_definition = CodeResourceDefinition.encode(workflow_definition)
+    current_workflow_definition = VellumCodeResourceDefinition.encode(workflow_definition)
 
     return event_parent_definition.model_dump() == current_workflow_definition.model_dump()