vellum-ai 1.3.3__py3-none-any.whl → 1.3.5__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.3",
+            "User-Agent": "vellum-ai/1.3.5",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "1.3.3",
+            "X-Fern-SDK-Version": "1.3.5",
             **(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/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/bases/base.py

@@ -120,7 +120,7 @@ class BaseNodeMeta(ABCMeta):
         cls = super().__new__(mcs, name, bases, dct)
         node_class = cast(Type["BaseNode"], cls)
 
-        node_class.Outputs._node_class = node_class
+        node_class.Outputs.__parent_class__ = node_class
 
         # Add cls to relevant nested classes, since python should've been doing this by default
         for port in node_class.Ports:
@@ -270,11 +270,8 @@ class BaseNode(Generic[StateType], ABC, metaclass=BaseNodeMeta):
     class ExternalInputs(BaseInputs):
         __descriptor_class__ = ExternalInputReference
 
-    # TODO: Consider using metaclasses to prevent the need for users to specify that the
-    #   "Outputs" class inherits from "BaseOutputs" and do so automatically.
-    #   https://app.shortcut.com/vellum/story/4008/auto-inherit-basenodeoutputs-in-outputs-classes
     class Outputs(BaseOutputs):
-        _node_class: Type["BaseNode"] = field(init=False)
+        __parent_class__: Type["BaseNode"] = field(init=False)
 
     class Ports(NodePorts):
         default = Port(default=True)

vellum/workflows/nodes/core/map_node/node.py

@@ -27,6 +27,7 @@ from vellum.workflows.nodes.bases.base_adornment_node import BaseAdornmentNode
 from vellum.workflows.nodes.utils import create_adornment
 from vellum.workflows.outputs import BaseOutputs
 from vellum.workflows.outputs.base import BaseOutput
+from vellum.workflows.references.node import NodeReference
 from vellum.workflows.references.output import OutputReference
 from vellum.workflows.state.context import WorkflowContext
 from vellum.workflows.types.generics import StateType
@@ -217,5 +218,11 @@ class MapNode(BaseAdornmentNode[StateType], Generic[StateType, MapNodeItemType])
         #     value: List[str]
         outputs_class.__annotations__ = {**previous_annotations, reference.name: annotation}
 
-        output_id = uuid4_from_hash(f"{cls.__id__}|{reference.name}")
+        subworkflow_class = cls.subworkflow.instance if isinstance(cls.subworkflow, NodeReference) else None
+        if subworkflow_class:
+            output_id = subworkflow_class.__output_ids__.get(reference.name) or uuid4_from_hash(
+                f"{cls.__id__}|{reference.name}"
+            )
+        else:
+            output_id = uuid4_from_hash(f"{cls.__id__}|{reference.name}")
         cls.__output_ids__[reference.name] = output_id

vellum/workflows/nodes/displayable/bases/inline_prompt_node/node.py

@@ -100,7 +100,7 @@ class BaseInlinePromptNode(BasePromptNode[StateType], Generic[StateType]):
         execution_context = get_execution_context()
         request_options = self.request_options or RequestOptions()
 
-        processed_parameters = self._process_parameters(self.parameters)
+        processed_parameters = self.process_parameters(self.parameters)
 
         request_options["additional_body_parameters"] = {
             "execution_context": execution_context.model_dump(mode="json"),
@@ -300,7 +300,7 @@ class BaseInlinePromptNode(BasePromptNode[StateType], Generic[StateType]):
 
         return input_variables, input_values
 
-    def _process_parameters(self, parameters: PromptParameters) -> PromptParameters:
+    def process_parameters(self, parameters: PromptParameters) -> PromptParameters:
         """
         Process parameters to recursively convert any Pydantic models to JSON schema dictionaries.
         """

vellum/workflows/nodes/displayable/guardrail_node/node.py

@@ -8,7 +8,6 @@ from vellum.workflows.constants import LATEST_RELEASE_TAG
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases import BaseNode
-from vellum.workflows.outputs.base import BaseOutputs
 from vellum.workflows.types.core import EntityInputsInterface, MergeBehavior
 from vellum.workflows.types.generics import StateType
 
@@ -33,7 +32,7 @@ class GuardrailNode(BaseNode[StateType], Generic[StateType]):
     class Trigger(BaseNode.Trigger):
         merge_behavior = MergeBehavior.AWAIT_ANY
 
-    class Outputs(BaseOutputs):
+    class Outputs(BaseNode.Outputs):
         score: float
         normalized_score: Optional[float]
         log: Optional[str]
@@ -98,7 +97,13 @@ class GuardrailNode(BaseNode[StateType], Generic[StateType]):
         else:
             reason = None
 
-        return self.Outputs(score=score, normalized_score=normalized_score, log=log, reason=reason, **metric_outputs)
+        return self.Outputs(
+            score=score,
+            normalized_score=normalized_score,
+            log=log,
+            reason=reason,
+            **metric_outputs,  # type: ignore [arg-type]
+        )
 
     def _compile_metric_inputs(self) -> List[MetricDefinitionInput]:
         # TODO: We may want to consolidate with prompt deployment input compilation

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

@@ -138,6 +138,9 @@ class ToolCallingNode(BaseNode[StateType], Generic[StateType]):
                 )
 
     def _build_graph(self) -> None:
+        # Get the process_parameters method if it exists on this class
+        process_parameters_method = getattr(self.__class__, "process_parameters", None)
+
         self.tool_prompt_node = create_tool_prompt_node(
             ml_model=self.ml_model,
             blocks=self.blocks,
@@ -145,6 +148,7 @@ class ToolCallingNode(BaseNode[StateType], Generic[StateType]):
             prompt_inputs=self.prompt_inputs,
             parameters=self.parameters,
             max_prompt_iterations=self.max_prompt_iterations,
+            process_parameters_method=process_parameters_method,
         )
 
         # Create the router node (handles routing logic only)

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

@@ -329,6 +329,7 @@ def create_tool_prompt_node(
     prompt_inputs: Optional[EntityInputsInterface],
     parameters: PromptParameters,
     max_prompt_iterations: Optional[int] = None,
+    process_parameters_method: Optional[Callable] = None,
 ) -> Type[ToolPromptNode]:
     if functions and len(functions) > 0:
         prompt_functions: List[Union[Tool, FunctionDefinition]] = []
@@ -398,6 +399,7 @@ def create_tool_prompt_node(
                 "prompt_inputs": node_prompt_inputs,
                 "parameters": parameters,
                 "max_prompt_iterations": max_prompt_iterations,
+                **({"process_parameters": process_parameters_method} if process_parameters_method is not None else {}),
                 "__module__": __name__,
             },
         ),
