vellum-ai 0.10.8__tar.gz → 0.10.9__tar.gz

{vellum_ai-0.10.8 → vellum_ai-0.10.9}/PKG-INFO

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

{vellum_ai-0.10.8 → vellum_ai-0.10.9}/ee/vellum_ee/workflows/display/nodes/vellum/__init__.py

@@ -1,6 +1,7 @@
 from .api_node import BaseAPINodeDisplay
 from .code_execution_node import BaseCodeExecutionNodeDisplay
 from .conditional_node import BaseConditionalNodeDisplay
+from .error_node import BaseErrorNodeDisplay
 from .final_output_node import BaseFinalOutputNodeDisplay
 from .guardrail_node import BaseGuardrailNodeDisplay
 from .inline_prompt_node import BaseInlinePromptNodeDisplay
@@ -16,19 +17,20 @@ from .try_node import BaseTryNodeDisplay
 
 # All node display classes must be imported here to be registered in BaseNodeDisplay's node display registry
 __all__ = [
+    "BaseAPINodeDisplay",
     "BaseCodeExecutionNodeDisplay",
     "BaseConditionalNodeDisplay",
+    "BaseErrorNodeDisplay",
+    "BaseFinalOutputNodeDisplay",
     "BaseGuardrailNodeDisplay",
     "BaseInlinePromptNodeDisplay",
     "BaseInlineSubworkflowNodeDisplay",
-    "BaseAPINodeDisplay",
     "BaseMapNodeDisplay",
     "BaseMergeNodeDisplay",
     "BaseNoteNodeDisplay",
+    "BasePromptDeploymentNodeDisplay",
     "BaseSearchNodeDisplay",
     "BaseSubworkflowDeploymentNodeDisplay",
     "BaseTemplatingNodeDisplay",
-    "BasePromptDeploymentNodeDisplay",
-    "BaseFinalOutputNodeDisplay",
-    "BaseTryNodeDisplay",
+    "BaseTryNodeDisplay"
 ]

vellum_ai-0.10.9/ee/vellum_ee/workflows/display/nodes/vellum/error_node.py

@@ -0,0 +1,49 @@
+from uuid import UUID
+from typing import Any, ClassVar, Dict, Generic, Optional, TypeVar
+
+from vellum.workflows.nodes import ErrorNode
+from vellum.workflows.types.core import EntityInputsInterface, Json, JsonObject
+from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
+from vellum_ee.workflows.display.nodes.vellum.utils import create_node_input
+from vellum_ee.workflows.display.types import WorkflowDisplayContext
+
+_ErrorNodeType = TypeVar("_ErrorNodeType", bound=ErrorNode)
+
+class BaseErrorNodeDisplay(BaseNodeVellumDisplay[_ErrorNodeType], Generic[_ErrorNodeType]):
+    error_output_id: ClassVar[Optional[UUID]] = None
+    error_inputs_by_name: ClassVar[Dict[str, Any]] = {}
+    name: ClassVar[str] = "error-node"
+
+    def serialize(
+            self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
+    ) -> JsonObject:
+        node = self._node
+        node_id = self.node_id
+        error_source_input_id = self.node_input_ids_by_name.get("error_source_input_id")
+
+        node_inputs = [
+            create_node_input(
+                node_id=node_id,
+                input_name=variable_name,
+                value=variable_value,
+                display_context=display_context,
+                input_id=self.node_input_ids_by_name.get(variable_name),
+            )
+            for variable_name, variable_value in self.error_inputs_by_name.items()
+        ]
+
+        return {
+            "id": str(node_id),
+            "type": "ERROR",
+            "inputs": [node_input.dict() for node_input in node_inputs],
+            "data": {
+                "name": self.name,
+                "label": self.label,
+                "source_handle_id": str(self.get_source_handle_id(display_context.port_displays)),
+                "target_handle_id": str(self.get_target_handle_id()),
+                "error_source_input_id": str(error_source_input_id),
+                "error_output_id": str(self.error_output_id),
+            },
+            "display_data": self.get_display_data().dict(),
+            "definition": self.get_definition().dict(),
+        }

vellum_ai-0.10.9/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_error_node_serialization.py

