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

vellum/client/types/workflow_result_event_state.py

@@ -0,0 +1,7 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+WorkflowResultEventState = typing.Union[
+    typing.Literal["INITIATED", "STREAMING", "FULFILLED", "REJECTED", "PENDING"], typing.Any
+]

vellum/client/types/workflow_sandbox_display_data.py

@@ -0,0 +1,27 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+from .workflow_display_icon import WorkflowDisplayIcon
+
+
+class WorkflowSandboxDisplayData(UniversalBaseModel):
+    """
+    Information used to display this Workflow Sandbox.
+    """
+
+    icon: typing.Optional[WorkflowDisplayIcon] = pydantic.Field(default=None)
+    """
+    The icon associated with this Workflow Sandbox.
+    """
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

vellum/client/types/workflow_sandbox_example.py

@@ -1,9 +1,9 @@
 # This file was auto-generated by Fern from our API Definition.
 
-from ..core.pydantic_utilities import UniversalBaseModel
 import typing
-from ..core.pydantic_utilities import IS_PYDANTIC_V2
+
 import pydantic
+from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
 
 
 class WorkflowSandboxExample(UniversalBaseModel):
@@ -11,6 +11,8 @@ class WorkflowSandboxExample(UniversalBaseModel):
     label: str
     description: typing.Optional[str] = None
     icon_name: typing.Optional[str] = None
+    ui_image_url: typing.Optional[str] = None
+    code_image_url: typing.Optional[str] = None
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2

vellum/client/types/workflow_sandbox_execute_node_response.py

@@ -0,0 +1,8 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+from .node_execution_fulfilled_event import NodeExecutionFulfilledEvent
+from .node_execution_rejected_event import NodeExecutionRejectedEvent
+
+WorkflowSandboxExecuteNodeResponse = typing.Union[NodeExecutionFulfilledEvent, NodeExecutionRejectedEvent]

vellum/client/types/workflow_sandbox_parent_context.py

@@ -1,11 +1,11 @@
 # This file was auto-generated by Fern from our API Definition.
 
 from __future__ import annotations
-from ..core.pydantic_utilities import UniversalBaseModel
+
 import typing
-from ..core.pydantic_utilities import IS_PYDANTIC_V2
+
 import pydantic
-from ..core.pydantic_utilities import update_forward_refs
+from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel, update_forward_refs
 
 
 class WorkflowSandboxParentContext(UniversalBaseModel):
@@ -27,12 +27,15 @@ class WorkflowSandboxParentContext(UniversalBaseModel):
             extra = pydantic.Extra.allow
 
 
-from .api_request_parent_context import ApiRequestParentContext  # noqa: E402
-from .node_parent_context import NodeParentContext  # noqa: E402
-from .prompt_deployment_parent_context import PromptDeploymentParentContext  # noqa: E402
-from .span_link import SpanLink  # noqa: E402
-from .workflow_deployment_parent_context import WorkflowDeploymentParentContext  # noqa: E402
-from .workflow_parent_context import WorkflowParentContext  # noqa: E402
-from .parent_context import ParentContext  # noqa: E402
+from .api_request_parent_context import ApiRequestParentContext  # noqa: E402, F401, I001
+from .external_parent_context import ExternalParentContext  # noqa: E402, F401, I001
+from .integration_trigger_context import IntegrationTriggerContext  # noqa: E402, F401, I001
+from .node_parent_context import NodeParentContext  # noqa: E402, F401, I001
+from .prompt_deployment_parent_context import PromptDeploymentParentContext  # noqa: E402, F401, I001
+from .scheduled_trigger_context import ScheduledTriggerContext  # noqa: E402, F401, I001
+from .span_link import SpanLink  # noqa: E402, F401, I001
+from .workflow_deployment_parent_context import WorkflowDeploymentParentContext  # noqa: E402, F401, I001
+from .workflow_parent_context import WorkflowParentContext  # noqa: E402, F401, I001
+from .parent_context import ParentContext  # noqa: E402, F401, I001
 
 update_forward_refs(WorkflowSandboxParentContext)

vellum/client/types/workflow_stream_event.py

@@ -1,7 +1,8 @@
 # This file was auto-generated by Fern from our API Definition.
 
 import typing
