vellum-ai 0.14.63__py3-none-any.whl → 1.11.2__py3-none-any.whl

vellum/utils/files/upload.py

@@ -0,0 +1,151 @@
+"""File upload utilities for uploading files to Vellum."""
+
+import base64
+from io import BytesIO
+import logging
+import re
+from typing import TYPE_CHECKING, Optional
+
+import requests
+
+from vellum.client.core.api_error import ApiError
+from vellum.client.core.file import File
+from vellum.utils.files.constants import BASE64_DATA_URL_PATTERN, URL_PATTERN, VELLUM_FILE_SRC_PATTERN
+from vellum.utils.files.exceptions import FileNotFoundError, FileRetrievalError, InvalidFileSourceError
+from vellum.utils.files.extensions import ensure_filename_with_extension
+from vellum.utils.files.types import VellumFileTypes
+
+if TYPE_CHECKING:
+    from vellum.client import Vellum as VellumClient
+
+logger = logging.getLogger(__name__)
+
+
+def upload_vellum_file(
+    vellum_file: VellumFileTypes,
+    *,
+    filename: Optional[str] = None,
+    vellum_client: Optional["VellumClient"] = None,
+) -> VellumFileTypes:
+    """
+    Upload a file to Vellum and return a new VellumFile with the uploaded source.
+
+    This function takes any VellumFile object (with a src that could be a base64 data URL,
+    HTTP/HTTPS URL, or existing vellum:uploaded-file: identifier), downloads its content,
+    and uploads it to Vellum's storage.
+
+    Args:
+        vellum_file: A VellumDocument, VellumImage, VellumAudio, or VellumVideo instance
+        filename: Optional filename to use when uploading. If not provided, defaults to "file"
+                 with an appropriate extension inferred from the MIME type. If provided without
+                 an extension, the extension will be automatically added based on the MIME type.
+        vellum_client: An optional Vellum client instance. If not provided, a default client will be created.
+
+    Returns:
+        VellumFileTypes: A new VellumFile of the same type with the vellum:uploaded-file:{id} source
+
+    Raises:
+        InvalidFileSourceError: If the file source format is invalid
+        FileRetrievalError: If the file cannot be retrieved from its source
+        FileNotFoundError: If the file is not found at its source
+
+    Example:
+        ```python
+        from vellum import VellumDocument, VellumImage
+        from vellum.utils.files import upload_vellum_file
+
+        # Upload a document from a URL
+        doc = VellumDocument(src="https://example.com/doc.pdf")
+        uploaded_doc = upload_vellum_file(doc, filename="my_document.pdf")
+
+        # Upload a base64-encoded image (filename automatically inferred as "file.png")
+        image = VellumImage(src="data:image/png;base64,iVBORw0KGgo...")
+        uploaded_image = upload_vellum_file(image)
+
+        # Upload with filename without extension (extension automatically added)
+        doc = VellumDocument(src="data:application/pdf;base64,...")
+        uploaded_doc = upload_vellum_file(doc, filename="report")  # becomes "report.pdf"
+        ```
+    """
+    src = vellum_file.src
+
+    # Case 1: Vellum Uploaded File (already uploaded, just return as-is)
+    match = re.match(VELLUM_FILE_SRC_PATTERN, src, re.IGNORECASE)
+    if match:
+        vellum_uploaded_file_id = match.group(1)
+        logger.info(
+            "File already uploaded to Vellum, returning unchanged",
+            extra={"vellum_uploaded_file_id": vellum_uploaded_file_id},
+        )
+        return vellum_file
+
+    if vellum_client is None:
+        from vellum.utils.vellum_client import create_vellum_client
+
+        vellum_client = create_vellum_client()
+
+    # Case 2: Base64 Data URL
+    data_url_match = re.match(BASE64_DATA_URL_PATTERN, src)
+    if data_url_match:
+        mime_type = data_url_match.group(1) or "application/octet-stream"
+        base64_content = data_url_match.group(3)
+        decoded = base64.b64decode(base64_content)
+
+        # Ensure filename has appropriate extension
+        resolved_filename = ensure_filename_with_extension(filename, mime_type)
+        file_content: File = (resolved_filename, BytesIO(decoded), mime_type)
+
+        try:
+            uploaded_file = vellum_client.uploaded_files.create(file=file_content)
+        except ApiError as e:
+            raise FileRetrievalError(f"Failed to upload file to Vellum: {str(e)}") from e
+
+        new_src = f"vellum:uploaded-file:{uploaded_file.id}"
+        return _copy_with_new_src(vellum_file, new_src)
+
+    # Case 3: Direct URL
+    if not re.match(URL_PATTERN, src):
+        raise InvalidFileSourceError(
+            f"Invalid file source: {src}. "
+            "Expected a base64 data URL (data:...;base64,...), "
+            "a Vellum uploaded file ID (vellum:uploaded-file:...), "
+            "or an HTTP/HTTPS URL."
+        )
+
+    file_url = src
+
+    # Download from URL
+    try:
+        response = requests.get(file_url, stream=True)
+        response.raise_for_status()
+    except requests.HTTPError as e:
+        if e.response.status_code == 404:
+            raise FileNotFoundError(f"File not found at URL: {file_url}") from e
+        raise FileRetrievalError(f"Failed to retrieve file from URL: {file_url}") from e
+    except requests.RequestException as e:
+        raise FileRetrievalError(f"Network error while retrieving file: {file_url}") from e
+
+    # Read content and get content type
+    content = response.content
+    content_type = response.headers.get("content-type", "application/octet-stream")
+
+    # Ensure filename has appropriate extension
+    resolved_filename = ensure_filename_with_extension(filename, content_type)
+    file_content = (resolved_filename, BytesIO(content), content_type)
+
+    try:
+        uploaded_file = vellum_client.uploaded_files.create(file=file_content)
+    except ApiError as e:
+        raise FileRetrievalError("Failed to upload file to Vellum") from e
+
+    new_src = f"vellum:uploaded-file:{uploaded_file.id}"
+    return _copy_with_new_src(vellum_file, new_src)
+
+
+def _copy_with_new_src(vellum_file: VellumFileTypes, new_src: str) -> VellumFileTypes:
+    """Helper to create a copy of a VellumFile with an updated src."""
+    # Use model_copy for Pydantic v2, copy for v1
+    if hasattr(vellum_file, "model_copy"):
+        return vellum_file.model_copy(update={"src": new_src})
+    else:
+        return vellum_file.copy(update={"src": new_src})

