vellum-ai 1.2.1__py3-none-any.whl → 1.2.3__py3-none-any.whl

vellum/types/execution_document_vellum_value.py

@@ -0,0 +1,3 @@
+# WARNING: This file will be removed in a future release. Please import from "vellum.client" instead.
+
+from vellum.client.types.execution_document_vellum_value import *

vellum/types/execution_image_vellum_value.py

@@ -0,0 +1,3 @@
+# WARNING: This file will be removed in a future release. Please import from "vellum.client" instead.
+
+from vellum.client.types.execution_image_vellum_value import *

vellum/types/execution_video_vellum_value.py

@@ -0,0 +1,3 @@
+# WARNING: This file will be removed in a future release. Please import from "vellum.client" instead.
+
+from vellum.client.types.execution_video_vellum_value import *

vellum/types/image_input_request.py

@@ -0,0 +1,3 @@
+# WARNING: This file will be removed in a future release. Please import from "vellum.client" instead.
+
+from vellum.client.types.image_input_request import *

vellum/types/node_input_compiled_audio_value.py

@@ -0,0 +1,3 @@
+# WARNING: This file will be removed in a future release. Please import from "vellum.client" instead.
+
+from vellum.client.types.node_input_compiled_audio_value import *

vellum/types/node_input_compiled_document_value.py

@@ -0,0 +1,3 @@
+# WARNING: This file will be removed in a future release. Please import from "vellum.client" instead.
+
+from vellum.client.types.node_input_compiled_document_value import *

vellum/types/node_input_compiled_image_value.py

@@ -0,0 +1,3 @@
+# WARNING: This file will be removed in a future release. Please import from "vellum.client" instead.
+
+from vellum.client.types.node_input_compiled_image_value import *

vellum/types/node_input_compiled_video_value.py

@@ -0,0 +1,3 @@
+# WARNING: This file will be removed in a future release. Please import from "vellum.client" instead.
+
+from vellum.client.types.node_input_compiled_video_value import *

vellum/types/prompt_request_audio_input.py

@@ -0,0 +1,3 @@
+# WARNING: This file will be removed in a future release. Please import from "vellum.client" instead.
+
+from vellum.client.types.prompt_request_audio_input import *

vellum/types/prompt_request_document_input.py

@@ -0,0 +1,3 @@
+# WARNING: This file will be removed in a future release. Please import from "vellum.client" instead.
+
+from vellum.client.types.prompt_request_document_input import *

vellum/types/prompt_request_image_input.py

@@ -0,0 +1,3 @@
+# WARNING: This file will be removed in a future release. Please import from "vellum.client" instead.
+
+from vellum.client.types.prompt_request_image_input import *

vellum/types/prompt_request_video_input.py

@@ -0,0 +1,3 @@
+# WARNING: This file will be removed in a future release. Please import from "vellum.client" instead.
+
+from vellum.client.types.prompt_request_video_input import *

vellum/types/video_input_request.py

@@ -0,0 +1,3 @@
+# WARNING: This file will be removed in a future release. Please import from "vellum.client" instead.
+
+from vellum.client.types.video_input_request import *

vellum/workflows/context.py

@@ -1,10 +1,11 @@
 from contextlib import contextmanager
 from dataclasses import field
 import threading
-from uuid import UUID
+from uuid import UUID, uuid4
 from typing import Iterator, Optional, cast
 
 from vellum.client.core import UniversalBaseModel
+from vellum.workflows.events.context import MonitoringContextStore
 from vellum.workflows.events.types import ParentContext
 
 
@@ -17,16 +18,37 @@ _CONTEXT_KEY = "_execution_context"
 
 local = threading.local()
 
+monitoring_context_store = MonitoringContextStore()
+
 
 def get_execution_context() -> ExecutionContext:
