vellum-ai 1.3.11__tar.gz → 1.4.1__tar.gz

{vellum_ai-1.3.11 → vellum_ai-1.4.1}/PKG-INFO

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

{vellum_ai-1.3.11 → vellum_ai-1.4.1}/ee/vellum_ee/workflows/display/workflows/base_workflow_display.py

@@ -17,6 +17,7 @@ from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.edges import Edge
 from vellum.workflows.events.workflow import NodeEventDisplayContext, WorkflowEventDisplayContext
 from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.inputs.dataset_row import DatasetRow
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.displayable.bases.utils import primitive_to_vellum_value
 from vellum.workflows.nodes.displayable.final_output_node.node import FinalOutputNode
@@ -913,7 +914,10 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
                 if dataset_attr and isinstance(dataset_attr, list):
                     dataset = []
                     for i, inputs_obj in enumerate(dataset_attr):
-                        if isinstance(inputs_obj, BaseInputs):
+                        if isinstance(inputs_obj, DatasetRow):
+                            serialized_inputs = json.loads(json.dumps(inputs_obj.inputs, cls=DefaultStateEncoder))
+                            dataset.append({"label": inputs_obj.label, "inputs": serialized_inputs})
+                        elif isinstance(inputs_obj, BaseInputs):
                             serialized_inputs = json.loads(json.dumps(inputs_obj, cls=DefaultStateEncoder))
                             dataset.append({"label": f"Scenario {i + 1}", "inputs": serialized_inputs})
         except (ImportError, AttributeError):

{vellum_ai-1.3.11 → vellum_ai-1.4.1}/ee/vellum_ee/workflows/tests/test_serialize_module.py

@@ -24,12 +24,11 @@ def test_serialize_module_with_actual_dataset():
     assert isinstance(result.dataset, list)
     assert len(result.dataset) == 2
 
-    for i, item in enumerate(result.dataset):
-        assert "label" in item
-        assert "inputs" in item
-        assert item["label"] == f"Scenario {i + 1}"
-        assert isinstance(item["inputs"], dict)
-        assert "message" in item["inputs"]
+    assert result.dataset[0]["label"] == "Scenario 1"
+    assert result.dataset[0]["inputs"]["message"] == "World"
+
+    assert result.dataset[1]["label"] == "Custom Test"
+    assert result.dataset[1]["inputs"]["message"] == "DatasetRow Test"
 
 
 def test_serialize_module_happy_path():

{vellum_ai-1.3.11 → vellum_ai-1.4.1}/pyproject.toml

@@ -3,7 +3,7 @@ name = "vellum-ai"
 
 [tool.poetry]
 name = "vellum-ai"
-version = "1.3.11"
+version = "1.4.1"
 description = ""
 readme = "README.md"
 authors = []

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

vellum_ai-1.4.1/src/vellum/workflows/events/exception_handling.py

@@ -0,0 +1,58 @@
+from uuid import uuid4
+from typing import Generator
+
+from vellum.workflows.context import get_execution_context
+from vellum.workflows.events.stream import WorkflowEventGenerator
+from vellum.workflows.events.workflow import (
+    WorkflowEvent,
+    WorkflowEventStream,
+    WorkflowExecutionInitiatedBody,
+    WorkflowExecutionInitiatedEvent,
+    WorkflowExecutionRejectedBody,
+    WorkflowExecutionRejectedEvent,
+)
+from vellum.workflows.exceptions import WorkflowInitializationException
+from vellum.workflows.inputs import BaseInputs
+
+
+def stream_initialization_exception(
+    exception: WorkflowInitializationException,
+) -> WorkflowEventStream:
+    """
+    Stream a workflow initiated event followed by a workflow rejected event for an initialization exception.
+
+    Args:
+        exception: The WorkflowInitializationException to stream events for
+
+    Returns:
+        WorkflowEventGenerator yielding initiated and rejected events
+    """
+
+    execution_context = get_execution_context()
+    span_id = uuid4()
+
+    def _generate_events() -> Generator[WorkflowEvent, None, None]:
+        initiated_event: WorkflowEvent = WorkflowExecutionInitiatedEvent(
+            trace_id=execution_context.trace_id,
+            span_id=span_id,
+            body=WorkflowExecutionInitiatedBody(
+                workflow_definition=exception.definition,
+                inputs=BaseInputs(),
+                initial_state=None,
+            ),
+            parent=execution_context.parent_context,
+        )
+        yield initiated_event
+
+        rejected_event = WorkflowExecutionRejectedEvent(
+            trace_id=execution_context.trace_id,
+            span_id=span_id,
+            body=WorkflowExecutionRejectedBody(
+                workflow_definition=exception.definition,
+                error=exception.error,
+            ),
+            parent=execution_context.parent_context,
+        )
+        yield rejected_event
+
+    return WorkflowEventGenerator(_generate_events(), span_id)