@@ -0,0 +1,203 @@
+from unittest import mock
+
+from deepdiff import DeepDiff
+
+from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
+from vellum_ee.workflows.display.workflows import VellumWorkflowDisplay
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+from tests.workflows.basic_error_node.workflow import BasicErrorNodeWorkflow
+
+
+def test_serialize_workflow():
+    # GIVEN a Workflow with an error node
+    # WHEN we serialize it
+    workflow_display = get_workflow_display(
+        base_display_class=VellumWorkflowDisplay, workflow_class=BasicErrorNodeWorkflow
+    )
+
+    # TODO: Support serialization of BaseNode
+    # https://app.shortcut.com/vellum/story/4871/support-serialization-of-base-node
+    with mock.patch.object(BaseNodeVellumDisplay, "serialize") as mocked_serialize:
+        mocked_serialize.return_value = {"type": "MOCKED"}
+        serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN we should get a serialized representation of the Workflow
+    assert serialized_workflow.keys() == {
+        "workflow_raw_data",
+        "input_variables",
+        "output_variables",
+    }
+
+    # AND its input variables should be what we expect
+    input_variables = serialized_workflow["input_variables"]
+    assert len(input_variables) == 1
+    assert not DeepDiff(
+        [
+            {
+                "id": "5d9edd44-b35b-4bad-ad51-ccdfe8185ff5",
+                "key": "threshold",
+                "type": "NUMBER",
+                "default": None,
+                "required": True,
+                "extensions": {"color": None},
+            }
+        ],
+        input_variables,
+        ignore_order=True,
+    )
+
+    # AND its output variables should be what we expect
+    output_variables = serialized_workflow["output_variables"]
+    assert len(output_variables) == 1
+    assert not DeepDiff(
+        [
+            {
+                "id": "04c5c6be-f5e1-41b8-b668-39e179790d9e",
+                "key": "final_value",
+                "type": "NUMBER",
+            }
+        ],
+        output_variables,
+        ignore_order=True,
+    )
+
+    # AND its raw data should be what we expect
+    workflow_raw_data = serialized_workflow["workflow_raw_data"]
+    assert workflow_raw_data.keys() == {"edges", "nodes", "display_data", "definition"}
+    assert len(workflow_raw_data["edges"]) == 4
+    assert len(workflow_raw_data["nodes"]) == 5
+
+    # AND each node should be serialized correctly
+    entrypoint_node = workflow_raw_data["nodes"][0]
+    assert entrypoint_node == {
+        "id": "10e90662-e998-421d-a5c9-ec16e37a8de1",
+        "type": "ENTRYPOINT",
+        "inputs": [],
+        "data": {
+            "label": "Entrypoint Node",
+            "source_handle_id": "7d86498b-84ed-4feb-8e62-2188058c2c4e",
+        },
+        "display_data": {"position": {"x": 0.0, "y": 0.0}},
+        "definition": {
+            "name": "BaseNode",
+            "module": ["vellum", "workflows", "nodes", "bases", "base"],
+            "bases": [],
+        },
+    }
+
+    error_node, error_index = next(
+        (
+            (node, index)
+            for index, node in enumerate(workflow_raw_data["nodes"])
+            if node.get("data", {}).get("label") == "Fail Node"
+        ),
+        (None, None),
+    )
+    assert not DeepDiff(
+        {
+            "id": "5cf9c5e3-0eae-4daf-8d73-8b9536258eb9",
+            "type": "ERROR",
+            "inputs": [],
+            "data": {
+                "name": "error-node",
+                "label": "Fail Node",
+                "source_handle_id": "ca17d318-a0f5-4f7c-be6c-59c9dc1dd7ed",
+                "target_handle_id": "70c19f1c-309c-4a5d-ba65-664c0bb2fedf",
+                "error_source_input_id": "None",
+                "error_output_id": "None",
+            },
+            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+            "definition": {
+                "name": "FailNode",
+                "module": ["tests", "workflows", "basic_error_node", "workflow"],
+                "bases": [
+                    {
+                        "name": "ErrorNode",
+                        "module": [
+                            "vellum",
+                            "workflows",
+                            "nodes",
+                            "core",
+                            "error_node",
+                            "node",
+                        ],
+                    }
+                ],
+            },
+        },
+        error_node,
+        ignore_order=True,
+    )
+
+    mocked_base_nodes = [
+        node
+        for i, node in enumerate(workflow_raw_data["nodes"])
+        if i != error_index and i != 0 and i != len(workflow_raw_data["nodes"]) - 1
+    ]
+
+    assert not DeepDiff(
+        [
+            {
+                "type": "MOCKED",
+            },
+            {
+                "type": "MOCKED",
+            },
+        ],
+        mocked_base_nodes,
+    )
+
+    terminal_node = workflow_raw_data["nodes"][-1]
+    assert not DeepDiff(
+        {
+            "id": "e5fff999-80c7-4cbc-9d99-06c653f3ec77",
+            "type": "TERMINAL",
+            "data": {
+                "label": "Final Output",
+                "name": "final_value",
+                "target_handle_id": "b070e9bc-e9b7-46d3-8f5b-0b646bd25cf0",
+                "output_id": "04c5c6be-f5e1-41b8-b668-39e179790d9e",
+                "output_type": "NUMBER",
+                "node_input_id": "39ff42c9-eae8-432e-ad41-e208fba77027",
+            },
+            "inputs": [
+                {
+                    "id": "39ff42c9-eae8-432e-ad41-e208fba77027",
+                    "key": "node_input",
+                    "value": {
+                        "rules": [
+                            {
+                                "type": "NODE_OUTPUT",
+                                "data": {
+                                    "node_id": "1eee9b4e-531f-45f2-a4b9-42207fac2c33",
+                                    "output_id": "c6b017a4-25e9-4296-8d81-6aa4b3dad171",
+                                },
+                            }
+                        ],
+                        "combinator": "OR",
+                    },
+                }
+            ],
+            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+            "definition": {
+                "name": "FinalOutputNode",
+                "module": [
+                    "vellum",
+                    "workflows",
+                    "nodes",
+                    "displayable",
+                    "final_output_node",
+                    "node",
+                ],
+                "bases": [
+                    {
+                        "name": "BaseNode",
+                        "module": ["vellum", "workflows", "nodes", "bases", "base"],
+                        "bases": [],
+                    }
+                ],
+            },
+        },
+        terminal_node,
+    )