-    """Retrieve the current execution context."""
-    return getattr(local, _CONTEXT_KEY, ExecutionContext())
+    """Get the current monitoring execution context, with intelligent fallback."""
+    context = getattr(local, _CONTEXT_KEY, ExecutionContext())
+    if context.parent_context:
+        return context
+
+    # If no thread-local context, try to restore from global store using current trace_id
+    context = monitoring_context_store.retrieve_context()
+    if context and context.parent_context:
+        set_execution_context(context)
+        return context
+    return ExecutionContext()
 
 
 def set_execution_context(context: ExecutionContext) -> None:
-    """Set the current execution context."""
+    """Set the current monitoring execution context and persist it for cross-boundary access."""
     setattr(local, _CONTEXT_KEY, context)
 
+    # Always store in global store for cross-thread access
+    monitoring_context_store.store_context(context)
+
+
+def clear_execution_context() -> None:
+    """Clear the current monitoring execution context."""
+    if hasattr(local, _CONTEXT_KEY):
+        delattr(local, _CONTEXT_KEY)
+    monitoring_context_store.clear_context()
+
 
 def get_parent_context() -> ParentContext:
     return cast(ParentContext, get_execution_context().parent_context)
@@ -38,11 +60,7 @@ def execution_context(
 ) -> Iterator[None]:
     """Context manager for handling execution context."""
     prev_context = get_execution_context()
-    set_trace_id = (
-        prev_context.trace_id
-        if int(prev_context.trace_id)
-        else trace_id or UUID("00000000-0000-0000-0000-000000000000")
-    )
+    set_trace_id = prev_context.trace_id if int(prev_context.trace_id) else trace_id or uuid4()
     set_parent_context = parent_context or prev_context.parent_context
     set_context = ExecutionContext(parent_context=set_parent_context, trace_id=set_trace_id)
     try:

vellum/workflows/emitters/vellum_emitter.py

@@ -1,12 +1,9 @@
 import logging
-import time
-from typing import Any, Dict, Optional
-
-import httpx
+from typing import Optional
 
+from vellum.core.request_options import RequestOptions
 from vellum.workflows.emitters.base import BaseWorkflowEmitter
-from vellum.workflows.events.types import default_serializer
-from vellum.workflows.events.workflow import WorkflowEvent
+from vellum.workflows.events.workflow import WorkflowEvent as SDKWorkflowEvent
 from vellum.workflows.state.base import BaseState
 
 logger = logging.getLogger(__name__)
@@ -43,9 +40,8 @@ class VellumEmitter(BaseWorkflowEmitter):
         super().__init__()
         self._timeout = timeout
         self._max_retries = max_retries
-        self._events_endpoint = "v1/events"  # TODO: make this configurable with the correct url
 
-    def emit_event(self, event: WorkflowEvent) -> None:
+    def emit_event(self, event: SDKWorkflowEvent) -> None:
         """
         Emit a workflow event to Vellum's infrastructure.
 
@@ -59,9 +55,7 @@ class VellumEmitter(BaseWorkflowEmitter):
             return
 
         try:
-            event_data = default_serializer(event)
-
-            self._send_event(event_data)
+            self._send_event(event)
 
         except Exception as e:
             logger.exception(f"Failed to emit event {event.name}: {e}")
@@ -75,70 +69,23 @@ class VellumEmitter(BaseWorkflowEmitter):
         """
         pass
 
-    def _send_event(self, event_data: Dict[str, Any]) -> None:
+    def _send_event(self, event: SDKWorkflowEvent) -> None:
         """
-        Send event data to Vellum's events endpoint with retry logic.
+        Send event to Vellum's events endpoint using client.events.create.
 
         Args:
-            event_data: The serialized event data to send.
+            event: The WorkflowEvent object to send.
         """
         if not self._context:
             logger.warning("Cannot send event: No workflow context registered")
             return
 
         client = self._context.vellum_client
