vellum-ai 1.3.2__py3-none-any.whl → 1.3.4__py3-none-any.whl

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

vellum/client/types/function_definition.py

@@ -30,6 +30,11 @@ class FunctionDefinition(UniversalBaseModel):
     An OpenAPI specification of parameters that are supported by this function.
     """
 
+    inputs: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] = pydantic.Field(default=None)
+    """
+    Optional user defined input mappings for this function.
+    """
+
     forced: typing.Optional[bool] = pydantic.Field(default=None)
     """
     Set this option to true to force the model to return a function call of this function.

vellum/client/types/scenario_input_audio_variable_value.py

@@ -9,7 +9,7 @@ from .vellum_audio import VellumAudio
 
 class ScenarioInputAudioVariableValue(UniversalBaseModel):
     type: typing.Literal["AUDIO"] = "AUDIO"
-    value: VellumAudio
+    value: typing.Optional[VellumAudio] = None
     input_variable_id: str
 
     if IS_PYDANTIC_V2:

vellum/client/types/scenario_input_document_variable_value.py

@@ -9,7 +9,7 @@ from .vellum_document import VellumDocument
 
 class ScenarioInputDocumentVariableValue(UniversalBaseModel):
     type: typing.Literal["DOCUMENT"] = "DOCUMENT"
-    value: VellumDocument
+    value: typing.Optional[VellumDocument] = None
     input_variable_id: str
 
     if IS_PYDANTIC_V2:

vellum/client/types/scenario_input_image_variable_value.py

@@ -9,7 +9,7 @@ from .vellum_image import VellumImage
 
 class ScenarioInputImageVariableValue(UniversalBaseModel):
     type: typing.Literal["IMAGE"] = "IMAGE"
-    value: VellumImage
+    value: typing.Optional[VellumImage] = None
     input_variable_id: str
 
     if IS_PYDANTIC_V2:

vellum/client/types/scenario_input_video_variable_value.py

@@ -9,7 +9,7 @@ from .vellum_video import VellumVideo
 
 class ScenarioInputVideoVariableValue(UniversalBaseModel):
     type: typing.Literal["VIDEO"] = "VIDEO"
-    value: VellumVideo
+    value: typing.Optional[VellumVideo] = None
     input_variable_id: str
 
     if IS_PYDANTIC_V2:

vellum/workflows/emitters/vellum_emitter.py

@@ -1,5 +1,6 @@
 import logging
-from typing import Optional
+import threading
+from typing import List, Optional
 
 from vellum.core.request_options import RequestOptions
 from vellum.workflows.emitters.base import BaseWorkflowEmitter
@@ -29,6 +30,7 @@ class VellumEmitter(BaseWorkflowEmitter):
         *,
         timeout: Optional[float] = 30.0,
         max_retries: int = 3,
+        debounce_timeout: float = 0.1,
     ):
         """
         Initialize the VellumEmitter.
@@ -36,14 +38,19 @@ class VellumEmitter(BaseWorkflowEmitter):
         Args:
             timeout: Request timeout in seconds.
             max_retries: Maximum number of retry attempts for failed requests.
+            debounce_timeout: Time in seconds to wait before sending batched events.
         """
         super().__init__()
         self._timeout = timeout
         self._max_retries = max_retries