vellum/utils/files/urls.py

@@ -0,0 +1,71 @@
+"""File upload utilities for uploading files to Vellum."""
+
+import logging
+import re
+from typing import TYPE_CHECKING, Optional
+
+from vellum.client.core.api_error import ApiError
+from vellum.utils.files.constants import VELLUM_FILE_SRC_PATTERN
+from vellum.utils.files.exceptions import FileRetrievalError, InvalidFileSourceError
+from vellum.utils.files.types import VellumFileTypes
+from vellum.utils.files.upload import upload_vellum_file
+
+if TYPE_CHECKING:
+    from vellum.client import Vellum as VellumClient
+
+logger = logging.getLogger(__name__)
+
+
+def get_signed_url(
+    vellum_file: VellumFileTypes,
+    *,
+    expiry_seconds: int = 7 * 24 * 60 * 60,  # 7 days
+    vellum_client: Optional["VellumClient"] = None,
+) -> str:
+    """
+    Retrieved a signed url for a file that's been uploaded to Vellum
+
+    This function takes any VellumFile object (with a src that could be a base64 data URL,
+    HTTP/HTTPS URL, or existing vellum:uploaded-file: identifier), uploads it to Vellum (if not already uploaded),
+    and returns a signed url for accessing the file.
+
+    Args:
+        vellum_file: A VellumDocument, VellumImage, VellumAudio, or VellumVideo instance
+        expiry_seconds: The number of seconds until the signed URL expires. Defaults to 7 days.
+        vellum_client: An optional Vellum client instance. If not provided, a default client will be created.
+
+    Returns:
+        str: A signed URL for accessing the uploaded file
+    """
+
+    # Upload the file to Vellum if it isn't already
+    uploaded_file = upload_vellum_file(vellum_file, vellum_client=vellum_client)
+
+    # Parse out its reference ID
+    vellum_uploaded_file_id: Optional[str] = None
+    src = uploaded_file.src
+    match = re.match(VELLUM_FILE_SRC_PATTERN, src, re.IGNORECASE)
+    if match:
+        vellum_uploaded_file_id = match.group(1)
+
+    if not vellum_uploaded_file_id:
+        raise InvalidFileSourceError("Failed to determine id of uploaded file.")
+
+    if vellum_client is None:
+        from vellum.utils.vellum_client import create_vellum_client
+
+        vellum_client = create_vellum_client()
+
+    # Fetch the signed URL for this file from Vellum
+    try:
+        vellum_uploaded_file = vellum_client.uploaded_files.retrieve(
+            vellum_uploaded_file_id, expiry_seconds=expiry_seconds
+        )
+    except ApiError as e:
+        raise FileRetrievalError("Failed to retrieve file from Vellum") from e
+
+    signed_url = vellum_uploaded_file.file_url
+    if not signed_url:
+        raise FileRetrievalError("Failed to retrieve signed URL for uploaded file.")
+
+    return signed_url