-
-        for attempt in range(self._max_retries + 1):
-            try:
-                # Use the Vellum client's underlying HTTP client to make the request
-                # For proper authentication headers and configuration
-                base_url = client._client_wrapper.get_environment().default
-                response = client._client_wrapper.httpx_client.request(
-                    method="POST",
-                    base_url=base_url,
-                    path=self._events_endpoint,  # TODO: will be replaced with the correct url
-                    json=event_data,
-                    headers=client._client_wrapper.get_headers(),
-                    request_options={"timeout_in_seconds": self._timeout},
-                )
-
-                response.raise_for_status()
-
-                if attempt > 0:
-                    logger.info(f"Event sent successfully after {attempt + 1} attempts")
-                return
-
-            except httpx.HTTPStatusError as e:
-                if e.response.status_code >= 500:
-                    # Server errors might be transient, retry
-                    if attempt < self._max_retries:
-                        wait_time = min(2**attempt, 60)  # Exponential backoff, max 60s
-                        logger.warning(
-                            f"Server error emitting event (attempt {attempt + 1}/{self._max_retries + 1}): "
-                            f"{e.response.status_code}. Retrying in {wait_time}s..."
-                        )
-                        time.sleep(wait_time)
-                        continue
-                    else:
-                        logger.exception(
-                            f"Server error emitting event after {self._max_retries + 1} attempts: "
-                            f"{e.response.status_code} {e.response.text}"
-                        )
-                        return
-                else:
-                    # Client errors (4xx) are not retriable
-                    logger.exception(f"Client error emitting event: {e.response.status_code} {e.response.text}")
-                    return
-
-            except httpx.RequestError as e:
-                if attempt < self._max_retries:
-                    wait_time = min(2**attempt, 60)  # Exponential backoff, max 60s
-                    logger.warning(
-                        f"Network error emitting event (attempt {attempt + 1}/{self._max_retries + 1}): "
-                        f"{e}. Retrying in {wait_time}s..."
-                    )
-                    time.sleep(wait_time)
-                    continue
-                else:
-                    logger.exception(f"Network error emitting event after {self._max_retries + 1} attempts: {e}")
-                    return
+        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_options=request_options,
+        )

vellum/workflows/events/context.py

@@ -2,110 +2,85 @@
 
 import threading
 from uuid import UUID
-from typing import Dict, Optional
+from typing import TYPE_CHECKING, Dict, Optional
 
-from vellum.workflows.context import ExecutionContext
+if TYPE_CHECKING:
+    from vellum.workflows.context import ExecutionContext
 
 DEFAULT_TRACE_ID = UUID("00000000-0000-0000-0000-000000000000")
 
-# Thread-local storage for monitoring execution context
-_monitoring_execution_context: threading.local = threading.local()
-# Thread-local storage for current span_id
-_current_span_id: threading.local = threading.local()
 
-
-class _MonitoringContextStore:
+class MonitoringContextStore:
     """
     thread-safe storage for monitoring contexts.
     handles context persistence and retrieval across threads.
-    relies on the execution context manager for manual retrieval
     """
 
     def __init__(self):
         self._lock = threading.Lock()
-        self._contexts: Dict[str, ExecutionContext] = {}
-        self._thread_contexts: Dict[int, ExecutionContext] = {}
-        self._current_trace_id: Optional[UUID] = None
-
-    def set_current_trace_id(self, trace_id: UUID) -> None:
-        """Set the current active trace_id that should be used by all threads."""
-        if trace_id != DEFAULT_TRACE_ID:
-            with self._lock:
-                self._current_trace_id = trace_id
+        self._contexts: Dict[str, "ExecutionContext"] = {}
 
     def get_current_trace_id(self) -> Optional[UUID]:
         """Get the current active trace_id that should be used by all threads."""
         with self._lock:
-            return self._current_trace_id
-
-    def set_current_span_id(self, span_id: UUID) -> None:
-        """Set the current active span_id for this thread."""
-        _current_span_id.span_id = span_id
-
-    def get_current_span_id(self) -> Optional[UUID]:
-        """Get the current active span_id for this thread."""
-        return getattr(_current_span_id, "span_id", None)
-
-    def store_context(self, context: Optional[ExecutionContext]) -> None:
-        """Store monitoring parent context using multiple keys for reliable retrieval."""
-        if not context or context.parent_context is None:
-            return
+            current_context = self.retrieve_context()
+            return current_context.trace_id if current_context else None
 