+        self._debounce_timeout = debounce_timeout
+        self._event_queue: List[SDKWorkflowEvent] = []
+        self._queue_lock = threading.Lock()
+        self._debounce_timer: Optional[threading.Timer] = None
 
     def emit_event(self, event: SDKWorkflowEvent) -> None:
         """
-        Emit a workflow event to Vellum's infrastructure.
+        Queue a workflow event for batched emission to Vellum's infrastructure.
 
         Args:
             event: The workflow event to emit.
@@ -55,10 +62,45 @@ class VellumEmitter(BaseWorkflowEmitter):
             return
 
         try:
-            self._send_event(event)
+            with self._queue_lock:
+                self._event_queue.append(event)
 
+                if self._debounce_timer:
+                    self._debounce_timer.cancel()
+
+                self._debounce_timer = threading.Timer(self._debounce_timeout, self._flush_events)
+                self._debounce_timer.start()
+
+        except Exception as e:
+            logger.exception(f"Failed to queue event {event.name}: {e}")
+
+    def _flush_events(self) -> None:
+        """
+        Send all queued events as a batch to Vellum's infrastructure.
+        """
+        with self._queue_lock:
+            if not self._event_queue:
+                return
+
+            events_to_send = self._event_queue.copy()
+            self._event_queue.clear()
+            self._debounce_timer = None
+
+        try:
+            self._send_events(events_to_send)
         except Exception as e:
-            logger.exception(f"Failed to emit event {event.name}: {e}")
+            logger.exception(f"Failed to send batched events: {e}")
+
+    def __del__(self) -> None:
+        """
+        Cleanup: flush any pending events and cancel timer.
+        """
+        try:
+            if self._debounce_timer:
+                self._debounce_timer.cancel()
+            self._flush_events()
+        except Exception:
+            pass
 
     def snapshot_state(self, state: BaseState) -> None:
         """
@@ -69,23 +111,27 @@ class VellumEmitter(BaseWorkflowEmitter):
         """
         pass
 
-    def _send_event(self, event: SDKWorkflowEvent) -> None:
+    def _send_events(self, events: List[SDKWorkflowEvent]) -> None:
         """
-        Send event to Vellum's events endpoint using client.events.create.
+        Send events to Vellum's events endpoint using client.events.create.
 
         Args:
-            event: The WorkflowEvent object to send.
+            events: List of WorkflowEvent objects to send.
         """
         if not self._context:
-            logger.warning("Cannot send event: No workflow context registered")
+            logger.warning("Cannot send events: No workflow context registered")
+            return
+
+        if not events:
             return
 
         client = self._context.vellum_client
         request_options = RequestOptions(timeout_in_seconds=self._timeout, max_retries=self._max_retries)
+
         client.events.create(
             # The API accepts a ClientWorkflowEvent but our SDK emits an SDKWorkflowEvent. These shapes are
             # meant to be identical, just with different helper methods. We may consolidate the two in the future.
             # But for now, the type ignore allows us to avoid an additional Model -> json -> Model conversion.
-            request=event,  # type: ignore[arg-type]
+            request=events,  # type: ignore[arg-type]
             request_options=request_options,
         )

vellum/workflows/events/node.py

@@ -141,7 +141,7 @@ class NodeExecutionFulfilledEvent(_BaseNodeEvent, Generic[OutputsType]):
 
 class NodeExecutionRejectedBody(_BaseNodeExecutionBody):
     error: WorkflowError
-    traceback: Optional[str] = None
+    stacktrace: Optional[str] = None
 
 
 class NodeExecutionRejectedEvent(_BaseNodeEvent):

vellum/workflows/events/tests/test_event.py

@@ -261,7 +261,7 @@ mock_node_uuid = str(uuid4_from_hash(MockNode.__qualname__))
                         "message": "Workflow failed",
                         "code": "USER_DEFINED_ERROR",
                     },
-                    "traceback": None,
+                    "stacktrace": None,
                 },
                 "parent": None,
                 "links": None,

vellum/workflows/events/workflow.py

@@ -156,7 +156,7 @@ class WorkflowExecutionFulfilledEvent(_BaseWorkflowEvent, Generic[OutputsType]):
 
 class WorkflowExecutionRejectedBody(_BaseWorkflowExecutionBody):
     error: WorkflowError
-    traceback: Optional[str] = None
+    stacktrace: Optional[str] = None
 
 
 class WorkflowExecutionRejectedEvent(_BaseWorkflowEvent):

vellum/workflows/nodes/core/retry_node/tests/test_node.py

@@ -6,7 +6,6 @@ from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.core.retry_node.node import RetryNode
 from vellum.workflows.outputs import BaseOutputs
-from vellum.workflows.references.lazy import LazyReference
 from vellum.workflows.state.base import BaseState, StateMeta
 
 
@@ -102,7 +101,7 @@ def test_retry_node__condition_arg_successfully_retries():
     # AND a retry node that retries on a condition
     @RetryNode.wrap(
         max_attempts=5,
-        retry_on_condition=LazyReference(lambda: State.count.less_than(3)),
+        retry_on_condition=State.count.less_than(3),
     )
     class TestNode(BaseNode[State]):
         attempt_number = RetryNode.SubworkflowInputs.attempt_number

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:
@@ -527,12 +520,25 @@ def create_function_node(
             },
         )
     else:
-        # For regular functions, use FunctionNode
+
+        def create_function_wrapper(func):
+            def wrapper(self, **kwargs):
+                merged_kwargs = kwargs.copy()
+                inputs = getattr(func, "__vellum_inputs__", {})
+                if inputs:
+                    for param_name, param_ref in inputs.items():
+                        resolved_value = param_ref.resolve(self.state)
+                        merged_kwargs[param_name] = resolved_value
+
+                return func(**merged_kwargs)
+
+            return wrapper
+
         node = type(
             f"FunctionNode_{function.__name__}",
             (FunctionNode,),
             {
-                "function_definition": lambda self, **kwargs: function(**kwargs),  # ← Revert back to lambda
+                "function_definition": create_function_wrapper(function),
                 "function_call_output": tool_prompt_node.Outputs.results,
                 "__module__": __name__,
             },

vellum/workflows/resolvers/resolver.py

@@ -1,10 +1,11 @@
 import logging
 from uuid import UUID
-from typing import Iterator, List, Optional, Tuple, Union
+from typing import Iterator, List, Optional, Tuple, Type, Union
 
 from vellum.client.types.vellum_span import VellumSpan
 from vellum.client.types.workflow_execution_initiated_event import WorkflowExecutionInitiatedEvent
 from vellum.workflows.events.workflow import WorkflowEvent
+from vellum.workflows.nodes.utils import cast_to_output_type
 from vellum.workflows.resolvers.base import BaseWorkflowResolver
 from vellum.workflows.resolvers.types import LoadStateResult
 from vellum.workflows.state.base import BaseState
@@ -51,6 +52,21 @@ class VellumResolver(BaseWorkflowResolver):
 
         return previous_trace_id, root_trace_id, previous_span_id, root_span_id
 
+    def _deserialize_state(self, state_data: dict, state_class: Type[BaseState]) -> BaseState:
+        """Deserialize state data with proper type conversion for complex types like List[ChatMessage]."""
+        converted_data = {}
+
+        annotations = getattr(state_class, "__annotations__", {})
+
+        for field_name, field_value in state_data.items():
+            if field_name in annotations:
+                field_type = annotations[field_name]
+                converted_data[field_name] = cast_to_output_type(field_value, field_type)
+            else:
+                converted_data[field_name] = field_value
+
+        return state_class(**converted_data)
+
     def load_state(self, previous_execution_id: Optional[Union[UUID, str]] = None) -> Optional[LoadStateResult]:
         if isinstance(previous_execution_id, UUID):
             previous_execution_id = str(previous_execution_id)
@@ -83,7 +99,7 @@ class VellumResolver(BaseWorkflowResolver):
 
         if self._workflow_class:
             state_class = self._workflow_class.get_state_class()
-            state = state_class(**response.state)
+            state = self._deserialize_state(response.state, state_class)
         else:
             logger.warning("No workflow class registered, falling back to BaseState")
             state = BaseState(**response.state)

vellum/workflows/resolvers/tests/test_resolver.py

@@ -1,7 +1,9 @@
 from datetime import datetime
 from unittest.mock import Mock
 from uuid import uuid4
+from typing import List
 
+from vellum import ChatMessage
 from vellum.client.types.span_link import SpanLink
 from vellum.client.types.vellum_code_resource_definition import VellumCodeResourceDefinition
 from vellum.client.types.workflow_execution_detail import WorkflowExecutionDetail
@@ -129,3 +131,122 @@ def test_load_state_with_context_success():
     mock_client.workflow_executions.retrieve_workflow_execution_detail.assert_called_once_with(
         execution_id=str(execution_id)
     )
+
+
+def test_load_state_with_chat_message_list():
+    """Test load_state successfully loads state with chat_history containing ChatMessage list."""
+    resolver = VellumResolver()
+    execution_id = uuid4()
+    root_execution_id = uuid4()
+
+    class TestStateWithChatHistory(BaseState):
+        test_key: str = "test_value"
+        chat_history: List[ChatMessage] = []
+
+    class TestWorkflow(BaseWorkflow[BaseInputs, TestStateWithChatHistory]):
+        pass
+
+    # GIVEN a state dictionary with chat_history containing ChatMessage objects
+    prev_id = str(uuid4())
+    prev_span_id = str(uuid4())
+    state_dict = {
+        "test_key": "test_value",
+        "chat_history": [
+            {"role": "USER", "text": "Hello, how are you?"},
+            {"role": "ASSISTANT", "text": "I'm doing well, thank you!"},
+            {"role": "USER", "text": "What can you help me with?"},
+        ],
+        "meta": {
+            "workflow_definition": "MockWorkflow",
+            "id": prev_id,
+            "span_id": prev_span_id,
+            "updated_ts": datetime.now().isoformat(),
+            "workflow_inputs": BaseInputs(),
+            "external_inputs": {},
+            "node_outputs": {},
+            "node_execution_cache": NodeExecutionCache(),
+            "parent": None,
+        },
+    }
+
+    mock_workflow_definition = VellumCodeResourceDefinition(
+        name="TestWorkflow", module=["test", "module"], id=str(uuid4())
+    )
+
+    mock_body = WorkflowExecutionInitiatedBody(workflow_definition=mock_workflow_definition, inputs={})
+
+    previous_trace_id = str(uuid4())
+    root_trace_id = str(uuid4())
+
+    previous_invocation = WorkflowExecutionInitiatedEvent(
+        id=str(uuid4()),
+        timestamp=datetime.now(),
+        trace_id=previous_trace_id,
+        span_id=str(execution_id),
+        body=mock_body,
+        links=[
+            SpanLink(
+                trace_id=previous_trace_id,
+                type="PREVIOUS_SPAN",
+                span_context=WorkflowParentContext(workflow_definition=mock_workflow_definition, span_id=str(uuid4())),
+            ),
+            SpanLink(
+                trace_id=root_trace_id,
+                type="ROOT_SPAN",
+                span_context=WorkflowParentContext(
+                    workflow_definition=mock_workflow_definition, span_id=str(root_execution_id)
+                ),
+            ),
+        ],
+    )
+
+    root_invocation = WorkflowExecutionInitiatedEvent(
+        id=str(uuid4()),
+        timestamp=datetime.now(),
+        trace_id=root_trace_id,
+        span_id=str(root_execution_id),
+        body=mock_body,
+        links=None,
+    )
+
+    mock_span = WorkflowExecutionSpan(
+        span_id=str(execution_id),
+        start_ts=datetime.now(),
+        end_ts=datetime.now(),
+        attributes=WorkflowExecutionSpanAttributes(label="Test Workflow", workflow_id=str(uuid4())),
+        events=[previous_invocation, root_invocation],
+    )
+
+    mock_response = WorkflowExecutionDetail(
+        span_id="test-span-id", start=datetime.now(), inputs=[], outputs=[], spans=[mock_span], state=state_dict
+    )
+
+    mock_client = Mock()
+    mock_client.workflow_executions.retrieve_workflow_execution_detail.return_value = mock_response
+
+    # AND context with the test workflow class is set up
+    context = WorkflowContext(vellum_client=mock_client)
+    TestWorkflow(context=context, resolvers=[resolver])
+
+    # WHEN load_state is called
+    result = resolver.load_state(previous_execution_id=execution_id)
+
+    # THEN should return LoadStateResult with state containing chat_history
+    assert isinstance(result, LoadStateResult)
+    assert result.state is not None
+    assert isinstance(result.state, TestStateWithChatHistory)
+    assert result.state.test_key == "test_value"
+
+    # AND the chat_history should be properly deserialized as ChatMessage objects
+    assert len(result.state.chat_history) == 3
+    assert all(isinstance(msg, ChatMessage) for msg in result.state.chat_history)
+    assert result.state.chat_history[0].role == "USER"
+    assert result.state.chat_history[0].text == "Hello, how are you?"
+    assert result.state.chat_history[1].role == "ASSISTANT"
+    assert result.state.chat_history[1].text == "I'm doing well, thank you!"
+    assert result.state.chat_history[2].role == "USER"
+    assert result.state.chat_history[2].text == "What can you help me with?"
+
+    mock_client.workflow_executions.retrieve_workflow_execution_detail.assert_called_once_with(
+        execution_id=str(execution_id)
+    )

vellum/workflows/runner/runner.py

@@ -404,7 +404,7 @@ class WorkflowRunner(Generic[StateType]):
             )
         except NodeException as e:
             logger.info(e)
-            captured_traceback = traceback.format_exc()
+            captured_stacktrace = traceback.format_exc()
 
             self._workflow_event_inner_queue.put(
                 NodeExecutionRejectedEvent(
@@ -413,14 +413,14 @@ class WorkflowRunner(Generic[StateType]):
                     body=NodeExecutionRejectedBody(
                         node_definition=node.__class__,
                         error=e.error,
-                        traceback=captured_traceback,
+                        stacktrace=captured_stacktrace,
                     ),
                     parent=execution.parent_context,
                 )
             )
         except WorkflowInitializationException as e:
             logger.info(e)
-            captured_traceback = traceback.format_exc()
+            captured_stacktrace = traceback.format_exc()
             self._workflow_event_inner_queue.put(
                 NodeExecutionRejectedEvent(
                     trace_id=execution.trace_id,
@@ -428,7 +428,7 @@ class WorkflowRunner(Generic[StateType]):
                     body=NodeExecutionRejectedBody(
                         node_definition=node.__class__,
                         error=e.error,
-                        traceback=captured_traceback,
+                        stacktrace=captured_stacktrace,
                     ),
                     parent=execution.parent_context,
                 )
@@ -713,13 +713,13 @@ class WorkflowRunner(Generic[StateType]):
         )
 
     def _reject_workflow_event(
-        self, error: WorkflowError, captured_traceback: Optional[str] = None
+        self, error: WorkflowError, captured_stacktrace: Optional[str] = None
     ) -> WorkflowExecutionRejectedEvent:
-        if captured_traceback is None:
+        if captured_stacktrace is None:
             try:
-                captured_traceback = traceback.format_exc()
-                if captured_traceback.strip() == "NoneType: None":
-                    captured_traceback = None
+                captured_stacktrace = traceback.format_exc()
+                if captured_stacktrace.strip() == "NoneType: None":
+                    captured_stacktrace = None
             except Exception:
                 pass
 
@@ -729,7 +729,7 @@ class WorkflowRunner(Generic[StateType]):
             body=WorkflowExecutionRejectedBody(
                 workflow_definition=self.workflow.__class__,
                 error=error,
-                traceback=captured_traceback,
+                stacktrace=captured_stacktrace,
             ),
             parent=self._execution_context.parent_context,
         )
@@ -773,21 +773,21 @@ class WorkflowRunner(Generic[StateType]):
                 else:
                     self._concurrency_queue.put((self._initial_state, node_cls, None))
             except NodeException as e:
-                captured_traceback = traceback.format_exc()
-                self._workflow_event_outer_queue.put(self._reject_workflow_event(e.error, captured_traceback))
+                captured_stacktrace = traceback.format_exc()
+                self._workflow_event_outer_queue.put(self._reject_workflow_event(e.error, captured_stacktrace))
                 return
             except WorkflowInitializationException as e:
-                captured_traceback = traceback.format_exc()
-                self._workflow_event_outer_queue.put(self._reject_workflow_event(e.error, captured_traceback))
+                captured_stacktrace = traceback.format_exc()
+                self._workflow_event_outer_queue.put(self._reject_workflow_event(e.error, captured_stacktrace))
                 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()
+                captured_stacktrace = traceback.format_exc()
                 self._workflow_event_outer_queue.put(
                     self._reject_workflow_event(
                         WorkflowError(code=WorkflowErrorCode.INTERNAL_ERROR, message=err_message),
-                        captured_traceback,
+                        captured_stacktrace,
                     )
                 )
                 return
@@ -838,7 +838,7 @@ class WorkflowRunner(Generic[StateType]):
 
         if rejection_event:
             self._workflow_event_outer_queue.put(
-                self._reject_workflow_event(rejection_event.error, rejection_event.body.traceback)
+                self._reject_workflow_event(rejection_event.error, rejection_event.body.stacktrace)
             )
             return
 

vellum/workflows/state/encoder.py

@@ -1,11 +1,8 @@
 from dataclasses import asdict, is_dataclass
 from datetime import datetime
 import enum
-import inspect
-from io import StringIO
 from json import JSONEncoder
 from queue import Queue
-import sys
 from uuid import UUID
 from typing import Any, Callable, Dict, Type
 
@@ -17,23 +14,6 @@ from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.outputs.base import BaseOutput, BaseOutputs
 from vellum.workflows.ports.port import Port
 from vellum.workflows.state.base import BaseState, NodeExecutionCache
-from vellum.workflows.utils.functions import compile_function_definition
-
-
-def virtual_open(file_path: str, mode: str = "r"):
-    """
-    Open a file, checking VirtualFileFinder instances first before falling back to regular open().
-    """
-    for finder in sys.meta_path:
-        if hasattr(finder, "loader") and hasattr(finder.loader, "_get_code"):
-            namespace = finder.loader.namespace
-            if file_path.startswith(namespace + "/"):
-                relative_path = file_path[len(namespace) + 1 :]
-                content = finder.loader._get_code(relative_path)
-                if content is not None:
-                    return StringIO(content)
-
-    return open(file_path, mode)
 
 
 class DefaultStateEncoder(JSONEncoder):
@@ -80,23 +60,6 @@ class DefaultStateEncoder(JSONEncoder):
         if isinstance(obj, type):
             return str(obj)
 
-        if callable(obj):
-            function_definition = compile_function_definition(obj)
-            source_path = inspect.getsourcefile(obj)
-            if source_path is not None:
-                with virtual_open(source_path) as f:
-                    source_code = f.read()
-            else:
-                source_code = f"# Error: Source code not available for {obj.__name__}"
-
-            return {
-                "type": "CODE_EXECUTION",
-                "name": function_definition.name,
-                "description": function_definition.description,
-                "definition": function_definition,
-                "src": source_code,
-            }
-
         if obj.__class__ in self.encoders:
             return self.encoders[obj.__class__](obj)
 

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

@@ -72,6 +72,9 @@ class DictWrapper(dict):
                 # several values as VellumValue objects, we use the "value" key to return itself
                 return self
 
+            if attr.startswith("__") and attr.endswith("__"):
+                return super().__getattribute__(attr)
+
             return undefined
 
         item = super().__getitem__(attr)