vellum/utils/json_encoder.py

@@ -0,0 +1,95 @@
+from dataclasses import asdict, is_dataclass
+from datetime import datetime
+import enum
+from json import JSONEncoder
+from queue import Queue
+from uuid import UUID
+from typing import Any, Callable, Dict, Protocol, Type
+
+from pydantic import BaseModel
+from pydantic.fields import FieldInfo
+from pydantic_core import PydanticUndefined
+
+# Handle Pydantic v1 compatibility
+try:
+    from pydantic.fields import Undefined as PydanticV1Undefined  # type: ignore[attr-defined]
+except ImportError:
+    PydanticV1Undefined = None  # type: ignore[assignment,misc]
+
+
+class VellumJsonEncodable(Protocol):
+    """Protocol for objects that can be encoded to JSON by VellumJsonEncoder.
+
+    Classes implementing this protocol must define a __vellum_encode__ method
+    that returns a JSON-serializable representation of the object.
+    """
+
+    def __vellum_encode__(self) -> Any:
+        """Return a JSON-serializable representation of this object."""
+        ...
+
+
+class VellumJsonEncoder(JSONEncoder):
+    """JSON encoder that handles Vellum-specific types.
+
+    This encoder supports:
+    - Objects implementing VellumJsonEncodable protocol
+    - Pydantic BaseModel instances
+    - Pydantic FieldInfo objects (serializes to default value or None)
+    - PydanticUndefined (serializes to None)
+    - UUIDs, sets, datetimes, enums
+    - Dataclasses and Queue objects
+    - Custom encoder registry via encoders dict
+    """
+
+    encoders: Dict[Type, Callable] = {}
+
+    def default(self, obj: Any) -> Any:
+        if hasattr(obj, "__vellum_encode__") and callable(getattr(obj, "__vellum_encode__")):
+            return obj.__vellum_encode__()
+
+        if isinstance(obj, UUID):
+            return str(obj)
+
+        if isinstance(obj, set):
+            return list(obj)
+
+        if isinstance(obj, BaseModel):
+            return obj.model_dump()
+
+        if isinstance(obj, datetime):
+            return obj.isoformat()
+
+        if isinstance(obj, enum.Enum):
+            return obj.value
+
+        if isinstance(obj, Queue):
+            return list(obj.queue)
+
+        if is_dataclass(obj) and not isinstance(obj, type):
+            return asdict(obj)
+
+        if isinstance(obj, type):
+            return str(obj)
+
+        if isinstance(obj, Exception):
+            return str(obj)
+
+        # Handle Pydantic FieldInfo objects
+        if isinstance(obj, FieldInfo):
+            # Serialize the default value if it exists and is not undefined (v1 or v2), otherwise None
+            is_undefined = obj.default is PydanticUndefined or (
+                PydanticV1Undefined is not None and obj.default is PydanticV1Undefined
+            )
+            if not is_undefined and obj.default is not None:
+                return obj.default
+            return None
+
+        # Handle PydanticUndefined value
+        if obj is PydanticUndefined:
+            return None
+
+        if obj.__class__ in self.encoders:
+            return self.encoders[obj.__class__](obj)
+
+        return super().default(obj)