{vellum_ai-0.10.8 → vellum_ai-0.10.9}/pyproject.toml

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

{vellum_ai-0.10.8 → vellum_ai-0.10.9}/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.10.8",
+            "X-Fern-SDK-Version": "0.10.9",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

{vellum_ai-0.10.8 → vellum_ai-0.10.9}/src/vellum/client/types/logical_operator.py

@@ -24,6 +24,8 @@ LogicalOperator = typing.Union[
         "notBetween",
         "blank",
         "notBlank",
+        "coalesce",
+        "accessField",
     ],
     typing.Any,
 ]

{vellum_ai-0.10.8 → vellum_ai-0.10.9}/src/vellum/workflows/descriptors/utils.py

@@ -5,6 +5,7 @@ from typing import Any, Dict, Optional, Sequence, Set, TypeVar, Union, cast, ove
 
 from pydantic import BaseModel
 
+from vellum.workflows.constants import UNDEF
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.state.base import BaseState
 
@@ -88,3 +89,29 @@ def resolve_value(
         return cast(_T, set_value)
 
     return value
+
+
+def is_unresolved(value: Any) -> bool:
+    """
+    Recursively checks if a value has an unresolved value, represented by UNDEF.
+    """
+
+    if value is UNDEF:
+        return True
+
+    if dataclasses.is_dataclass(value):
+        return any(is_unresolved(getattr(value, field.name)) for field in dataclasses.fields(value))
+
+    if isinstance(value, BaseModel):
+        return any(is_unresolved(getattr(value, key)) for key in value.model_fields.keys())
+
+    if isinstance(value, Mapping):
+        return any(is_unresolved(item) for item in value.values())
+
+    if isinstance(value, Sequence):
+        return any(is_unresolved(item) for item in value)
+
+    if isinstance(value, Set):
+        return any(is_unresolved(item) for item in value)
+
+    return False

{vellum_ai-0.10.8 → vellum_ai-0.10.9}/src/vellum/workflows/events/__init__.py

@@ -5,7 +5,6 @@ from .node import (
     NodeExecutionRejectedEvent,
     NodeExecutionStreamingEvent,
 )
-from .types import WorkflowEventType
 from .workflow import (
     WorkflowEvent,
     WorkflowEventStream,
@@ -27,5 +26,4 @@ __all__ = [
     "WorkflowExecutionStreamingEvent",
     "WorkflowEvent",
     "WorkflowEventStream",
-    "WorkflowEventType",
 ]

{vellum_ai-0.10.8 → vellum_ai-0.10.9}/src/vellum/workflows/events/tests/test_event.py

@@ -100,7 +100,8 @@ module_root = name_parts[: name_parts.index("events")]
                     node_definition=MockNode,
                     span_id=UUID("123e4567-e89b-12d3-a456-426614174000"),
                     parent=WorkflowParentContext(
-                        workflow_definition=MockWorkflow, span_id=UUID("123e4567-e89b-12d3-a456-426614174000")
+                        workflow_definition=MockWorkflow,
+                        span_id=UUID("123e4567-e89b-12d3-a456-426614174000"),
                     ),
                 ),
             ),