-from .workflow_execution_workflow_result_event import WorkflowExecutionWorkflowResultEvent
+
 from .workflow_execution_node_result_event import WorkflowExecutionNodeResultEvent
+from .workflow_execution_workflow_result_event import WorkflowExecutionWorkflowResultEvent
 
 WorkflowStreamEvent = typing.Union[WorkflowExecutionWorkflowResultEvent, WorkflowExecutionNodeResultEvent]

vellum/client/types/workspace_display_config.py

@@ -0,0 +1,19 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+
+
+class WorkspaceDisplayConfig(UniversalBaseModel):
+    color: typing.Optional[str] = None
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

vellum/client/types/workspace_read.py

@@ -1,11 +1,12 @@
 # This file was auto-generated by Fern from our API Definition.
 
-from ..core.pydantic_utilities import UniversalBaseModel
-import pydantic
 import datetime as dt
-from ..core.pydantic_utilities import IS_PYDANTIC_V2
 import typing
 
+import pydantic
+from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+from .workspace_display_config import WorkspaceDisplayConfig
+
 
 class WorkspaceRead(UniversalBaseModel):
     id: str
@@ -16,6 +17,7 @@ class WorkspaceRead(UniversalBaseModel):
 
     label: str
     created: dt.datetime
+    display_config: typing.Optional[WorkspaceDisplayConfig] = None
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2

vellum/client/types/workspace_secret_read.py

@@ -1,11 +1,11 @@
 # This file was auto-generated by Fern from our API Definition.
 
-from ..core.pydantic_utilities import UniversalBaseModel
 import datetime as dt
-from .secret_type_enum import SecretTypeEnum
-from ..core.pydantic_utilities import IS_PYDANTIC_V2
 import typing
+
 import pydantic
+from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+from .secret_type_enum import SecretTypeEnum
 
 
 class WorkspaceSecretRead(UniversalBaseModel):

vellum/client/utils.py

@@ -0,0 +1,24 @@
+# Custom client utilities
+# This file is not generated by Fern and can be freely edited
+
+from uuid import UUID
+from typing import Optional
+from pydantic import SerializationInfo
+
+
+def convert_input_variable_to_uuid(value: str, info: Optional[SerializationInfo] = None) -> str:
+    """Convert input_variable to UUID using executable_id from context."""
+    # Check if value is already a valid UUID
+    try:
+        UUID(value)
+        return value  # Already a UUID, return as-is
+    except ValueError:
+        pass  # Not a UUID, continue with conversion logic
+
+    if info and hasattr(info, "context") and info.context:
+        executable_id = info.context.get("executable_id")
+        if executable_id:
+            from vellum.workflows.utils.uuids import uuid4_from_hash  # avoid circular import
+
+            return str(uuid4_from_hash(f"{executable_id}|{value}"))
+    return value

vellum/core/force_multipart.py

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

vellum/core/http_response.py

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

vellum/errors/misdirected_request_error.py

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

vellum/errors/too_many_requests_error.py

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

vellum/errors/unauthorized_error.py

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

vellum/evaluations/resources.py

@@ -8,11 +8,7 @@ from typing import Callable, Generator, Iterable, List, cast
 
 from vellum import TestSuiteRunMetricNumberOutput, TestSuiteRunRead
 from vellum.client import OMIT, Vellum