+    def store_context(self, context: "ExecutionContext") -> None:
+        """Store monitoring parent context using trace:span:thread keys."""
         thread_id = threading.get_ident()
-        trace_id = self.get_current_trace_id()
-        if context.trace_id != DEFAULT_TRACE_ID and trace_id is None:
-            self.set_current_trace_id(context.trace_id)
+        current_thread = threading.current_thread()
+        trace_id = context.trace_id
 
         with self._lock:
-            # Use trace:span:thread for unique context storage
-            trace_span_thread_key = (
-                f"trace:{str(trace_id)}:span:{str(context.parent_context.span_id)}:thread:{thread_id}"
-            )
-            self._contexts[trace_span_thread_key] = context
-
-    def retrieve_context(self, trace_id: UUID, span_id: Optional[UUID] = None) -> Optional[ExecutionContext]:
-        """Retrieve monitoring parent context with multiple fallback strategies."""
-        thread_id = threading.get_ident()
-        with self._lock:
-            if not span_id:
-                span_id = getattr(_current_span_id, "span_id", None)
-                if not span_id:
-                    return None
-
-            span_key = f"trace:{str(trace_id)}:span:{str(span_id)}:thread:{thread_id}"
-            if span_key in self._contexts:
-                result = self._contexts[span_key]
-                return result
+            # Get span_id from RelationalThread first
+            span_id = None
 
-        return None
+            if context.parent_context and hasattr(context.parent_context, "span_id"):
+                span_id = context.parent_context.span_id
 
+            if not span_id and hasattr(current_thread, "get_parent_span_id"):
+                span_id = current_thread.get_parent_span_id()
 
-# Global instance for cross-boundary context persistence
-_monitoring_context_store = _MonitoringContextStore()
+            # Always use trace:span:thread format - require span_id
+            if span_id:
+                context_key = f"trace:{str(trace_id)}:span:{str(span_id)}:thread:{thread_id}"
+                self._contexts[context_key] = context
 
+    def retrieve_context(self) -> Optional["ExecutionContext"]:
+        """Retrieve monitoring parent context using trace:span:thread keys."""
+        current_thread = threading.current_thread()
+        current_thread_id = current_thread.ident
 
-def get_monitoring_execution_context() -> ExecutionContext:
-    """Get the current monitoring execution context, with intelligent fallback."""
-    if hasattr(_monitoring_execution_context, "context"):
-        context = _monitoring_execution_context.context
-        if context.trace_id != DEFAULT_TRACE_ID and context.parent_context:
-            return context
+        # Get trace_id and span_id directly from the thread if it's a RelationalThread
+        trace_id = None
+        span_id = None
+        if hasattr(current_thread, "get_trace_id"):
+            trace_id = current_thread.get_trace_id()
+        if hasattr(current_thread, "get_parent_span_id"):
+            span_id = current_thread.get_parent_span_id()
 
-    # If no thread-local context, try to restore from global store using current trace_id
-    trace_id = _monitoring_context_store.get_current_trace_id()
-    span_id = _current_span_id.span_id if hasattr(_current_span_id, "span_id") else None
-    if trace_id:
-        if trace_id != DEFAULT_TRACE_ID:
-            context = _monitoring_context_store.retrieve_context(trace_id, span_id)
-            if context:
-                _monitoring_execution_context.context = context
-                return context
-    return ExecutionContext()
+        # Require both trace_id and span_id - no fallback searching
+        if not trace_id or not span_id:
+            return None
 