vellum/utils/templating/custom_filters.py

@@ -4,7 +4,7 @@ from typing import Any, Union
 from jinja2 import Undefined
 from jinja2.utils import htmlsafe_json_dumps
 
-from vellum.workflows.state.encoder import DefaultStateEncoder
+from vellum.utils.json_encoder import VellumJsonEncoder
 
 
 def is_valid_json_string(value: Union[str, bytes]) -> bool:
@@ -19,11 +19,11 @@ def is_valid_json_string(value: Union[str, bytes]) -> bool:
 
 def replace(s: Any, old: Any, new: Any) -> str:
     def encode_to_str(obj: Any) -> str:
-        """Encode an object for template rendering using DefaultStateEncoder."""
+        """Encode an object for template rendering using VellumJsonEncoder."""
         try:
             if isinstance(obj, str):
                 return obj
-            return json.dumps(obj, cls=DefaultStateEncoder)
+            return json.dumps(obj, cls=VellumJsonEncoder)
         except TypeError:
             return str(obj)
 
@@ -39,4 +39,4 @@ def replace(s: Any, old: Any, new: Any) -> str:
 def safe_tojson(value: Any) -> str:
     if isinstance(value, Undefined):
         return ""
-    return htmlsafe_json_dumps(value, cls=DefaultStateEncoder)
+    return htmlsafe_json_dumps(value, cls=VellumJsonEncoder)

vellum/utils/templating/render.py

@@ -4,17 +4,17 @@ from typing import Any, Dict, Optional
 from jinja2.sandbox import SandboxedEnvironment
 from pydantic import BaseModel
 
+from vellum.utils.json_encoder import VellumJsonEncoder
 from vellum.utils.templating.constants import FilterFunc
 from vellum.utils.templating.exceptions import JinjaTemplateError
-from vellum.workflows.state.encoder import DefaultStateEncoder
 
 
 def finalize(obj: Any) -> str:
     if isinstance(obj, (dict, list)):
-        return json.dumps(obj, cls=DefaultStateEncoder)
+        return json.dumps(obj, cls=VellumJsonEncoder)
 
     if isinstance(obj, BaseModel):
-        return json.dumps(obj.model_dump(), cls=DefaultStateEncoder)
+        return json.dumps(obj.model_dump(), cls=VellumJsonEncoder)
 
     return str(obj)
 
@@ -33,7 +33,7 @@ def render_sandboxed_jinja_template(
             finalize=finalize,
         )
         environment.policies["json.dumps_kwargs"] = {
-            "cls": DefaultStateEncoder,
+            "cls": VellumJsonEncoder,
         }
 
         if jinja_custom_filters:

vellum/utils/tests/test_json_encoder.py

