vellum-ai 1.3.1__py3-none-any.whl → 1.3.3__py3-none-any.whl

vellum/workflows/nodes/core/templating_node/tests/test_templating_node.py

@@ -446,3 +446,19 @@ def test_templating_node__conditional_type_checking():
 
     # THEN conditional type checking works
     assert outputs.result == "test string"
+
+
+def test_templating_node__dict_wrapper_nonexistent_attribute_is_none():
+    """Test that non-existent attributes on DictWrapper evaluate to None."""
+
+    # GIVEN a templating node with nonexistent attr in the template
+    class TemplateNode(TemplatingNode[BaseState, str]):
+        template = "{% if data.nonexistent_attr is none %}none_value{% else %}{{ data.nonexistent_attr }}{% endif %}"
+        inputs = {"data": {"existing_key": "existing_value"}}
+
+    # WHEN the node is run
+    node = TemplateNode()
+    outputs = node.run()
+
+    # THEN it should recognize the non-existent attribute as ""
+    assert outputs.result == ""

vellum/workflows/nodes/displayable/code_execution_node/tests/test_node.py

@@ -847,21 +847,11 @@ def main(arg1: list) -> str:
         runtime = "PYTHON_3_11_6"
 
     # WHEN we run the node
-    with pytest.raises(NodeException) as exc_info:
-        node = ExampleCodeExecutionNode()
-        node.run()
+    node = ExampleCodeExecutionNode()
+    outputs = node.run()
 
     # AND the result should be the correct output
-    assert (
-        exc_info.value.message
-        == """\
-Traceback (most recent call last):
-  File "ExampleCodeExecutionNode.code.py", line 2, in main
-    return arg1["invalid"]
-
-AttributeError: dict has no key: 'invalid'
-"""
-    )
+    assert outputs == {"result": "", "log": ""}
 
 
 def test_run_node__execute_code__value_key_access():

vellum/workflows/nodes/displayable/tool_calling_node/utils.py

@@ -27,7 +27,6 @@ from vellum.workflows.nodes.displayable.subworkflow_deployment_node.node import
 from vellum.workflows.nodes.displayable.tool_calling_node.state import ToolCallingState
 from vellum.workflows.outputs.base import BaseOutput
 from vellum.workflows.ports.port import Port
-from vellum.workflows.references.lazy import LazyReference
 from vellum.workflows.state import BaseState
 from vellum.workflows.state.encoder import DefaultStateEncoder
 from vellum.workflows.types.core import EntityInputsInterface, MergeBehavior, Tool, ToolBase