+        with self._lock:
+            # Try current thread
+            current_key = f"trace:{str(trace_id)}:span:{str(span_id)}:thread:{current_thread_id}"
+            if current_key in self._contexts:
+                return self._contexts[current_key]
+
+            # Try parent thread with same trace and span
+            if hasattr(current_thread, "get_parent_thread"):
+                parent_thread_id = current_thread.get_parent_thread()
+                if parent_thread_id:
+                    parent_key = f"trace:{str(trace_id)}:span:{str(span_id)}:thread:{parent_thread_id}"
+                    if parent_key in self._contexts:
+                        return self._contexts[parent_key]
 
-def set_monitoring_execution_context(context: ExecutionContext) -> None:
-    """Set the current monitoring execution context and persist it for cross-boundary access."""
-    _monitoring_execution_context.context = context
+        return None
 
-    if context.trace_id and context.parent_context:
-        _monitoring_context_store.store_context(context)
+    def clear_context(self):
+        """Clear all stored contexts."""
+        with self._lock:
+            self._contexts.clear()

vellum/workflows/events/node.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING, Any, Dict, Generic, List, Literal, Optional, Set, Type, Union
 
-from pydantic import field_serializer, model_serializer
+from pydantic import SerializationInfo, field_serializer, model_serializer
 
 from vellum.client.core.pydantic_utilities import UniversalBaseModel
 from vellum.workflows.errors import WorkflowError
@@ -82,8 +82,8 @@ class NodeExecutionStreamingEvent(_BaseNodeEvent):
         return self.body.invoked_ports
 
     @model_serializer(mode="plain", when_used="json")
-    def serialize_model(self) -> Any:
-        serialized = super().serialize_model()
+    def serialize_model(self, info: SerializationInfo) -> Any:
+        serialized = super().serialize_model(info)
         if (
             "body" in serialized
             and isinstance(serialized["body"], dict)
@@ -127,8 +127,8 @@ class NodeExecutionFulfilledEvent(_BaseNodeEvent, Generic[OutputsType]):
         return self.body.mocked
 
     @model_serializer(mode="plain", when_used="json")
-    def serialize_model(self) -> Any:
-        serialized = super().serialize_model()
+    def serialize_model(self, info: SerializationInfo) -> Any:
+        serialized = super().serialize_model(info)
         if (
             "body" in serialized
             and isinstance(serialized["body"], dict)

vellum/workflows/events/relational_threads.py

@@ -0,0 +1,41 @@
+import threading
+from uuid import UUID
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    from vellum.workflows.context import ExecutionContext
+
+
+class RelationalThread(threading.Thread):
+    _parent_thread: Optional[int] = None
+    _trace_id: Optional[UUID] = None
+    _parent_span_id: Optional[UUID] = None
+
+    def __init__(self, *args, execution_context: Optional["ExecutionContext"] = None, **kwargs):
+        self._collect_parent_context(execution_context)
+        threading.Thread.__init__(self, *args, **kwargs)
+
+    def _collect_parent_context(self, execution_context: Optional["ExecutionContext"] = None) -> None:
+        """Collect parent thread ID, trace ID, and parent span ID from passed execution context."""
+        self._parent_thread = threading.get_ident()
+
+        # Only use explicitly passed execution context
+        if execution_context:
+            self._trace_id = execution_context.trace_id
+            self._parent_span_id = (
+                execution_context.parent_context.span_id
+                if execution_context.parent_context and hasattr(execution_context.parent_context, "span_id")
+                else None
+            )
+        else:
+            self._trace_id = None
+            self._parent_span_id = None
+
+    def get_parent_thread(self) -> Optional[int]:
+        return self._parent_thread
+
+    def get_trace_id(self) -> Optional[UUID]:
+        return self._trace_id
+
+    def get_parent_span_id(self) -> Optional[UUID]:
+        return self._parent_span_id

vellum/workflows/events/tests/test_basic_workflow.py

@@ -0,0 +1,50 @@
+import logging
+from uuid import uuid4
+
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.context import execution_context
+from vellum.workflows.nodes.bases import BaseNode
+from vellum.workflows.workflows.event_filters import all_workflow_event_filter
+
+
+class StartNode(BaseNode):
+    pass
+
+
+class TrivialWorkflow(BaseWorkflow):
+    graph = StartNode
+
+
+logger = logging.getLogger(__name__)
+
+
+def test_basic_workflow_monitoring_context_flow():
+    """Test that monitoring creates the correct workflow→node context hierarchy using streamed events.
+    What's missing:
+    - span_id from previous event mapping to parent context
+    """
+
+    workflow = TrivialWorkflow()
+
+    with execution_context(trace_id=uuid4()):
+        events = list(workflow.stream(event_filter=all_workflow_event_filter))
+
+    # Verify workflow succeeded
+    assert len(events) >= 2
+    assert events[0].name == "workflow.execution.initiated"
+    assert events[-1].name == "workflow.execution.fulfilled"
+
+    # Collect all events with parent context
+    events_with_parent = [event for event in events if event.parent is not None]
+
+    assert len(events_with_parent) > 0, "Expected at least some events with parent context"
+
+    # Filter for node events
+    node_events = [event for event in events if event.name.startswith("node.")]
+    assert len(node_events) > 0, "Expected at least some node events"
+
+    # Verify each node event has the workflow as its parent context
+    for event in node_events:
+        assert event.parent is not None, "Node event should have parent context"
+        assert event.parent.type == "WORKFLOW", "Node event parent should be workflow"
+        assert event.parent.workflow_definition.name == "TrivialWorkflow", "Parent workflow name mismatch"

vellum/workflows/events/tests/test_event.py

@@ -90,6 +90,7 @@ mock_node_uuid = str(uuid4_from_hash(MockNode.__qualname__))
                     },
                     "display_context": None,
                     "initial_state": None,
+                    "workflow_version_exec_config": None,
                 },
                 "parent": None,
             },