@@ -0,0 +1,92 @@
+import json
+
+from pydantic import BaseModel, Field
+from pydantic.fields import FieldInfo
+
+from vellum.utils.json_encoder import VellumJsonEncoder
+
+
+class TestVellumJsonEncoder:
+    """Tests for VellumJsonEncoder."""
+
+    def test_encode_fieldinfo_with_default(self):
+        """Test that FieldInfo objects with defaults are serialized to their default value."""
+        # Create a FieldInfo with a default value
+        field_info = Field(default="default_value")
+
+        result = json.dumps({"field": field_info}, cls=VellumJsonEncoder)
+        assert result == '{"field": "default_value"}'
+
+    def test_encode_fieldinfo_without_default(self):
+        """Test that FieldInfo objects without defaults are serialized to None."""
+        # Create a FieldInfo without a default value (annotation only)
+        field_info = FieldInfo(annotation=str)
+
+        result = json.dumps({"field": field_info}, cls=VellumJsonEncoder)
+        assert result == '{"field": null}'
+
+    def test_encode_nested_dict_with_fieldinfo(self):
+        """Test that nested structures containing FieldInfo are properly serialized."""
+        field_info_with_default = Field(default=42)
+        field_info_without_default = FieldInfo(annotation=int)
+
+        data = {
+            "config": {
+                "cron": field_info_with_default,
+                "timezone": field_info_without_default,
+                "regular_value": "test",
+            }
+        }
+
+        result = json.dumps(data, cls=VellumJsonEncoder)
+        expected = '{"config": {"cron": 42, "timezone": null, "regular_value": "test"}}'
+        assert result == expected
+
+    def test_encode_list_with_fieldinfo(self):
+        """Test that lists containing FieldInfo are properly serialized."""
+        field_info = Field(default="item")
+
+        data = [field_info, "normal_string", field_info]
+
+        result = json.dumps(data, cls=VellumJsonEncoder)
+        assert result == '["item", "normal_string", "item"]'
+
+    def test_encode_fieldinfo_with_default_factory(self):
+        """Test that FieldInfo objects with default_factory are serialized properly."""
+
+        field_info = Field(
+            default_factory=lambda: {
+                "key1": "value1",
+                "key2": "value2",
+            }
+        )
+
+        data = {"test": field_info}
+
+        result = json.dumps(data, cls=VellumJsonEncoder)
+        # Note: When a FieldInfo has default_factory instead of default,
+        # the default attribute will be PydanticUndefined, which should serialize to None.
+        assert result == '{"test": null}'
+
+    def test_encode_basemodel_with_default_factory(self):
+        """
+        Tests that BaseModel instances with default_factory fields serialize correctly.
+
+        This demonstrates that when pushing workflows to Vellum, the default_factory
+        values are preserved because Pydantic invokes the factory during model instantiation.
+        """
+
+        class ConfigModel(BaseModel):
+            settings: dict = Field(default_factory=lambda: {"key1": "value1", "key2": "value2"})
+            name: str = "test"
+
+        model_instance = ConfigModel()
+
+        assert model_instance.settings == {"key1": "value1", "key2": "value2"}
+
+        # AND when we serialize the model instance with VellumJsonEncoder
+        result = json.dumps(model_instance, cls=VellumJsonEncoder)
+
+        deserialized = json.loads(result)
+        assert deserialized["settings"] == {"key1": "value1", "key2": "value2"}
+        assert deserialized["name"] == "test"

vellum/utils/vellum_client.py

@@ -0,0 +1,40 @@
+import os
+from typing import List, Optional
+
+from vellum import Vellum, VellumEnvironment
+from vellum.client.types.api_version_enum import ApiVersionEnum
+
+
+def create_vellum_client(
+    api_key: Optional[str] = None,
+    api_url: Optional[str] = None,
+    api_version: Optional[ApiVersionEnum] = None,
+) -> Vellum:
+    if api_key is None:
+        api_key = os.getenv("VELLUM_API_KEY", default="")
+
+    return Vellum(
+        api_key=api_key,
+        environment=create_vellum_environment(api_url),
+        api_version=api_version,
+    )
+
+
+def create_vellum_environment(api_url: Optional[str] = None) -> VellumEnvironment:
+    return VellumEnvironment(
+        default=_resolve_env([api_url, "VELLUM_DEFAULT_API_URL", "VELLUM_API_URL"], "https://api.vellum.ai"),
+        documents=_resolve_env([api_url, "VELLUM_DOCUMENTS_API_URL", "VELLUM_API_URL"], "https://documents.vellum.ai"),
+        predict=_resolve_env([api_url, "VELLUM_PREDICT_API_URL", "VELLUM_API_URL"], "https://predict.vellum.ai"),
+    )
+
+
+def _resolve_env(names: List[Optional[str]], default: str = "") -> str:
+    for name in names:
+        if not name:
+            continue
+
+        value = os.getenv(name)
+        if value:
+            return value
+
+    return default