@@ -520,12 +522,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/outputs/base.py

@@ -1,5 +1,6 @@
+from dataclasses import field
 import inspect
-from typing import TYPE_CHECKING, Any, Generic, Iterator, Set, Tuple, Type, TypeVar, Union, cast
+from typing import Any, Generic, Iterator, Set, Tuple, Type, TypeVar, Union, cast
 from typing_extensions import dataclass_transform
 
 from pydantic import GetCoreSchemaHandler
@@ -13,9 +14,6 @@ from vellum.workflows.references.output import OutputReference
 from vellum.workflows.types.generics import is_node_instance
 from vellum.workflows.types.utils import get_class_attr_names, infer_types
 
-if TYPE_CHECKING:
-    from vellum.workflows.nodes.bases.base import BaseNode
-
 _Delta = TypeVar("_Delta")
 _Accumulated = TypeVar("_Accumulated")
 
@@ -112,18 +110,16 @@ class _BaseOutputsMeta(type):
         if not cls.__qualname__.endswith(".Outputs") or not other.__qualname__.endswith(".Outputs"):
             return super().__eq__(other)
 
-        self_outputs_class = cast(Type["BaseNode.Outputs"], cls)
-        other_outputs_class = cast(Type["BaseNode.Outputs"], other)
+        self_outputs_class = cast(Type["BaseOutputs"], cls)
+        other_outputs_class = cast(Type["BaseOutputs"], other)
 
-        if not hasattr(self_outputs_class, "_node_class") or not hasattr(other_outputs_class, "_node_class"):
+        if not hasattr(self_outputs_class, "__parent_class__") or not hasattr(other_outputs_class, "__parent_class__"):
             return super().__eq__(other)
 
-        if self_outputs_class._node_class is None or other_outputs_class._node_class is None:
+        if self_outputs_class.__parent_class__ is None or other_outputs_class.__parent_class__ is None:
             return super().__eq__(other)
 
-        return getattr(self_outputs_class._node_class, "__qualname__") == getattr(
-            other_outputs_class._node_class, "__qualname__"
-        )
+        return self_outputs_class.__parent_class__.__qualname__ == other_outputs_class.__parent_class__.__qualname__
 
     def __setattr__(cls, name: str, value: Any) -> None:
         if isinstance(value, OutputReference):
@@ -187,6 +183,10 @@ class _BaseOutputsMeta(type):
 
 
 class BaseOutputs(metaclass=_BaseOutputsMeta):
+    # TODO: Uncomment once we figure out why this causes a failure in `infer_types`
+    # __parent_class__: Type[Union["BaseNode", "BaseWorkflow"]] = field(init=False)
+    __parent_class__: Type = field(init=False)
+
     def __init__(self, **kwargs: Any) -> None:
         declared_fields = {descriptor.name for descriptor in self.__class__}
         provided_fields = set(kwargs.keys())

vellum/workflows/references/output.py

@@ -35,13 +35,11 @@ class OutputReference(BaseDescriptor[_OutputType], Generic[_OutputType]):
 
     @cached_property
     def id(self) -> UUID:
-        self._outputs_class = self._outputs_class
-
-        node_class = getattr(self._outputs_class, "_node_class", None)
-        if not node_class:
+        parent_class = self._outputs_class.__parent_class__
+        if not parent_class:
             return uuid4()
 
-        output_ids = getattr(node_class, "__output_ids__", {})
+        output_ids = getattr(parent_class, "__output_ids__", {})
         if not isinstance(output_ids, dict):
             return uuid4()
 

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)