{vellum_ai-1.3.11 → vellum_ai-1.4.1}/src/vellum/workflows/events/tests/test_event.py

@@ -7,6 +7,7 @@ from deepdiff import DeepDiff
 from vellum.client.core.pydantic_utilities import UniversalBaseModel
 from vellum.workflows.constants import undefined
 from vellum.workflows.errors.types import WorkflowError, WorkflowErrorCode
+from vellum.workflows.events.exception_handling import stream_initialization_exception
 from vellum.workflows.events.node import (
     NodeExecutionFulfilledBody,
     NodeExecutionFulfilledEvent,
@@ -26,6 +27,7 @@ from vellum.workflows.events.workflow import (
     WorkflowExecutionStreamingBody,
     WorkflowExecutionStreamingEvent,
 )
+from vellum.workflows.exceptions import WorkflowInitializationException
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.outputs.base import BaseOutput
@@ -460,3 +462,28 @@ def test_parent_context__deserialize_from_json__invalid_parent_context():
     assert event.parent.type == "UNKNOWN"
     assert event.parent.span_id == UUID("123e4567-e89b-12d3-a456-426614174000")
     assert event.parent.parent is None
+
+
+def test_workflow_event_generator_stream_initialization_exception():
+    """
+    Tests that stream_initialization_exception yields both initiated and rejected events with proper correlation.
+    """
+    exception = WorkflowInitializationException("Test initialization error", workflow_definition=MockWorkflow)
+
+    events = list(stream_initialization_exception(exception))
+
+    assert len(events) == 2
+
+    initiated_event = events[0]
+    assert initiated_event.name == "workflow.execution.initiated"
+    assert initiated_event.body.inputs is not None
+    assert initiated_event.body.initial_state is None
+    assert initiated_event.body.workflow_definition == MockWorkflow
+
+    rejected_event = events[1]
+    assert rejected_event.name == "workflow.execution.rejected"
+    assert rejected_event.body.error.message == "Test initialization error"
+    assert rejected_event.body.workflow_definition == MockWorkflow
+
+    assert initiated_event.trace_id == rejected_event.trace_id
+    assert initiated_event.span_id == rejected_event.span_id

{vellum_ai-1.3.11 → vellum_ai-1.4.1}/src/vellum/workflows/exceptions.py

@@ -1,7 +1,10 @@
-from typing import Any, Dict, Optional
+from typing import TYPE_CHECKING, Any, Dict, Optional, Type
 
 from vellum.workflows.errors import WorkflowError, WorkflowErrorCode
 
+if TYPE_CHECKING:
+    from vellum.workflows.workflows.base import BaseWorkflow
+
 
 class NodeException(Exception):
     def __init__(
@@ -29,9 +32,15 @@ class NodeException(Exception):
 
 
 class WorkflowInitializationException(Exception):
-    def __init__(self, message: str, code: WorkflowErrorCode = WorkflowErrorCode.INVALID_INPUTS):
+    def __init__(
+        self,
+        message: str,
+        workflow_definition: Type["BaseWorkflow"],
+        code: WorkflowErrorCode = WorkflowErrorCode.INVALID_INPUTS,
+    ):
         self.message = message
         self.code = code
+        self.definition = workflow_definition
         super().__init__(message)
 
     @property
@@ -40,7 +49,3 @@ class WorkflowInitializationException(Exception):
             message=self.message,
             code=self.code,
         )
-
-    @staticmethod
-    def of(workflow_error: WorkflowError) -> "WorkflowInitializationException":
-        return WorkflowInitializationException(message=workflow_error.message, code=workflow_error.code)

{vellum_ai-1.3.11 → vellum_ai-1.4.1}/src/vellum/workflows/inputs/base.py

@@ -95,6 +95,7 @@ class BaseInputs(metaclass=_BaseInputsMeta):
                     raise WorkflowInitializationException(
                         message=f"Required input variables {name} should have defined value",
                         code=WorkflowErrorCode.INVALID_INPUTS,
+                        workflow_definition=self.__class__.__parent_class__,
                     )
 
             # If value provided in kwargs, set it on the instance

{vellum_ai-1.3.11 → vellum_ai-1.4.1}/src/vellum/workflows/nodes/mocks.py

@@ -123,6 +123,7 @@ class MockNodeExecution(UniversalBaseModel):
             raise WorkflowInitializationException(
                 message="Failed to validate mock node executions",
                 code=WorkflowErrorCode.INVALID_INPUTS,
+                workflow_definition=workflow,
             ) from e
 
         nodes = {node.__id__: node for node in workflow.get_nodes()}
@@ -186,7 +187,10 @@ class MockNodeExecution(UniversalBaseModel):
             elif raw_logical_condition.operator == "!=":
                 return lhs.does_not_equal(rhs)
             else:
-                raise WorkflowInitializationException(f"Unsupported logical operator: {raw_logical_condition.operator}")
+                raise WorkflowInitializationException(
+                    message=f"Unsupported logical operator: {raw_logical_condition.operator}",
+                    workflow_definition=workflow,
+                )
 
         def _translate_raw_logical_expression_variable(
             raw_variable: _RawMockWorkflowNodeExecutionValuePointer,
@@ -197,7 +201,10 @@ class MockNodeExecution(UniversalBaseModel):
                 node = nodes[raw_variable.node_id]
                 return node.Execution.count
             else:
-                raise WorkflowInitializationException(f"Unsupported logical expression type: {raw_variable.type}")
+                raise WorkflowInitializationException(
+                    message=f"Unsupported logical expression type: {raw_variable.type}",
+                    workflow_definition=workflow,
+                )
 
         mock_node_executions = []
         for mock_workflow_node_config in mock_workflow_node_configs:
@@ -212,8 +219,10 @@ class MockNodeExecution(UniversalBaseModel):
                     for then_output in mock_execution.then_outputs:
                         node_output_name = node_output_name_by_id.get(then_output.output_id)
                         if node_output_name is None:
+                            node_id = mock_workflow_node_config.node_id
                             raise WorkflowInitializationException(
-                                f"Output {then_output.output_id} not found in node {mock_workflow_node_config.node_id}"
+                                message=f"Output {then_output.output_id} not found in node {node_id}",
+                                workflow_definition=workflow,
                             )
 
                         resolved_output_reference = _translate_raw_logical_expression_variable(then_output.value)
@@ -224,8 +233,10 @@ class MockNodeExecution(UniversalBaseModel):
                                 resolved_output_reference._value,
                             )
                         else:
+                            ref_type = type(resolved_output_reference)
                             raise WorkflowInitializationException(
-                                f"Unsupported resolved output reference type: {type(resolved_output_reference)}"
+                                message=f"Unsupported resolved output reference type: {ref_type}",
+                                workflow_definition=workflow,
                             )
 
                     mock_node_executions.append(

{vellum_ai-1.3.11 → vellum_ai-1.4.1}/src/vellum/workflows/nodes/tests/test_utils.py

@@ -86,23 +86,23 @@ def test_parse_type_from_str_list_of_models():
             List[str],
             NodeException,
             WorkflowErrorCode.INVALID_OUTPUTS,
-            "Invalid JSON Array format for result_as_str",
+            "Invalid JSON format: expected a valid JSON array",
         ),
         (
             "{invalid json}",
             Person,
             NodeException,
             WorkflowErrorCode.INVALID_OUTPUTS,
-            "Invalid JSON format for result_as_str",
+            "Invalid JSON format: unable to parse the provided data",
         ),
         (
             "{invalid json}",
             Json,
             NodeException,
             WorkflowErrorCode.INVALID_OUTPUTS,
-            "Invalid JSON format for result_as_str",
+            "Invalid JSON format: unable to parse the provided data",
         ),
-        ('{"name": "Alice"}', List[str], ValueError, None, "Expected a list of items for result_as_str, received dict"),
+        ('{"name": "Alice"}', List[str], ValueError, None, "Expected a list of items, but received dict"),
         ("data", object, ValueError, None, "Unsupported output type: <class 'object'>"),
     ],
     ids=[

{vellum_ai-1.3.11 → vellum_ai-1.4.1}/src/vellum/workflows/nodes/utils.py

@@ -129,11 +129,11 @@ def parse_type_from_str(result_as_str: str, output_type: Any) -> Any:
             # raise ValueError("Invalid JSON Array format for result_as_str")
             raise NodeException(
                 code=WorkflowErrorCode.INVALID_OUTPUTS,
-                message="Invalid JSON Array format for result_as_str",
+                message="Invalid JSON format: expected a valid JSON array",
             )
 
         if not isinstance(data, list):
-            raise ValueError(f"Expected a list of items for result_as_str, received {data.__class__.__name__}")
+            raise ValueError(f"Expected a list of items, but received {data.__class__.__name__}")
 
         inner_type = get_args(output_type)[0]
         if issubclass(inner_type, BaseModel):
@@ -151,7 +151,7 @@ def parse_type_from_str(result_as_str: str, output_type: Any) -> Any:
         except json.JSONDecodeError:
             raise NodeException(
                 code=WorkflowErrorCode.INVALID_OUTPUTS,
-                message="Invalid JSON format for result_as_str",
+                message="Invalid JSON format: unable to parse the provided data",
             )
 
     if get_origin(output_type) is Union:
@@ -177,7 +177,7 @@ def parse_type_from_str(result_as_str: str, output_type: Any) -> Any:
         except json.JSONDecodeError:
             raise NodeException(
                 code=WorkflowErrorCode.INVALID_OUTPUTS,
-                message="Invalid JSON format for result_as_str",
+                message="Invalid JSON format: unable to parse the provided data",
             )
 
     raise ValueError(f"Unsupported output type: {output_type}")