@@ -421,19 +420,13 @@ def create_router_node(
         # and if the function_name is changed, the port_condition will also change.
         def create_port_condition(fn_name):
             return Port.on_if(
-                LazyReference(
-                    lambda: (
-                        ToolCallingState.current_prompt_output_index.less_than(
-                            tool_prompt_node.Outputs.results.length()
-                        )
-                        & tool_prompt_node.Outputs.results[ToolCallingState.current_prompt_output_index]["type"].equals(
-                            "FUNCTION_CALL"
-                        )
-                        & tool_prompt_node.Outputs.results[ToolCallingState.current_prompt_output_index]["value"][
-                            "name"
-                        ].equals(fn_name)
-                    )
+                ToolCallingState.current_prompt_output_index.less_than(tool_prompt_node.Outputs.results.length())
+                & tool_prompt_node.Outputs.results[ToolCallingState.current_prompt_output_index]["type"].equals(
+                    "FUNCTION_CALL"
                 )
+                & tool_prompt_node.Outputs.results[ToolCallingState.current_prompt_output_index]["value"][
+                    "name"
+                ].equals(fn_name)
             )
 
         for function in functions:

vellum/workflows/nodes/tests/test_utils.py

@@ -150,3 +150,26 @@ def test_cast_to_output_type_none_value(output_type, expected_result):
     """Test that cast_to_output_type returns appropriate default values when None is provided."""
     result = cast_to_output_type(None, output_type)
     assert result == expected_result
+
+
+@pytest.mark.parametrize(
+    "input_value,expected_result",
+    [
+        ('{"name": "Alice", "age": 30}', {"name": "Alice", "age": 30}),
+        ("[1, 2, 3]", [1, 2, 3]),
+        ("invalid json", "invalid json"),
+        ([1, 2, 3], [1, 2, 3]),
+        ({"already": "dict"}, {"already": "dict"}),
+    ],
+    ids=[
+        "valid_json_object",
+        "valid_json_array",
+        "invalid_json_string",
+        "non_string_list",
+        "non_string_dict",
+    ],
+)
+def test_cast_to_output_type_any_json_parsing(input_value, expected_result):
+    """Test that cast_to_output_type attempts JSON parsing for Any type and falls back gracefully."""
+    result = cast_to_output_type(input_value, Any)
+    assert result == expected_result

vellum/workflows/nodes/utils.py

@@ -8,6 +8,7 @@ from typing import Any, Callable, Dict, ForwardRef, List, Optional, Type, TypeVa
 from pydantic import BaseModel, create_model
 
 from vellum.client.types.function_call import FunctionCall
+from vellum.workflows.constants import undefined
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.inputs.base import BaseInputs
@@ -253,6 +254,19 @@ def cast_to_output_type(result: Any, output_type: Any) -> Any:
     if result is None:
         return _get_default_value(output_type)
 
+    if result is undefined:
+        return _get_default_value(output_type)
+
+    # Attempt JSON parse if type is Any
+    if output_type is Any:
+        if isinstance(result, str):
+            try:
+                return json.loads(result)
+            except (json.JSONDecodeError, TypeError):
+                # If JSON parsing fails, fall back to original result
+                pass
+        return result
+
     clean_output_type = _clean_output_type(output_type)
     DynamicModel = create_model("Output", output_type=(clean_output_type, ...))
 

vellum/workflows/runner/runner.py

@@ -404,6 +404,7 @@ class WorkflowRunner(Generic[StateType]):
             )
         except NodeException as e:
             logger.info(e)
+            captured_traceback = traceback.format_exc()
 
             self._workflow_event_inner_queue.put(
                 NodeExecutionRejectedEvent(
@@ -412,12 +413,14 @@ class WorkflowRunner(Generic[StateType]):
                     body=NodeExecutionRejectedBody(
                         node_definition=node.__class__,
                         error=e.error,
+                        traceback=captured_traceback,
                     ),
                     parent=execution.parent_context,
                 )
             )
         except WorkflowInitializationException as e:
             logger.info(e)
+            captured_traceback = traceback.format_exc()
             self._workflow_event_inner_queue.put(
                 NodeExecutionRejectedEvent(
                     trace_id=execution.trace_id,
@@ -425,6 +428,7 @@ class WorkflowRunner(Generic[StateType]):
                     body=NodeExecutionRejectedBody(
                         node_definition=node.__class__,
                         error=e.error,
+                        traceback=captured_traceback,
                     ),
                     parent=execution.parent_context,
                 )
@@ -574,7 +578,7 @@ class WorkflowRunner(Generic[StateType]):
             )
             worker_thread.start()
 
-    def _handle_work_item_event(self, event: WorkflowEvent) -> Optional[WorkflowError]:
+    def _handle_work_item_event(self, event: WorkflowEvent) -> Optional[NodeExecutionRejectedEvent]:
         active_node = self._active_nodes_by_execution_id.get(event.span_id)
         if not active_node:
             return None
@@ -582,7 +586,7 @@ class WorkflowRunner(Generic[StateType]):
         node = active_node.node
         if event.name == "node.execution.rejected":
             self._active_nodes_by_execution_id.pop(event.span_id)
-            return event.error
+            return event
 
         if event.name == "node.execution.streaming":
             for workflow_output_descriptor in self.workflow.Outputs:
@@ -708,13 +712,24 @@ class WorkflowRunner(Generic[StateType]):
             parent=self._execution_context.parent_context,
         )
 
-    def _reject_workflow_event(self, error: WorkflowError) -> WorkflowExecutionRejectedEvent:
+    def _reject_workflow_event(
+        self, error: WorkflowError, captured_traceback: Optional[str] = None
+    ) -> WorkflowExecutionRejectedEvent:
+        if captured_traceback is None:
+            try:
+                captured_traceback = traceback.format_exc()
+                if captured_traceback.strip() == "NoneType: None":
+                    captured_traceback = None
+            except Exception:
+                pass
+
         return WorkflowExecutionRejectedEvent(
             trace_id=self._execution_context.trace_id,
             span_id=self._initial_state.meta.span_id,
             body=WorkflowExecutionRejectedBody(
                 workflow_definition=self.workflow.__class__,
                 error=error,
+                traceback=captured_traceback,
             ),
             parent=self._execution_context.parent_context,
         )
@@ -758,22 +773,26 @@ class WorkflowRunner(Generic[StateType]):
                 else:
                     self._concurrency_queue.put((self._initial_state, node_cls, None))
             except NodeException as e:
-                self._workflow_event_outer_queue.put(self._reject_workflow_event(e.error))
+                captured_traceback = traceback.format_exc()
+                self._workflow_event_outer_queue.put(self._reject_workflow_event(e.error, captured_traceback))
                 return
             except WorkflowInitializationException as e:
-                self._workflow_event_outer_queue.put(self._reject_workflow_event(e.error))
+                captured_traceback = traceback.format_exc()
+                self._workflow_event_outer_queue.put(self._reject_workflow_event(e.error, captured_traceback))
                 return
             except Exception:
                 err_message = f"An unexpected error occurred while initializing node {node_cls.__name__}"
                 logger.exception(err_message)
