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

vellum/workflows/utils/functions.py

@@ -1,16 +1,34 @@
 import dataclasses
+from datetime import datetime
 import inspect
-from typing import TYPE_CHECKING, Annotated, Any, Callable, List, Literal, Optional, Type, Union, get_args, get_origin
+from typing import (
+    TYPE_CHECKING,
+    Annotated,
+    Any,
+    Callable,
+    ForwardRef,
+    List,
+    Literal,
+    Optional,
+    Type,
+    TypeVar,
+    Union,
+    get_args,
+    get_origin,
+)
 
 from pydantic import BaseModel
 from pydantic_core import PydanticUndefined
 from pydash import snake_case
 
 from vellum import Vellum
+from vellum.client.types.array_chat_message_content_item import ArrayChatMessageContentItem
 from vellum.client.types.function_definition import FunctionDefinition
+from vellum.workflows.constants import undefined
 from vellum.workflows.integrations.composio_service import ComposioService
 from vellum.workflows.integrations.mcp_service import MCPService
 from vellum.workflows.integrations.vellum_integration_service import VellumIntegrationService
+from vellum.workflows.types.core import is_json_type
 from vellum.workflows.types.definition import (
     ComposioToolDefinition,
     DeploymentDefinition,
@@ -41,12 +59,51 @@ for k, v in list(type_map.items()):
         type_map[k.__name__] = v
 
 
+def _get_def_name(annotation: Type) -> str:
+    return f"{annotation.__module__}.{annotation.__qualname__}"
+
+
+recorded_unions = {
+    ArrayChatMessageContentItem: "vellum.client.types.array_chat_message_content_item.ArrayChatMessageContentItem",
+}
+
+
 def compile_annotation(annotation: Optional[Any], defs: dict[str, Any]) -> dict:
     if annotation is None:
         return {"type": "null"}
 
+    if annotation is Any:
+        return {}
+
+    # Handle type variables (e.g., MapNodeItemType) - return empty schema since we can't determine the type
+    if isinstance(annotation, TypeVar):
+        return {}
+
+    if annotation is datetime:
+        return {"type": "string", "format": "date-time"}
+
     if get_origin(annotation) is Union:
-        return {"anyOf": [compile_annotation(a, defs) for a in get_args(annotation)]}
+        if is_json_type(get_args(annotation)):
+            return {"$ref": "#/$defs/vellum.workflows.types.core.Json"}
+
+        if annotation in recorded_unions:
+            return {"$ref": f"#/$defs/{recorded_unions[annotation]}"}
+
+        # Filter out Type[undefined] from union args - it just makes the property optional
+        filtered_args = [
+            a
+            for a in get_args(annotation)
+            if not (get_origin(a) is type and get_args(a) and get_args(a)[0] is undefined)
+        ]
+
+        if len(filtered_args) == 0:
+            # Edge case: all union members were Type[undefined], return empty schema
+            return {}
+
+        if len(filtered_args) == 1:
+            return compile_annotation(filtered_args[0], defs)
+
+        return {"anyOf": [compile_annotation(a, defs) for a in filtered_args]}
 
     if get_origin(annotation) is Literal:
         values = list(get_args(annotation))
@@ -84,7 +141,8 @@ def compile_annotation(annotation: Optional[Any], defs: dict[str, Any]) -> dict:
             return result
 
     if dataclasses.is_dataclass(annotation) and isinstance(annotation, type):
-        if annotation.__name__ not in defs:
+        def_name = _get_def_name(annotation)
+        if def_name not in defs:
             properties = {}
             required = []
             for field in dataclasses.fields(annotation):
@@ -93,11 +151,12 @@ def compile_annotation(annotation: Optional[Any], defs: dict[str, Any]) -> dict:
                     required.append(field.name)
                 else:
                     properties[field.name]["default"] = _compile_default_value(field.default)
-            defs[annotation.__name__] = {"type": "object", "properties": properties, "required": required}
-        return {"$ref": f"#/$defs/{annotation.__name__}"}
+            defs[def_name] = {"type": "object", "properties": properties, "required": required}
+        return {"$ref": f"#/$defs/{def_name}"}
 
     if inspect.isclass(annotation) and issubclass(annotation, BaseModel):
-        if annotation.__name__ not in defs:
+        def_name = _get_def_name(annotation)
+        if def_name not in defs:
             properties = {}
             required = []
             for field_name, field_info in annotation.model_fields.items():
@@ -111,9 +170,22 @@ def compile_annotation(annotation: Optional[Any], defs: dict[str, Any]) -> dict:
                     required.append(field_name)
                 else:
                     properties[field_name]["default"] = _compile_default_value(field_info.default)
-            defs[annotation.__name__] = {"type": "object", "properties": properties, "required": required}
+            defs[def_name] = {"type": "object", "properties": properties, "required": required}
+
+        return {"$ref": f"#/$defs/{def_name}"}
+
+    if type(annotation) is ForwardRef:
+        # Ignore forward references for now
+        return {}
+
+    # Handle Type[undefined] - skip it as it just makes the property optional
+    if get_origin(annotation) is type:
+        args = get_args(annotation)
+        if args and args[0] is undefined:
+            return {}
 
-        return {"$ref": f"#/$defs/{annotation.__name__}"}
+    if annotation not in type_map:
+        raise ValueError(f"Failed to compile type: {annotation}")
 
     return {"type": type_map[annotation]}
 
@@ -161,6 +233,7 @@ def compile_function_definition(function: Callable) -> FunctionDefinition:
 
     # Get inputs from the decorator if present
     inputs = getattr(function, "__vellum_inputs__", {})
+    examples = getattr(function, "__vellum_examples__", None)
     exclude_params = set(inputs.keys())
 
     properties = {}
@@ -192,6 +265,8 @@ def compile_function_definition(function: Callable) -> FunctionDefinition:
     parameters = {"type": "object", "properties": properties, "required": required}
     if defs:
         parameters["$defs"] = defs
+    if examples is not None:
+        parameters["examples"] = examples
 
     return FunctionDefinition(
         name=function.__name__,
@@ -208,6 +283,11 @@ def compile_inline_workflow_function_definition(workflow_class: Type["BaseWorkfl
     inputs_class = workflow_class.get_inputs_class()
     vars_inputs_class = vars(inputs_class)
 
+    # Get inputs from the decorator if present (to exclude from schema)
+    inputs = getattr(workflow_class, "__vellum_inputs__", {})
+    examples = getattr(workflow_class, "__vellum_examples__", None)
+    exclude_params = set(inputs.keys())
+
     properties = {}
     required = []
     defs: dict[str, Any] = {}
@@ -216,6 +296,10 @@ def compile_inline_workflow_function_definition(workflow_class: Type["BaseWorkfl
         if name.startswith("__"):
             continue
 
+        # Skip parameters that are in the exclude_params set
+        if exclude_params and name in exclude_params:
+            continue
+
         properties[name] = compile_annotation(field_type, defs)
 
         # Check if the field has a default value
@@ -228,6 +312,8 @@ def compile_inline_workflow_function_definition(workflow_class: Type["BaseWorkfl
     parameters = {"type": "object", "properties": properties, "required": required}
     if defs:
         parameters["$defs"] = defs
+    if examples is not None:
+        parameters["examples"] = examples
 
     return FunctionDefinition(
         name=snake_case(workflow_class.__name__),
@@ -342,6 +428,7 @@ def compile_vellum_integration_tool_definition(
             integration=tool_def.integration_name,
             provider=tool_def.provider.value,
             tool_name=tool_def.name,
+            toolkit_version=tool_def.toolkit_version,
         )
 
         return FunctionDefinition(
@@ -354,11 +441,66 @@ def compile_vellum_integration_tool_definition(
         return FunctionDefinition(name=tool_def.name, description=tool_def.description, parameters={})
 
 
-def use_tool_inputs(**inputs):
+ToolType = Union[Callable[..., Any], Type["BaseWorkflow"]]
+
+
+def tool(
+    *,
+    inputs: Optional[dict[str, Any]] = None,
+    examples: Optional[List[dict[str, Any]]] = None,
+) -> Callable[[ToolType], ToolType]:
+    """
+    Decorator to configure a tool function or inline workflow.
+
+    Currently supports specifying which parameters should come from parent workflow inputs
+    via the `inputs` mapping. Also supports providing `examples` which will be hoisted
+    into the JSON Schema `examples` keyword for this tool's parameters.
+
+    Args:
+        inputs: Mapping of parameter names to parent input references
+        examples: List of example argument objects for the tool
+
+    Example with function:
+        @tool(inputs={
+            "parent_input": ParentInputs.parent_input,
+        }, examples=[{"location": "San Francisco"}])
+        def get_string(parent_input: str, user_query: str) -> str:
+            return f"Parent: {parent_input}, Query: {user_query}"
+
+    Example with inline workflow:
+        @tool(inputs={
+            "context": ParentInputs.context,
+        })
+        class MyInlineWorkflow(BaseWorkflow):
+            graph = MyNode
+
+            class Outputs(BaseWorkflow.Outputs):
+                result = MyNode.Outputs.result
+    """
+
+    def decorator(func: ToolType) -> ToolType:
+        # Store the inputs mapping on the function/workflow for later use
+        if inputs is not None:
+            setattr(func, "__vellum_inputs__", inputs)
+        # Store the examples on the function/workflow for later use
+        if examples is not None:
+            setattr(func, "__vellum_examples__", examples)
+        return func
+
+    return decorator
+
+
+def use_tool_inputs(**inputs: Any) -> Callable[[Callable], Callable]:
     """
     Decorator to specify which parameters of a tool function should be provided
     from the parent workflow inputs rather than from the LLM.
 
+    .. deprecated:: 2.0.0
+        This function is deprecated and will be removed in version 2.0.0.
+        Use :func:`tool` with the ``inputs`` parameter instead.
+
+    This is a backward-compatible helper equivalent to @tool(inputs={...}).
+
     Args:
         **inputs: Mapping of parameter names to parent input references
 
@@ -369,10 +511,4 @@ def use_tool_inputs(**inputs):
         def get_string(parent_input: str, user_query: str) -> str:
             return f"Parent: {parent_input}, Query: {user_query}"
     """
-
-    def decorator(func: Callable) -> Callable:
-        # Store the inputs mapping on the function for later use
-        setattr(func, "__vellum_inputs__", inputs)
-        return func
-
-    return decorator
+    return tool(inputs=inputs)

vellum/workflows/utils/pydantic_schema.py

@@ -1,10 +1,28 @@
 import inspect
-from typing import Any, Dict
+from typing import Any, Dict, Type, TypeVar
 
+import pydantic
 from pydantic import BaseModel
 
 from vellum.workflows.utils.functions import compile_annotation
 
+T = TypeVar("T")
+IS_PYDANTIC_V2 = pydantic.VERSION.startswith("2.")
+_type_adapter_cache: Dict[Type, "pydantic.TypeAdapter"] = {}  # type: ignore[type-arg]
+
+
+def validate_obj_as(type_: Type[T], object_: Any) -> T:
+    """Validate an object as a given type using pydantic's TypeAdapter (v2) or parse_obj_as (v1).
+
+    This is similar to parse_obj_as but without the convert_and_respect_annotation_metadata step,
+    making it suitable for simple type validation without annotation metadata handling.
+    """
+    if IS_PYDANTIC_V2:
+        if type_ not in _type_adapter_cache:
+            _type_adapter_cache[type_] = pydantic.TypeAdapter(type_)  # type: ignore[attr-defined]
+        return _type_adapter_cache[type_].validate_python(object_)
+    return pydantic.parse_obj_as(type_, object_)  # type: ignore[attr-defined]
+
 
 def normalize_json(schema_input: Any) -> Any:
     """

vellum/workflows/utils/tests/test_functions.py

@@ -18,6 +18,8 @@ from vellum.workflows.utils.functions import (
     compile_function_definition,
     compile_inline_workflow_function_definition,
     compile_workflow_deployment_function_definition,
+    tool,
+    use_tool_inputs,
 )
 
 
@@ -187,14 +189,15 @@ def test_compile_function_definition__dataclasses():
     compiled_function = compile_function_definition(my_function)
 
     # THEN it should return the compiled function definition
+    ref_name = f"{__name__}.test_compile_function_definition__dataclasses.<locals>.MyDataClass"
     assert compiled_function == FunctionDefinition(
         name="my_function",
         parameters={
             "type": "object",
-            "properties": {"c": {"$ref": "#/$defs/MyDataClass"}},
+            "properties": {"c": {"$ref": f"#/$defs/{ref_name}"}},
             "required": ["c"],
             "$defs": {
-                "MyDataClass": {
+                ref_name: {
                     "type": "object",
                     "properties": {"a": {"type": "integer"}, "b": {"type": "string"}},
                     "required": ["a", "b"],
@@ -217,14 +220,15 @@ def test_compile_function_definition__pydantic():
     compiled_function = compile_function_definition(my_function)
 
     # THEN it should return the compiled function definition
+    ref_name = f"{__name__}.test_compile_function_definition__pydantic.<locals>.MyPydanticModel"
     assert compiled_function == FunctionDefinition(
         name="my_function",
         parameters={
             "type": "object",
-            "properties": {"c": {"$ref": "#/$defs/MyPydanticModel"}},
+            "properties": {"c": {"$ref": f"#/$defs/{ref_name}"}},
             "required": ["c"],
             "$defs": {
-                "MyPydanticModel": {
+                ref_name: {
                     "type": "object",
                     "properties": {
                         "a": {"type": "integer", "description": "The first number"},
@@ -251,14 +255,15 @@ def test_compile_function_definition__default_dataclass():
     compiled_function = compile_function_definition(my_function)
 
     # THEN it should return the compiled function definition
+    ref_name = f"{__name__}.test_compile_function_definition__default_dataclass.<locals>.MyDataClass"
     assert compiled_function == FunctionDefinition(
         name="my_function",
         parameters={
             "type": "object",
-            "properties": {"c": {"$ref": "#/$defs/MyDataClass", "default": {"a": 1, "b": "hello"}}},
+            "properties": {"c": {"$ref": f"#/$defs/{ref_name}", "default": {"a": 1, "b": "hello"}}},
             "required": [],
             "$defs": {
-                "MyDataClass": {
+                ref_name: {
                     "type": "object",
                     "properties": {"a": {"type": "integer"}, "b": {"type": "string"}},
                     "required": ["a", "b"],
@@ -281,14 +286,15 @@ def test_compile_function_definition__default_pydantic():
     compiled_function = compile_function_definition(my_function)
 
     # THEN it should return the compiled function definition
+    ref_name = f"{__name__}.test_compile_function_definition__default_pydantic.<locals>.MyPydanticModel"
     assert compiled_function == FunctionDefinition(
         name="my_function",
         parameters={
             "type": "object",
-            "properties": {"c": {"$ref": "#/$defs/MyPydanticModel", "default": {"a": 1, "b": "hello"}}},
+            "properties": {"c": {"$ref": f"#/$defs/{ref_name}", "default": {"a": 1, "b": "hello"}}},
             "required": [],
             "$defs": {
-                "MyPydanticModel": {
+                ref_name: {
                     "type": "object",
                     "properties": {"a": {"type": "integer"}, "b": {"type": "string"}},
                     "required": ["a", "b"],
@@ -773,3 +779,112 @@ def test_compile_function_definition__string_annotations_with_future_imports():
             "required": ["a", "b", "c", "d", "e", "f", "g"],
         },
     )
+
+
+def test_use_tool_inputs__inline_vs_decorator():
+    """
+    Tests that inline use_tool_inputs(...)(func) behaves the same as @use_tool_inputs(...) decorator.
+    """
+
+    # GIVEN a function with some parameters
+    def my_function(a: str, b: int, c: float) -> str:
+        """A test function."""
+        return f"{a}-{b}-{c}"
+
+    # WHEN using use_tool_inputs as a decorator
+    @use_tool_inputs(a="fixed_a", b=42)
+    def decorated_function(a: str, b: int, c: float) -> str:
+        """A test function."""
+        return f"{a}-{b}-{c}"
+
+    # AND using use_tool_inputs inline
+    inline_function = use_tool_inputs(a="fixed_a", b=42)(my_function)
+
+    # THEN both should have the same __vellum_inputs__ attribute
+    assert hasattr(decorated_function, "__vellum_inputs__")
+    assert hasattr(inline_function, "__vellum_inputs__")
+
+    # AND the inputs should be identical
+    assert decorated_function.__vellum_inputs__ == inline_function.__vellum_inputs__
+    assert decorated_function.__vellum_inputs__ == {"a": "fixed_a", "b": 42}
+
+
+def test_tool__inline_vs_decorator():
+    """
+    Tests that inline tool(inputs={...})(func) behaves the same as @tool(inputs={...}) decorator.
+    """
+
+    # GIVEN a function with some parameters
+    def my_function(a: str, b: int, c: float) -> str:
+        """A test function."""
+        return f"{a}-{b}-{c}"
+
+    # WHEN using tool as a decorator
+    @tool(inputs={"a": "fixed_a", "b": 42})
+    def decorated_function(a: str, b: int, c: float) -> str:
+        """A test function."""
+        return f"{a}-{b}-{c}"
+
+    # AND using tool inline
+    inline_function = tool(inputs={"a": "fixed_a", "b": 42})(my_function)
+
+    # THEN both should have the same __vellum_inputs__ attribute
+    assert hasattr(decorated_function, "__vellum_inputs__")
+    assert hasattr(inline_function, "__vellum_inputs__")
+
+    # AND the inputs should be identical
+    assert decorated_function.__vellum_inputs__ == inline_function.__vellum_inputs__
+    assert decorated_function.__vellum_inputs__ == {"a": "fixed_a", "b": 42}
+
+
+def test_tool__backward_compatibility_with_use_tool_inputs():
+    """
+    Tests that tool(inputs={...}) and use_tool_inputs(**inputs) produce the same __vellum_inputs__ attribute.
+    """
+
+    # GIVEN a function with some parameters
+    def my_function(a: str, b: int) -> str:
+        """A test function."""
+        return f"{a}-{b}"
+
+    # WHEN using tool as a decorator with inputs dict
+    @tool(inputs={"a": "value_a"})
+    def tool_decorated(a: str, b: int) -> str:
+        """A test function."""
+        return f"{a}-{b}"
+
+    # AND using use_tool_inputs as a decorator with kwargs
+    @use_tool_inputs(a="value_a")
+    def use_tool_inputs_decorated(a: str, b: int) -> str:
+        """A test function."""
+        return f"{a}-{b}"
+
+    # THEN both should have identical __vellum_inputs__ attributes
+    assert getattr(tool_decorated, "__vellum_inputs__") == getattr(use_tool_inputs_decorated, "__vellum_inputs__")
+    assert getattr(tool_decorated, "__vellum_inputs__") == {"a": "value_a"}
+
+
+def test_tool_examples_included_in_schema():
+    @tool(
+        examples=[
+            {"location": "San Francisco"},
+            {"location": "New York", "units": "celsius"},
+        ]
+    )
+    def get_current_weather(location: str, units: str = "fahrenheit") -> str:
+        return "sunny"
+
+    compiled = compile_function_definition(get_current_weather)
+    assert isinstance(compiled.parameters, dict)
+    assert compiled.parameters == {
+        "type": "object",
+        "properties": {
+            "location": {"type": "string"},
+            "units": {"type": "string", "default": "fahrenheit"},
+        },
+        "required": ["location"],
+        "examples": [
+            {"location": "San Francisco"},
+            {"location": "New York", "units": "celsius"},
+        ],
+    }

vellum/workflows/utils/tests/test_validate.py

@@ -0,0 +1,79 @@
+import pytest
+from typing import Any, Union
+
+from vellum.workflows.utils.validate import validate_target_type
+
+
+@pytest.mark.parametrize(
+    ["declared_type", "target_type"],
+    [
+        (str, int),
+        (list[str], list[int]),
+        (str, Union[str, int]),
+        (int, Union[str, int]),
+        (list[str], Union[list[str], list[int]]),
+        (Union[str, int], Union[bool, float]),
+    ],
+    ids=[
+        "str_int",
+        "list_str_int",
+        "str_union_str_int",
+        "int_union_str_int",
+        "list_str_union",
+        "union_str_int_union_bool_float",
+    ],
+)
+def test_validate__should_raise_exception(
+    declared_type,
+    target_type,
+):
+    """
+    Tests that validate_target_type raises an exception for mismatched types.
+    """
+
+    # WHEN validating the target type
+    with pytest.raises(ValueError) as exc_info:
+        validate_target_type(declared_type, target_type)
+
+    # THEN an exception should be raised
+    assert "Output type mismatch" in str(exc_info.value)
+
+
+@pytest.mark.parametrize(
+    ["declared_type", "target_type"],
+    [
+        (str, str),
+        (list[str], list[str]),
+        (dict, dict[str, str]),
+        (str, Any),
+        (Any, str),
+        (Union[str, int], str),
+        (Union[str, int], int),
+        (Union[str, int], Union[str, int]),
+        (Union[str, int], Union[int, str]),
+        (Union[str, int], Union[str, bool]),
+    ],
+    ids=[
+        "str",
+        "list_str",
+        "bare_dict_params_dict",
+        "str_any",
+        "any_str",
+        "union_str_int_str",
+        "union_str_int_int",
+        "union_str_int_union_str_int",
+        "union_str_int_union_int_str",
+        "union_str_int_union_str_bool",
+    ],
+)
+def test_validate__should_validate(
+    declared_type,
+    target_type,
+):
+    """
+    Tests that validate_target_type accepts matching types.
+    """
+
+    # WHEN validating the target type
+    # THEN no exception should be raised
+    validate_target_type(declared_type, target_type)

vellum/workflows/utils/tests/test_vellum_variables.py

@@ -1,9 +1,20 @@
 import pytest
-from typing import List, Optional
+from datetime import datetime
+from typing import List, Optional, Union
 
-from vellum import ChatMessage, SearchResult, VellumAudio, VellumDocument, VellumImage, VellumValue
+from vellum import (
+    ArrayChatMessageContentItem,
+    ChatMessage,
+    SearchResult,
+    VellumAudio,
+    VellumDocument,
+    VellumImage,
+    VellumValue,
+)
+import vellum.client.types as vellum_types
 from vellum.workflows.types.core import Json
 from vellum.workflows.utils.vellum_variables import (
+    _is_vellum_value_subtype,
     primitive_type_to_vellum_variable_type,
     vellum_variable_type_to_openapi_type,
 )
@@ -14,6 +25,8 @@ from vellum.workflows.utils.vellum_variables import (
     [
         (str, "STRING"),
         (Optional[str], "STRING"),
+        (datetime, "STRING"),
+        (Optional[datetime], "STRING"),
         (int, "NUMBER"),
         (Optional[int], "NUMBER"),
         (float, "NUMBER"),
@@ -36,6 +49,8 @@ from vellum.workflows.utils.vellum_variables import (
         (Optional[list[SearchResult]], "SEARCH_RESULTS"),
         (list[VellumValue], "ARRAY"),
         (Optional[list[VellumValue]], "ARRAY"),
+        (List[ArrayChatMessageContentItem], "ARRAY"),
+        (Optional[List[ArrayChatMessageContentItem]], "ARRAY"),
     ],
 )
 def test_primitive_type_to_vellum_variable_type(type_, expected):
@@ -61,3 +76,48 @@ def test_primitive_type_to_vellum_variable_type(type_, expected):
 )
 def test_vellum_variable_type_to_openapi_type(vellum_type, expected):
     assert vellum_variable_type_to_openapi_type(vellum_type) == expected
+
+
+class _SomeType:
+    pass
+
+
+_STRING_OR_NUMBER_VELLUM_VALUE = Union[vellum_types.StringVellumValue, vellum_types.NumberVellumValue]
+
+
+@pytest.mark.parametrize(
+    ["type_", "expected_is_vellum_value_subtype"],
+    [
+        # Individual union members
+        (vellum_types.StringVellumValue, True),
+        (vellum_types.NumberVellumValue, True),
+        (vellum_types.JsonVellumValue, True),
+        (vellum_types.AudioVellumValue, True),
+        (vellum_types.VideoVellumValue, True),
+        (vellum_types.ImageVellumValue, True),
+        (vellum_types.DocumentVellumValue, True),
+        (vellum_types.FunctionCallVellumValue, True),
+        (vellum_types.ErrorVellumValue, True),
+        (vellum_types.ArrayVellumValue, True),
+        (vellum_types.ChatHistoryVellumValue, True),
+        (vellum_types.SearchResultsVellumValue, True),
+        (vellum_types.ThinkingVellumValue, True),
+        # Misc union types
+        (Union[vellum_types.StringVellumValue, vellum_types.NumberVellumValue], True),
+        (_STRING_OR_NUMBER_VELLUM_VALUE, True),
+        (Union[vellum_types.StringVellumValue], True),
+        (Union["vellum_types.StringVellumValue"], False),
+        # Random types
+        (int, False),
+        (_SomeType, False),
+        (List[int], False),
+        (Union[int, str], False),
+        (Optional[int], False),
+        (List["_SomeType"], False),
+        # Handle non-types gracefully
+        (1, False),
+        (_SomeType(), False),
+    ],
+)
+def test_is_vellum_value_subtype(type_, expected_is_vellum_value_subtype):
+    assert _is_vellum_value_subtype(type_) == expected_is_vellum_value_subtype