-from vellum.evaluations.constants import DEFAULT_MAX_POLLING_DURATION_MS, DEFAULT_POLLING_INTERVAL_MS
-from vellum.evaluations.exceptions import TestSuiteRunResultsException
-from vellum.evaluations.utils.env import get_api_key
-from vellum.evaluations.utils.paginator import PaginatedResults, get_all_results
-from vellum.types import (
+from vellum.client.types import (
     ExternalTestCaseExecutionRequest,
     NamedTestCaseVariableValueRequest,
     TestCaseVariableValue,
@@ -22,6 +18,10 @@ from vellum.types import (
     TestSuiteRunMetricOutput,
     TestSuiteRunState,
 )
+from vellum.evaluations.constants import DEFAULT_MAX_POLLING_DURATION_MS, DEFAULT_POLLING_INTERVAL_MS
+from vellum.evaluations.exceptions import TestSuiteRunResultsException
+from vellum.evaluations.utils.env import get_api_key
+from vellum.evaluations.utils.paginator import PaginatedResults, get_all_results
 from vellum.utils.typing import cast_not_optional
 from vellum.utils.uuid import is_valid_uuid
 

vellum/plugins/pydantic.py

@@ -28,9 +28,12 @@ def import_base_descriptor():
     """
     We have to avoid importing from vellum.* in this file because it will cause a circular import.
     """
-    from vellum.workflows.descriptors.base import BaseDescriptor
+    try:
+        from vellum.workflows.descriptors.base import BaseDescriptor
 
-    return BaseDescriptor
+        return BaseDescriptor
+    except Exception:
+        return None
 
 
 # https://docs.pydantic.dev/2.8/concepts/plugins/#build-a-plugin
@@ -45,6 +48,7 @@ class OnValidatePython(ValidatePythonHandlerProtocol):
         from_attributes: Optional[bool] = None,
         context: Optional[Dict[str, Any]] = None,
         self_instance: Optional[Any] = None,
+        extra: Optional[Literal["allow", "ignore", "forbid"]] = None,
         allow_partial: Union[bool, Literal["off", "on", "trailing-strings"]] = False,
         by_alias: Optional[bool] = None,
         by_name: Optional[bool] = None,
@@ -60,6 +64,10 @@ class OnValidatePython(ValidatePythonHandlerProtocol):
         self.tracked_descriptors = {}
         BaseDescriptor = import_base_descriptor()
 
+        # If BaseDescriptor import failed, skip descriptor processing
+        if BaseDescriptor is None:
+            return
+
         for key, value in input.items():
             field_info = model_fields.get(key)
             if isinstance(value, BaseDescriptor) and (
@@ -71,7 +79,10 @@ class OnValidatePython(ValidatePythonHandlerProtocol):
                 self.tracked_descriptors[key] = value
                 # TODO: This does not yet work for descriptors that map to more complex types
                 # https://app.shortcut.com/vellum/story/4636
-                input[key] = value.types[0]()
+                if len(value.types) == 0:
+                    input[key] = dict()
+                else:
+                    input[key] = value.types[0]()
 
     def on_success(self, result: Any) -> None:
         if self.tracked_descriptors:

vellum/plugins/tests/test_pydantic.py

@@ -0,0 +1,30 @@
+from typing import Any
+
+from pydantic import BaseModel
+
+from vellum.workflows.expressions.accessor import AccessorExpression
+from vellum.workflows.references.constant import ConstantValueReference
+from vellum.workflows.state.base import BaseState
+
+
+class TestState(BaseState):
+    pass
+
+
+class TestModel(BaseModel):
+    field: Any
+
+
+def test_pydantic_plugin__empty_types_descriptor():
+    """
+    Test that the pydantic plugin handles BaseDescriptor with empty types gracefully.
+    """
+
+    base_ref = ConstantValueReference({"name": "test"})
+    accessor = AccessorExpression(base=base_ref, field="name")
+
+    model = TestModel(field=accessor)
+
+    assert model is not None
+    assert hasattr(model, "field")
+    assert model.field == accessor

vellum/plugins/vellum_mypy.py

@@ -20,37 +20,76 @@ from mypy.types import AnyType, CallableType, FunctionLike, Instance, Type as My
 
 TypeResolver = Callable[[str, List[MypyType]], MypyType]
 NODE_ATTRIBUTE_REGEX = r"^[a-z].*$"
+BASE_NODE_FULLNAME = "vellum.workflows.nodes.bases.base.BaseNode"
 
-DESCRIPTOR_PATHS: list[tuple[str, str, str]] = [
+# Pre-compile regex patterns for better performance
+NODE_ATTRIBUTE_PATTERN = re.compile(NODE_ATTRIBUTE_REGEX)
+NON_UNDERSCORE_PATTERN = re.compile(r"^[^_].*$")
+COUNT_PATTERN = re.compile(r"^count$")
+
+# Check if mypy.nodes.TypeAlias supports the 'module' parameter (added in mypy 1.14+)
+_MYPY_TYPE_ALIAS_HAS_MODULE = hasattr(MypyTypeAlias, "module")
+
+
+def _create_type_alias(
+    target: MypyType,
+    fullname: str,
+    line: int,
+    column: int,
+    module: Optional[str] = None,
+) -> MypyTypeAlias:
+    """Create a TypeAlias with backward compatibility for different mypy versions.
+
+    In mypy 1.14+, the TypeAlias constructor requires a 'module' parameter.
+    This helper function handles both old and new mypy versions.
+    """
+    if _MYPY_TYPE_ALIAS_HAS_MODULE:
+        return MypyTypeAlias(  # type: ignore[call-arg]
+            target=target,
+            fullname=fullname,
+            module=module,
+            line=line,
+            column=column,
+        )
+    else:
+        return MypyTypeAlias(
+            target=target,
+            fullname=fullname,
+            line=line,
+            column=column,
+        )
+
+
+DESCRIPTOR_PATHS: list[tuple[str, str, re.Pattern[str]]] = [
     (
         "vellum.workflows.outputs.base.BaseOutputs",
         "vellum.workflows.references.output.OutputReference",
-        r"^[^_].*$",
+        NON_UNDERSCORE_PATTERN,
     ),
     (
-        "vellum.workflows.nodes.bases.base.BaseNode.ExternalInputs",
+        f"{BASE_NODE_FULLNAME}.ExternalInputs",
         "vellum.workflows.references.external_input.ExternalInputReference",
-        r"^[^_].*$",
+        NON_UNDERSCORE_PATTERN,
     ),
     (
-        "vellum.workflows.nodes.bases.base.BaseNode.Execution",
+        f"{BASE_NODE_FULLNAME}.Execution",
         "vellum.workflows.references.execution_count.ExecutionCountReference",
-        r"^count$",
+        COUNT_PATTERN,
     ),
     (
         "vellum.workflows.state.base.BaseState",
         "vellum.workflows.references.state_value.StateValueReference",
-        r"^[^_].*$",
+        NON_UNDERSCORE_PATTERN,
     ),
     (
         "vellum.workflows.inputs.base.BaseInputs",
         "vellum.workflows.references.workflow_input.WorkflowInputReference",
-        r"^[^_].*$",
+        NON_UNDERSCORE_PATTERN,
     ),
     (
-        "vellum.workflows.nodes.bases.base.BaseNode",
+        BASE_NODE_FULLNAME,
         "vellum.workflows.references.node.NodeReference",
-        NODE_ATTRIBUTE_REGEX,
+        NODE_ATTRIBUTE_PATTERN,
     ),
 ]
 
@@ -127,8 +166,8 @@ class VellumMypyPlugin(Plugin):
         if not isinstance(ctx.context, MemberExpr):
             return ctx.default_attr_type
 
-        for base_path, descriptor_path, attribute_regex in DESCRIPTOR_PATHS:
-            if not re.match(attribute_regex, ctx.context.name):
+        for base_path, descriptor_path, attribute_pattern in DESCRIPTOR_PATHS:
+            if not attribute_pattern.match(ctx.context.name):
                 continue
 
             if not _is_subclass(ctx.type.ret_type.type, base_path):
@@ -163,7 +202,7 @@ class VellumMypyPlugin(Plugin):
         elif _is_subclass(ctx.cls.info, "vellum.workflows.nodes.displayable.final_output_node.node.FinalOutputNode"):
             self._dynamic_output_node_class_hook(ctx, "value")
 
-        if _is_subclass(ctx.cls.info, "vellum.workflows.nodes.bases.base.BaseNode"):
+        if _is_subclass(ctx.cls.info, BASE_NODE_FULLNAME):
             return self._base_node_class_hook(ctx)
 
         if _is_subclass(ctx.cls.info, "vellum.workflows.workflows.base.BaseWorkflow"):
@@ -241,15 +280,19 @@ class VellumMypyPlugin(Plugin):
         """
 
         for key, sym in ctx.cls.info.names.items():
+            if ctx.cls.info.fullname == BASE_NODE_FULLNAME:
+                continue
+
             if not isinstance(sym.node, Var):
                 continue
 
-            if not re.match(NODE_ATTRIBUTE_REGEX, key):
+            if not NODE_ATTRIBUTE_PATTERN.match(key):
                 continue
 
             type_ = sym.node.type
             if not type_:
                 continue
+
             sym.node.type = self._get_resolvable_type(
                 lambda fullname, types: ctx.api.named_type(fullname, types), type_
             )
@@ -276,8 +319,8 @@ class VellumMypyPlugin(Plugin):
                 continue
 
             is_arg_registered = False
-            for base_path, _, attribute_regex in DESCRIPTOR_PATHS:
-                if not re.match(attribute_regex, arg.name):
+            for base_path, _, attribute_pattern in DESCRIPTOR_PATHS:
+                if not attribute_pattern.match(arg.name):
                     continue
 
                 if not isinstance(arg.expr, (NameExpr, MemberExpr)):
@@ -297,11 +340,11 @@ class VellumMypyPlugin(Plugin):
             if not is_arg_registered:
                 # Need to check node outputs that are inherited
                 if (
-                    re.match(r"^[^_].*$", arg.name)
+                    NON_UNDERSCORE_PATTERN.match(arg.name)
                     and isinstance(arg.expr, MemberExpr)
                     and isinstance(arg.expr.expr, NameExpr)
                     and isinstance(arg.expr.expr.node, TypeInfo)
-                    and _is_subclass(arg.expr.expr.node, "vellum.workflows.nodes.bases.base.BaseNode")
+                    and _is_subclass(arg.expr.expr.node, BASE_NODE_FULLNAME)
                     and arg.expr.name == "Outputs"
                 ):
                     self._calls_with_nested_descriptor_expressions.add(call_expr)
@@ -548,7 +591,7 @@ class VellumMypyPlugin(Plugin):
         if not isinstance(ctx.default_return_type, Instance):
             return ctx.default_return_type
 
-        if not _is_subclass(ctx.default_return_type.type, "vellum.workflows.nodes.bases.base.BaseNode.Outputs"):
+        if not _is_subclass(ctx.default_return_type.type, f"{BASE_NODE_FULLNAME}.Outputs"):
             return ctx.default_return_type
 
         outputs_node = self._get_node_outputs_type_info(ctx)
@@ -573,7 +616,7 @@ class VellumMypyPlugin(Plugin):
         alias_target = alias.target
         if (
             not isinstance(alias_target, Instance)
-            or not _is_subclass(alias_target.type, "typing.Iterator")
+            or not _is_subclass(alias_target.type, "vellum.workflows.events.stream.WorkflowEventGenerator")
             or not alias_target.args
         ):
             return ctx.default_return_type
@@ -607,11 +650,11 @@ class VellumMypyPlugin(Plugin):
 
         new_fulfilled_event = fulfilled_event.copy_modified(args=(Instance(outputs_node, []),))
         return TypeAliasType(
-            alias=MypyTypeAlias(
+            alias=_create_type_alias(
                 target=alias_target.copy_modified(
                     args=[
                         TypeAliasType(
-                            alias=MypyTypeAlias(
+                            alias=_create_type_alias(
                                 target=UnionType(
                                     items=[
                                         new_fulfilled_event if index == fulfilled_event_index else item
@@ -621,6 +664,7 @@ class VellumMypyPlugin(Plugin):
                                 fullname=union_alias.alias.fullname,
                                 line=union_alias.alias.line,
                                 column=union_alias.alias.column,
+                                module=getattr(union_alias.alias, "module", None),
                             ),
                             args=union_alias.args,
                             line=union_alias.line,
@@ -632,6 +676,7 @@ class VellumMypyPlugin(Plugin):
                 fullname=alias.fullname,
                 line=alias.line,
                 column=alias.column,
+                module=getattr(alias, "module", None),
             ),
             args=ctx.default_return_type.args,
             line=ctx.default_return_type.line,
@@ -677,9 +722,7 @@ class VellumMypyPlugin(Plugin):
 
         expr = ctx.context.callee.expr
         instance = ctx.api.get_expression_type(expr)
-        if not isinstance(instance, Instance) or not _is_subclass(
-            instance.type, "vellum.workflows.nodes.bases.base.BaseNode"
-        ):
+        if not isinstance(instance, Instance) or not _is_subclass(instance.type, BASE_NODE_FULLNAME):
             return None
 
         outputs_node = instance.type.names.get("Outputs")

vellum/prompts/__init__.py

@@ -0,0 +1,3 @@
+from .blocks import TextSystemMessage, TextUserMessage
+
+__all__ = ["TextSystemMessage", "TextUserMessage"]

vellum/prompts/blocks/__init__.py

@@ -0,0 +1,3 @@
+from .helpers import TextSystemMessage, TextUserMessage
+
+__all__ = ["TextSystemMessage", "TextUserMessage"]

vellum/prompts/blocks/compilation.py

@@ -19,6 +19,8 @@ from vellum.client.types.image_vellum_value import ImageVellumValue
 from vellum.client.types.number_input import NumberInput
 from vellum.client.types.vellum_audio import VellumAudio
 from vellum.client.types.vellum_image import VellumImage
+from vellum.client.types.vellum_video import VellumVideo
+from vellum.client.types.video_vellum_value import VideoVellumValue
 from vellum.prompts.blocks.exceptions import PromptCompilationError
 from vellum.prompts.blocks.types import CompiledChatMessagePromptBlock, CompiledPromptBlock, CompiledValuePromptBlock
 from vellum.utils.templating.constants import DEFAULT_JINJA_CUSTOM_FILTERS, DEFAULT_JINJA_GLOBALS
@@ -105,7 +107,11 @@ def compile_prompt_blocks(
                         cache_config=block.cache_config,
                     )
                 )
-            elif compiled_input == "JSON":
+            elif compiled_input.type == "JSON":
+                # Skip empty JSON arrays when there are chat message blocks present
+                if compiled_input.value == [] and any(block.block_type == "CHAT_MESSAGE" for block in compiled_blocks):
+                    continue
+
                 compiled_blocks.append(
                     CompiledValuePromptBlock(
                         content=JsonVellumValue(value=compiled_input.value),
@@ -138,29 +144,41 @@ def compile_prompt_blocks(
             )
             compiled_blocks.append(function_call_block)
 
-        elif block.block_type == "IMAGE":
-            image_block = CompiledValuePromptBlock(
-                content=ImageVellumValue(
-                    value=VellumImage(
+        elif block.block_type == "AUDIO":
+            audio_block = CompiledValuePromptBlock(
+                content=AudioVellumValue(
+                    value=VellumAudio(
                         src=block.src,
                         metadata=block.metadata,
                     ),
                 ),
                 cache_config=block.cache_config,
             )
-            compiled_blocks.append(image_block)
+            compiled_blocks.append(audio_block)
 
-        elif block.block_type == "AUDIO":
-            audio_block = CompiledValuePromptBlock(
-                content=AudioVellumValue(
-                    value=VellumAudio(
+        elif block.block_type == "VIDEO":
+            video_block = CompiledValuePromptBlock(
+                content=VideoVellumValue(
+                    value=VellumVideo(
                         src=block.src,
                         metadata=block.metadata,
                     ),
                 ),
                 cache_config=block.cache_config,
             )
-            compiled_blocks.append(audio_block)
+            compiled_blocks.append(video_block)
+
+        elif block.block_type == "IMAGE":
+            image_block = CompiledValuePromptBlock(
+                content=ImageVellumValue(
+                    value=VellumImage(
+                        src=block.src,
+                        metadata=block.metadata,
+                    ),
+                ),
+                cache_config=block.cache_config,
+            )
+            compiled_blocks.append(image_block)
 
         elif block.block_type == "DOCUMENT":
             document_block = CompiledValuePromptBlock(

vellum/prompts/blocks/helpers.py

@@ -0,0 +1,31 @@
+from vellum import ChatMessagePromptBlock, PlainTextPromptBlock, RichTextPromptBlock
+
+
+def TextSystemMessage(content: str) -> ChatMessagePromptBlock:
+    """
+    Create a text system message that autocasts to ChatMessagePromptBlock.
+
+    Args:
+        content: The text content for the system message
+
+    Returns:
+        ChatMessagePromptBlock configured as a system message
+    """
+    return ChatMessagePromptBlock(
+        chat_role="SYSTEM", blocks=[RichTextPromptBlock(blocks=[PlainTextPromptBlock(text=content)])]
+    )
+
+
+def TextUserMessage(content: str) -> ChatMessagePromptBlock:
+    """
+    Create a text user message that autocasts to ChatMessagePromptBlock.
+
+    Args:
+        content: The text content for the user message
+
+    Returns:
+        ChatMessagePromptBlock configured as a user message
+    """
+    return ChatMessagePromptBlock(
+        chat_role="USER", blocks=[RichTextPromptBlock(blocks=[PlainTextPromptBlock(text=content)])]
+    )