vellum/workflows/events/workflow.py

@@ -2,7 +2,7 @@ from uuid import UUID
 from typing import TYPE_CHECKING, Any, Dict, Generic, Iterable, Literal, Optional, Type, Union
 from typing_extensions import TypeGuard
 
-from pydantic import field_serializer
+from pydantic import SerializationInfo, field_serializer
 
 from vellum.client.core.pydantic_utilities import UniversalBaseModel
 from vellum.workflows.errors import WorkflowError
@@ -77,6 +77,9 @@ class WorkflowExecutionInitiatedBody(_BaseWorkflowExecutionBody, Generic[InputsT
     # that the Workflow Runner can begin populating this field then.
     display_context: Optional[WorkflowEventDisplayContext] = None
 
+    # This field will be populated during serialization by the serialize_body method
+    workflow_version_exec_config: Optional[Any] = None
+
     @field_serializer("inputs")
     def serialize_inputs(self, inputs: InputsType, _info: Any) -> Dict[str, Any]:
         return default_serializer(inputs)
@@ -98,6 +101,17 @@ class WorkflowExecutionInitiatedEvent(_BaseWorkflowEvent, Generic[InputsType, St
     def initial_state(self) -> Optional[StateType]:
         return self.body.initial_state
 
+    @field_serializer("body")
+    def serialize_body(
+        self, body: WorkflowExecutionInitiatedBody[InputsType, StateType], info: SerializationInfo
+    ) -> WorkflowExecutionInitiatedBody[InputsType, StateType]:
+        context = info.context if info and hasattr(info, "context") else {}
+        if context and "event_enricher" in context and callable(context["event_enricher"]):
+            event = context["event_enricher"](self)
+            return event.body
+        else:
+            return body
+
 
 class WorkflowExecutionStreamingBody(_BaseWorkflowExecutionBody):
     output: BaseOutput

vellum/workflows/expressions/contains.py

@@ -35,4 +35,11 @@ class ContainsExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
             )
 
         rhs = resolve_value(self._rhs, state)
+
+        if isinstance(rhs, dict):
+            raise InvalidExpressionException(
+                "Cannot use dict as right-hand side of contains operation. "
+                "Use dict keys/values or convert to strings for comparison."
+            )
+
         return rhs in lhs