{vellum_ai-0.10.8 → vellum_ai-0.10.9}/src/vellum/workflows/events/types.py

@@ -2,23 +2,14 @@ from datetime import datetime
 from enum import Enum
 import json
 from uuid import UUID, uuid4
-from typing import TYPE_CHECKING, Any, Dict, Literal, Optional, Type, Union
+from typing import Annotated, Any, Dict, List, Literal, Optional, Union
 
-from pydantic import Field, field_serializer
+from pydantic import BeforeValidator, Field
 
 from vellum.core.pydantic_utilities import UniversalBaseModel
 from vellum.workflows.state.encoder import DefaultStateEncoder
 from vellum.workflows.types.utils import datetime_now
 
-if TYPE_CHECKING:
-    from vellum.workflows.nodes.bases.base import BaseNode
-    from vellum.workflows.workflows.base import BaseWorkflow
-
-
-class WorkflowEventType(Enum):
-    NODE = "NODE"
-    WORKFLOW = "WORKFLOW"
-
 
 def default_datetime_factory() -> datetime:
     """
@@ -47,9 +38,25 @@ def default_serializer(obj: Any) -> Any:
     )
 
 
+class CodeResourceDefinition(UniversalBaseModel):
+    name: str
+    module: List[str]
+
+    @staticmethod
+    def encode(obj: type) -> "CodeResourceDefinition":
+        return CodeResourceDefinition(**serialize_type_encoder(obj))
+
+
+VellumCodeResourceDefinition = Annotated[
+    CodeResourceDefinition,
+    BeforeValidator(lambda d: (d if type(d) is dict else serialize_type_encoder(d))),
+]
+
+
 class BaseParentContext(UniversalBaseModel):
     span_id: UUID
-    parent: Optional['ParentContext'] = None
+    parent: Optional["ParentContext"] = None
+    type: str
 
 
 class BaseDeploymentParentContext(BaseParentContext):
@@ -73,29 +80,28 @@ class PromptDeploymentParentContext(BaseDeploymentParentContext):
 
 class NodeParentContext(BaseParentContext):
     type: Literal["WORKFLOW_NODE"] = "WORKFLOW_NODE"
-    node_definition: Type['BaseNode']
-
-    @field_serializer("node_definition")
-    def serialize_node_definition(self, definition: Type, _info: Any) -> Dict[str, Any]:
-        return serialize_type_encoder(definition)
+    node_definition: VellumCodeResourceDefinition
 
 
 class WorkflowParentContext(BaseParentContext):
     type: Literal["WORKFLOW"] = "WORKFLOW"
-    workflow_definition: Type['BaseWorkflow']
-
-    @field_serializer("workflow_definition")
-    def serialize_workflow_definition(self, definition: Type, _info: Any) -> Dict[str, Any]:
-        return serialize_type_encoder(definition)
-
-
-ParentContext = Union[
-    NodeParentContext,
-    WorkflowParentContext,
-    PromptDeploymentParentContext,
-    WorkflowDeploymentParentContext,
+    workflow_definition: VellumCodeResourceDefinition
+
+
+# Define the discriminated union
+ParentContext = Annotated[
+    Union[
+        WorkflowParentContext,
+        NodeParentContext,
+        WorkflowDeploymentParentContext,
+        PromptDeploymentParentContext,
+    ],
+    Field(discriminator="type"),
 ]
 
+# Update the forward references
+BaseParentContext.model_rebuild()
+
 
 class BaseEvent(UniversalBaseModel):
     id: UUID = Field(default_factory=uuid4)

{vellum_ai-0.10.8 → vellum_ai-0.10.9}/src/vellum/workflows/events/workflow.py

@@ -3,7 +3,6 @@ from typing import TYPE_CHECKING, Any, Dict, Generator, Generic, Iterable, Liter
 from pydantic import field_serializer
 
 from vellum.core.pydantic_utilities import UniversalBaseModel
-
 from vellum.workflows.errors import VellumError
 from vellum.workflows.outputs.base import BaseOutput
 from vellum.workflows.references import ExternalInputReference
@@ -31,6 +30,14 @@ class _BaseWorkflowExecutionBody(UniversalBaseModel):
         return serialize_type_encoder(workflow_definition)
 
 
+class _BaseWorkflowEvent(BaseEvent):
+    body: _BaseWorkflowExecutionBody
+
+    @property
+    def workflow_definition(self) -> Type["BaseWorkflow"]:
+        return self.body.workflow_definition
+
+
 class WorkflowExecutionInitiatedBody(_BaseWorkflowExecutionBody, Generic[WorkflowInputsType]):
     inputs: WorkflowInputsType
 
@@ -39,7 +46,7 @@ class WorkflowExecutionInitiatedBody(_BaseWorkflowExecutionBody, Generic[Workflo
         return default_serializer(inputs)
 
 
-class WorkflowExecutionInitiatedEvent(BaseEvent, Generic[WorkflowInputsType]):
+class WorkflowExecutionInitiatedEvent(_BaseWorkflowEvent, Generic[WorkflowInputsType]):
     name: Literal["workflow.execution.initiated"] = "workflow.execution.initiated"
     body: WorkflowExecutionInitiatedBody[WorkflowInputsType]
 
@@ -56,7 +63,7 @@ class WorkflowExecutionStreamingBody(_BaseWorkflowExecutionBody):
         return default_serializer(output)
 
 
-class WorkflowExecutionStreamingEvent(BaseEvent):
+class WorkflowExecutionStreamingEvent(_BaseWorkflowEvent):
     name: Literal["workflow.execution.streaming"] = "workflow.execution.streaming"
     body: WorkflowExecutionStreamingBody
 
@@ -73,7 +80,7 @@ class WorkflowExecutionFulfilledBody(_BaseWorkflowExecutionBody, Generic[Outputs
         return default_serializer(outputs)
 
 
-class WorkflowExecutionFulfilledEvent(BaseEvent, Generic[OutputsType]):
+class WorkflowExecutionFulfilledEvent(_BaseWorkflowEvent, Generic[OutputsType]):
     name: Literal["workflow.execution.fulfilled"] = "workflow.execution.fulfilled"
     body: WorkflowExecutionFulfilledBody[OutputsType]
 
@@ -86,7 +93,7 @@ class WorkflowExecutionRejectedBody(_BaseWorkflowExecutionBody):
     error: VellumError
 
 
-class WorkflowExecutionRejectedEvent(BaseEvent):
+class WorkflowExecutionRejectedEvent(_BaseWorkflowEvent):
     name: Literal["workflow.execution.rejected"] = "workflow.execution.rejected"
     body: WorkflowExecutionRejectedBody
 
@@ -99,7 +106,7 @@ class WorkflowExecutionPausedBody(_BaseWorkflowExecutionBody):
     external_inputs: Iterable[ExternalInputReference]
 
 
-class WorkflowExecutionPausedEvent(BaseEvent):
+class WorkflowExecutionPausedEvent(_BaseWorkflowEvent):
     name: Literal["workflow.execution.paused"] = "workflow.execution.paused"
     body: WorkflowExecutionPausedBody
 
@@ -112,7 +119,7 @@ class WorkflowExecutionResumedBody(_BaseWorkflowExecutionBody):
     pass
 
 
-class WorkflowExecutionResumedEvent(BaseEvent):
+class WorkflowExecutionResumedEvent(_BaseWorkflowEvent):
     name: Literal["workflow.execution.resumed"] = "workflow.execution.resumed"
     body: WorkflowExecutionResumedBody