+                captured_traceback = traceback.format_exc()
                 self._workflow_event_outer_queue.put(
                     self._reject_workflow_event(
                         WorkflowError(code=WorkflowErrorCode.INTERNAL_ERROR, message=err_message),
+                        captured_traceback,
                     )
                 )
                 return
 
-        rejection_error: Optional[WorkflowError] = None
+        rejection_event: Optional[NodeExecutionRejectedEvent] = None
 
         while True:
             if not self._active_nodes_by_execution_id:
@@ -784,9 +803,9 @@ class WorkflowRunner(Generic[StateType]):
             self._workflow_event_outer_queue.put(event)
 
             with execution_context(parent_context=current_parent, trace_id=self._execution_context.trace_id):
-                rejection_error = self._handle_work_item_event(event)
+                rejection_event = self._handle_work_item_event(event)
 
-            if rejection_error:
+            if rejection_event:
                 break
 
         # Handle any remaining events
@@ -795,9 +814,9 @@ class WorkflowRunner(Generic[StateType]):
                 self._workflow_event_outer_queue.put(event)
 
                 with execution_context(parent_context=current_parent, trace_id=self._execution_context.trace_id):
-                    rejection_error = self._handle_work_item_event(event)
+                    rejection_event = self._handle_work_item_event(event)
 
-                if rejection_error:
+                if rejection_event:
                     break
         except Empty:
             pass
@@ -817,8 +836,10 @@ class WorkflowRunner(Generic[StateType]):
             )
             return
 
-        if rejection_error:
-            self._workflow_event_outer_queue.put(self._reject_workflow_event(rejection_error))
+        if rejection_event:
+            self._workflow_event_outer_queue.put(
+                self._reject_workflow_event(rejection_event.error, rejection_event.body.traceback)
+            )
             return
 
         fulfilled_outputs = self.workflow.Outputs()

vellum/workflows/state/tests/test_state.py

@@ -4,11 +4,13 @@ import json
 from queue import Queue
 from typing import Dict, List, cast
 
+from vellum.workflows.constants import undefined
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.outputs.base import BaseOutputs
 from vellum.workflows.state.base import BaseState
 from vellum.workflows.state.delta import SetStateDelta, StateDelta
 from vellum.workflows.state.encoder import DefaultStateEncoder
+from vellum.workflows.types.code_execution_node_wrappers import DictWrapper
 
 
 @pytest.fixture()
@@ -229,3 +231,15 @@ def test_state_snapshot__deepcopy_fails__logs_error(mock_deepcopy, mock_logger):
 
     # AND alert sentry once
     assert mock_logger.exception.call_count == 1
+
+
+def test_state_deepcopy_handles_undefined_values():
+    # GIVEN a state with undefined values in node outputs
+    state = MockState(foo="bar")
+    state.meta.node_outputs[MockNode.Outputs.baz] = DictWrapper({"foo": undefined})
+
+    # WHEN we deepcopy the state
+    deepcopied_state = deepcopy(state)
+
+    # THEN the undefined values are preserved
+    assert deepcopied_state.meta.node_outputs[MockNode.Outputs.baz] == {"foo": undefined}

vellum/workflows/types/code_execution_node_wrappers.py

@@ -1,4 +1,5 @@
 from vellum.client.types.function_call import FunctionCall
+from vellum.workflows.constants import undefined
 
 
 class StringValueWrapper(str):
@@ -71,7 +72,10 @@ class DictWrapper(dict):
                 # several values as VellumValue objects, we use the "value" key to return itself
                 return self
 
-            raise AttributeError(f"dict has no key: '{attr}'")
+            if attr.startswith("__") and attr.endswith("__"):
+                return super().__getattribute__(attr)
+
+            return undefined
 
         item = super().__getitem__(attr)
         if not isinstance(item, DictWrapper) and not isinstance(item, ListWrapper):

vellum/workflows/utils/vellum_variables.py

@@ -22,6 +22,7 @@ from vellum import (
     VellumVideo,
     VellumVideoRequest,
 )
+from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.types.core import Json
 
@@ -29,8 +30,16 @@ from vellum.workflows.types.core import Json
 def primitive_type_to_vellum_variable_type(type_: Union[Type, BaseDescriptor]) -> VellumVariableType:
     """Converts a python primitive to a VellumVariableType"""
     if isinstance(type_, BaseDescriptor):
-        # Ignore None because those just make types optional
-        types = [t for t in type_.types if t is not type(None)]
+        # Ignore None and undefined because those just make types optional
+        types = []
+        for t in type_.types:
+            if t is type(None):
+                continue
+            if t is undefined or t is type(undefined):
+                continue
+            if get_origin(t) is type and len(get_args(t)) == 1 and get_args(t)[0] is undefined:
+                continue
+            types.append(t)
 
         # default to JSON for typevars where the types is empty tuple
         if len(types) == 0:

{vellum_ai-1.3.1.dist-info → vellum_ai-1.3.3.dist-info}/METADATA

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