vellum/workflows/__init__.py

@@ -1,5 +1,83 @@
+from .constants import APIRequestMethod, AuthorizationType
+from .errors.types import WorkflowErrorCode
+from .exceptions import NodeException
+from .inputs import BaseInputs, DatasetRow
+from .nodes import (
+    APINode,
+    BaseInlinePromptNode,
+    BaseNode,
+    BasePromptDeploymentNode,
+    BaseSearchNode,
+    CodeExecutionNode,
+    ConditionalNode,
+    ErrorNode,
+    FinalOutputNode,
+    GuardrailNode,
+    InlinePromptNode,
+    InlineSubworkflowNode,
+    MapNode,
+    NoteNode,
+    PromptDeploymentNode,
+    RetryNode,
+    SearchNode,
+    SubworkflowDeploymentNode,
+    TemplatingNode,
+    TryNode,
+    WebSearchNode,
+)
+from .nodes.displayable.tool_calling_node import ToolCallingNode
+from .ports import Port
+from .references.environment_variable import EnvironmentVariableReference
+from .references.lazy import LazyReference
+from .runner import WorkflowRunner
+from .sandbox import WorkflowSandboxRunner
+from .state.base import BaseState
+from .triggers import IntegrationTrigger, ScheduleTrigger
+from .types.core import Json, MergeBehavior
+from .types.definition import DeploymentDefinition, MCPServer, VellumIntegrationToolDefinition
 from .workflows import BaseWorkflow
 
 __all__ = [
+    "APINode",
+    "APIRequestMethod",
+    "AuthorizationType",
+    "BaseInlinePromptNode",
+    "BaseInputs",
+    "BaseNode",
+    "BasePromptDeploymentNode",
+    "BaseSearchNode",
+    "BaseState",
     "BaseWorkflow",
+    "CodeExecutionNode",
+    "ConditionalNode",
+    "DatasetRow",
+    "DeploymentDefinition",
+    "EnvironmentVariableReference",
+    "ErrorNode",
+    "FinalOutputNode",
+    "GuardrailNode",
+    "InlinePromptNode",
+    "InlineSubworkflowNode",
+    "IntegrationTrigger",
+    "Json",
+    "LazyReference",
+    "MapNode",
+    "MCPServer",
+    "MergeBehavior",
+    "NodeException",
+    "NoteNode",
+    "Port",
+    "PromptDeploymentNode",
+    "RetryNode",
+    "ScheduleTrigger",
+    "SearchNode",
+    "SubworkflowDeploymentNode",
+    "TemplatingNode",
+    "ToolCallingNode",
+    "TryNode",
+    "VellumIntegrationToolDefinition",
+    "WebSearchNode",
+    "WorkflowErrorCode",
+    "WorkflowRunner",
+    "WorkflowSandboxRunner",
 ]

vellum/workflows/constants.py

@@ -22,6 +22,9 @@ class _UndefMeta(type):
 
         return super().__getattribute__(name)
 
+    def __str__(cls) -> str:
+        return ""
+
     def __bool__(cls) -> bool:
         return False
 
@@ -55,3 +58,7 @@ class APIRequestMethod(Enum):
 class AuthorizationType(Enum):
     BEARER_TOKEN = "BEARER_TOKEN"
     API_KEY = "API_KEY"
+
+
+class VellumIntegrationProviderType(Enum):
+    COMPOSIO = "COMPOSIO"

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: