vellum-ai 0.13.28__py3-none-any.whl → 0.14.1__py3-none-any.whl

vellum/client/core/client_wrapper.py

@@ -18,7 +18,7 @@ class BaseClientWrapper:
         headers: typing.Dict[str, str] = {
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "0.13.28",
+            "X-Fern-SDK-Version": "0.14.1",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

vellum/prompts/blocks/compilation.py

@@ -1,5 +1,5 @@
 import json
-from typing import Optional, cast
+from typing import Sequence, Union, cast
 
 from vellum import (
     ChatMessage,
@@ -14,6 +14,7 @@ from vellum.client.types.audio_vellum_value import AudioVellumValue
 from vellum.client.types.function_call import FunctionCall
 from vellum.client.types.function_call_vellum_value import FunctionCallVellumValue
 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.prompts.blocks.exceptions import PromptCompilationError
@@ -22,15 +23,20 @@ from vellum.utils.templating.constants import DEFAULT_JINJA_CUSTOM_FILTERS
 from vellum.utils.templating.render import render_sandboxed_jinja_template
 from vellum.utils.typing import cast_not_optional
 
+PromptInput = Union[PromptRequestInput, NumberInput]
+
 
 def compile_prompt_blocks(
     blocks: list[PromptBlock],
-    inputs: list[PromptRequestInput],
+    inputs: Sequence[PromptInput],
     input_variables: list[VellumVariable],
 ) -> list[CompiledPromptBlock]:
     """Compiles a list of Prompt Blocks, performing all variable substitutions and Jinja templating needed."""
 
     sanitized_inputs = _sanitize_inputs(inputs)
+    inputs_by_name = {
+        (input_.name if isinstance(input_, NumberInput) else input_.key): input_ for input_ in sanitized_inputs
+    }
 
     compiled_blocks: list[CompiledPromptBlock] = []
     for block in blocks:
@@ -66,7 +72,7 @@ def compile_prompt_blocks(
 
             rendered_template = render_sandboxed_jinja_template(
                 template=block.template,
-                input_values={input_.key: input_.value for input_ in sanitized_inputs},
+                input_values={name: inp.value for name, inp in inputs_by_name.items()},
                 jinja_custom_filters=DEFAULT_JINJA_CUSTOM_FILTERS,
                 jinja_globals=DEFAULT_JINJA_CUSTOM_FILTERS,
             )
@@ -80,9 +86,7 @@ def compile_prompt_blocks(
             )
 
         elif block.block_type == "VARIABLE":
-            compiled_input: Optional[PromptRequestInput] = next(
-                (input_ for input_ in sanitized_inputs if input_.key == str(block.input_variable)), None
-            )
+            compiled_input = inputs_by_name.get(block.input_variable)
             if compiled_input is None:
                 raise PromptCompilationError(f"Input variable '{block.input_variable}' not found")
 
@@ -196,23 +200,26 @@ def _compile_chat_messages_as_prompt_blocks(chat_messages: list[ChatMessage]) ->
 
 def _compile_rich_text_block_as_value_block(
     block: RichTextPromptBlock,
-    inputs: list[PromptRequestInput],
+    inputs: list[PromptInput],
 ) -> CompiledValuePromptBlock:
     value: str = ""
+    inputs_by_name = {(input_.name if isinstance(input_, NumberInput) else input_.key): input_ for input_ in inputs}
     for child_block in block.blocks:
         if child_block.block_type == "PLAIN_TEXT":
             value += child_block.text
         elif child_block.block_type == "VARIABLE":
-            variable = next((input_ for input_ in inputs if input_.key == str(child_block.input_variable)), None)
-            if variable is None:
+            input = inputs_by_name.get(child_block.input_variable)
+            if input is None:
                 raise PromptCompilationError(f"Input variable '{child_block.input_variable}' not found")
-            elif variable.type == "STRING":
-                value += str(variable.value)
-            elif variable.type == "JSON":
-                value += json.dumps(variable.value, indent=4)
+            elif input.type == "STRING":
+                value += str(input.value)
+            elif input.type == "JSON":
+                value += json.dumps(input.value, indent=4)
+            elif input.type == "NUMBER":
+                value += str(input.value)
             else:
                 raise PromptCompilationError(
-                    f"Input variable '{child_block.input_variable}' must be of type STRING or JSON"
+                    f"Input variable '{child_block.input_variable}' has an invalid type: {input.type}"
                 )
         else:
             raise PromptCompilationError(f"Invalid child block_type for RICH_TEXT: {child_block.block_type}")
@@ -220,8 +227,8 @@ def _compile_rich_text_block_as_value_block(
     return CompiledValuePromptBlock(content=StringVellumValue(value=value), cache_config=block.cache_config)
 
 
-def _sanitize_inputs(inputs: list[PromptRequestInput]) -> list[PromptRequestInput]:
-    sanitized_inputs: list[PromptRequestInput] = []
+def _sanitize_inputs(inputs: Sequence[PromptInput]) -> list[PromptInput]:
+    sanitized_inputs: list[PromptInput] = []
     for input_ in inputs:
         if input_.type == "CHAT_HISTORY" and input_.value is None:
             sanitized_inputs.append(input_.model_copy(update={"value": cast(list[ChatMessage], [])}))

vellum/prompts/blocks/tests/test_compilation.py

@@ -10,6 +10,7 @@ from vellum import (
     VariablePromptBlock,
     VellumVariable,
 )
+from vellum.client.types.number_input import NumberInput
 from vellum.prompts.blocks.compilation import compile_prompt_blocks
 from vellum.prompts.blocks.types import CompiledChatMessagePromptBlock, CompiledValuePromptBlock
 
@@ -94,6 +95,33 @@ from vellum.prompts.blocks.types import CompiledChatMessagePromptBlock, Compiled
                 ),
             ],
         ),
+        (
+            [
+                ChatMessagePromptBlock(
+                    chat_role="USER",
+                    blocks=[
+                        RichTextPromptBlock(
+                            blocks=[
+                                PlainTextPromptBlock(text="Count to "),
+                                VariablePromptBlock(input_variable="count"),
+                            ]
+                        )
+                    ],
+                )
+            ],
+            [
+                # TODO: We don't yet have PromptRequestNumberInput. We should either add it or migrate
+                # Prompts to using these more generic inputs.
+                NumberInput(name="count", value=10),
+            ],
+            [VellumVariable(id="901ec2d6-430c-4341-b963-ca689006f5cc", type="NUMBER", key="count")],
+            [
+                CompiledChatMessagePromptBlock(
+                    role="USER",
+                    blocks=[CompiledValuePromptBlock(content=StringVellumValue(value="Count to 10.0"))],
+                ),
+            ],
+        ),
     ],
     ids=[
         "empty",
@@ -102,6 +130,7 @@ from vellum.prompts.blocks.types import CompiledChatMessagePromptBlock, Compiled
         "rich-text-no-variables",
         "rich-text-with-variables",
         "chat-message",
+        "number-input",
     ],
 )
 def test_compile_prompt_blocks__happy(blocks, inputs, input_variables, expected):

vellum/utils/templating/render.py

@@ -42,6 +42,8 @@ def render_sandboxed_jinja_template(
 
         rendered_template = jinja_template.render(input_values)
     except json.JSONDecodeError as e:
+        if not e.doc:
+            raise JinjaTemplateError("Unable to render jinja template:\n" "Cannot run json.loads() on empty input")
         if e.msg == "Invalid control character at":
             raise JinjaTemplateError(
                 "Unable to render jinja template:\n"

vellum/workflows/constants.py

@@ -4,11 +4,11 @@ from typing import Any, cast
 
 class _UndefMeta(type):
     def __repr__(cls) -> str:
-        return "UNDEF"
+        return "undefined"
 
     def __getattribute__(cls, name: str) -> Any:
         if name == "__class__":
-            # ensures that UNDEF.__class__ == UNDEF
+            # ensures that undefined.__class__ == undefined
             return cls
 
         return super().__getattribute__(name)
@@ -17,7 +17,12 @@ class _UndefMeta(type):
         return False
 
 
-class UNDEF(metaclass=_UndefMeta):
+class undefined(metaclass=_UndefMeta):
+    """
+    A singleton class that represents an `undefined` value, mirroring the behavior of the `undefined`
+    value in TypeScript.
+    """
+
     pass
 
 

vellum/workflows/descriptors/tests/test_utils.py

@@ -1,6 +1,7 @@
 import pytest
 
 from vellum.workflows.descriptors.utils import resolve_value
+from vellum.workflows.errors.types import WorkflowError, WorkflowErrorCode
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.references.constant import ConstantValueReference
 from vellum.workflows.state.base import BaseState
@@ -77,6 +78,24 @@ class DummyNode(BaseNode[FixtureState]):
         (FixtureState.zeta["foo"], "bar"),
         (ConstantValueReference(1), 1),
         (FixtureState.theta[0], "baz"),
+        (
+            ConstantValueReference(
+                WorkflowError(
+                    message="This is a test",
+                    code=WorkflowErrorCode.USER_DEFINED_ERROR,
+                )
+            ).contains("test"),
+            True,
+        ),
+        (
+            ConstantValueReference(
+                WorkflowError(
+                    message="This is a test",
+                    code=WorkflowErrorCode.USER_DEFINED_ERROR,
+                )
+            ).does_not_contain("test"),
+            False,
+        ),
     ],
     ids=[
         "or",
@@ -122,6 +141,8 @@ class DummyNode(BaseNode[FixtureState]):
         "accessor",
         "constants",
         "list_index",
+        "error_contains",
+        "error_does_not_contain",
     ],
 )
 def test_resolve_value__happy_path(descriptor, expected_value):

vellum/workflows/descriptors/utils.py

@@ -5,7 +5,7 @@ from typing import Any, Dict, Optional, Sequence, Set, TypeVar, Union, cast, ove
 
 from pydantic import BaseModel
 
-from vellum.workflows.constants import UNDEF
+from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.state.base import BaseState
 
@@ -93,10 +93,10 @@ def resolve_value(
 
 def is_unresolved(value: Any) -> bool:
     """
-    Recursively checks if a value has an unresolved value, represented by UNDEF.
+    Recursively checks if a value has an unresolved value, represented by undefined.
     """
 
-    if value is UNDEF:
+    if value is undefined:
         return True
 
     if dataclasses.is_dataclass(value):

vellum/workflows/errors/types.py

@@ -1,6 +1,6 @@
 from dataclasses import dataclass
 from enum import Enum
-from typing import Dict
+from typing import Any, Dict
 
 from vellum.client.types.vellum_error import VellumError
 from vellum.client.types.vellum_error_code_enum import VellumErrorCodeEnum
@@ -26,6 +26,9 @@ class WorkflowError:
     message: str
     code: WorkflowErrorCode
 
+    def __contains__(self, item: Any) -> bool:
+        return item in self.message
+
 
 _VELLUM_ERROR_CODE_TO_WORKFLOW_ERROR_CODE: Dict[VellumErrorCodeEnum, WorkflowErrorCode] = {
     "INVALID_REQUEST": WorkflowErrorCode.INVALID_INPUTS,

vellum/workflows/expressions/coalesce_expression.py

@@ -1,6 +1,6 @@
 from typing import TypeVar, Union
 
-from vellum.workflows.constants import UNDEF
+from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
@@ -27,7 +27,7 @@ class CoalesceExpression(BaseDescriptor[Union[LHS, RHS]]):
 
     def resolve(self, state: "BaseState") -> Union[LHS, RHS]:
         lhs = resolve_value(self._lhs, state)
-        if lhs is not UNDEF and lhs is not None:
+        if lhs is not undefined and lhs is not None:
             return lhs
 
         return resolve_value(self._rhs, state)

vellum/workflows/expressions/contains.py

@@ -1,9 +1,10 @@
 from typing import Generic, TypeVar, Union
 
-from vellum.workflows.constants import UNDEF
+from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.descriptors.utils import resolve_value
+from vellum.workflows.errors.types import WorkflowError
 from vellum.workflows.state.base import BaseState
 
 LHS = TypeVar("LHS")
@@ -26,9 +27,9 @@ class ContainsExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
         # https://app.shortcut.com/vellum/story/4658
         lhs = resolve_value(self._lhs, state)
         # assumes that lack of is also false
-        if lhs is UNDEF:
+        if lhs is undefined:
             return False
-        if not isinstance(lhs, (list, tuple, set, dict, str)):
+        if not isinstance(lhs, (list, tuple, set, dict, str, WorkflowError)):
             raise InvalidExpressionException(
                 f"Expected a LHS that supported `contains`, got `{lhs.__class__.__name__}`"
             )

vellum/workflows/expressions/does_not_contain.py

@@ -3,6 +3,7 @@ from typing import Generic, TypeVar, Union
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.descriptors.utils import resolve_value
+from vellum.workflows.errors.types import WorkflowError
 from vellum.workflows.state.base import BaseState
 
 LHS = TypeVar("LHS")
@@ -24,7 +25,7 @@ class DoesNotContainExpression(BaseDescriptor[bool], Generic[LHS, RHS]):
         # Support any type that implements the not in operator
         # https://app.shortcut.com/vellum/story/4658
         lhs = resolve_value(self._lhs, state)
-        if not isinstance(lhs, (list, tuple, set, dict, str)):
+        if not isinstance(lhs, (list, tuple, set, dict, str, WorkflowError)):
             raise InvalidExpressionException(
                 f"Expected a LHS that supported `contains`, got `{lhs.__class__.__name__}`"
             )

vellum/workflows/expressions/is_nil.py

@@ -1,6 +1,6 @@
 from typing import Generic, TypeVar, Union
 
-from vellum.workflows.constants import UNDEF
+from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
@@ -19,4 +19,4 @@ class IsNilExpression(BaseDescriptor[bool], Generic[_T]):
 
     def resolve(self, state: "BaseState") -> bool:
         expression = resolve_value(self._expression, state)
-        return expression is None or expression is UNDEF
+        return expression is None or expression is undefined

vellum/workflows/expressions/is_not_nil.py

@@ -1,6 +1,6 @@
 from typing import Generic, TypeVar, Union
 
-from vellum.workflows.constants import UNDEF
+from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
@@ -19,4 +19,4 @@ class IsNotNilExpression(BaseDescriptor[bool], Generic[_T]):
 
     def resolve(self, state: "BaseState") -> bool:
         expression = resolve_value(self._expression, state)
-        return expression is not None and expression is not UNDEF
+        return expression is not None and expression is not undefined

vellum/workflows/expressions/is_not_undefined.py

@@ -1,6 +1,6 @@
 from typing import Generic, TypeVar, Union
 
-from vellum.workflows.constants import UNDEF
+from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
@@ -19,4 +19,4 @@ class IsNotUndefinedExpression(BaseDescriptor[bool], Generic[_T]):
 
     def resolve(self, state: "BaseState") -> bool:
         expression = resolve_value(self._expression, state)
-        return expression is not UNDEF
+        return expression is not undefined

vellum/workflows/expressions/is_undefined.py

@@ -1,6 +1,6 @@
 from typing import Generic, TypeVar, Union
 
-from vellum.workflows.constants import UNDEF
+from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.descriptors.utils import resolve_value
 from vellum.workflows.state.base import BaseState
@@ -19,4 +19,4 @@ class IsUndefinedExpression(BaseDescriptor[bool], Generic[_T]):
 
     def resolve(self, state: "BaseState") -> bool:
         expression = resolve_value(self._expression, state)
-        return expression is UNDEF
+        return expression is undefined

vellum/workflows/nodes/bases/base.py

@@ -5,7 +5,7 @@ from types import MappingProxyType
 from uuid import UUID
 from typing import Any, Dict, Generic, Iterator, Optional, Set, Tuple, Type, TypeVar, Union, cast, get_args
 
-from vellum.workflows.constants import UNDEF
+from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.descriptors.utils import is_unresolved, resolve_value
 from vellum.workflows.errors.types import WorkflowErrorCode
@@ -43,7 +43,23 @@ class BaseNodeMeta(type):
         # TODO: Inherit the inner Output classes from every base class.
         #   https://app.shortcut.com/vellum/story/4007/support-auto-inheriting-parent-node-outputs
 
-        if "Outputs" not in dct:
+        if "Outputs" in dct:
+            outputs_class = dct["Outputs"]
+            if not any(issubclass(base, BaseOutputs) for base in outputs_class.__bases__):
+                parent_outputs_class = next(
+                    (base.Outputs for base in bases if hasattr(base, "Outputs")),
+                    BaseOutputs,  # Default to BaseOutputs only if no parent has Outputs
+                )
+
+                # Filter out object from bases while preserving other inheritance
+                filtered_bases = tuple(base for base in outputs_class.__bases__ if base is not object)
+
+                dct["Outputs"] = type(
+                    f"{name}.Outputs",
+                    (parent_outputs_class,) + filtered_bases,
+                    {**outputs_class.__dict__, "__module__": dct["__module__"]},
+                )
+        else:
             for base in reversed(bases):
                 if hasattr(base, "Outputs"):
                     dct["Outputs"] = type(
@@ -165,7 +181,7 @@ class BaseNodeMeta(type):
                 if attr_name in yielded_attr_names:
                     continue
 
-                attr_value = getattr(resolved_cls, attr_name, UNDEF)
+                attr_value = getattr(resolved_cls, attr_name, undefined)
                 if not isinstance(attr_value, NodeReference):
                     continue
 

vellum/workflows/nodes/bases/tests/test_base_node.py

@@ -5,6 +5,7 @@ from vellum.client.types.string_vellum_value_request import StringVellumValueReq
 from vellum.core.pydantic_utilities import UniversalBaseModel
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.outputs.base import BaseOutputs
 from vellum.workflows.state.base import BaseState, StateMeta
 
 
@@ -148,3 +149,86 @@ def test_base_node__node_resolution__descriptor_in_fern_pydantic():
     node = SomeNode(state=State(foo="bar"))
 
     assert node.model.value == "bar"
+
+
+def test_base_node__inherit_base_outputs():
+    class MyNode(BaseNode):
+        class Outputs:
+            foo: str
+
+        def run(self):
+            return self.Outputs(foo="bar")  # type: ignore
+
+    # TEST that the Outputs class is a subclass of BaseOutputs
+    assert issubclass(MyNode.Outputs, BaseOutputs)
+
+    # TEST that the Outputs class does not inherit from object
+    assert object not in MyNode.Outputs.__bases__
+
+    # TEST that the Outputs class has the correct attributes
+    assert hasattr(MyNode.Outputs, "foo")
+
+    # WHEN the node is run
+    node = MyNode()
+    outputs = node.run()
+
+    # THEN the outputs should be correct
+    assert outputs.foo == "bar"
+
+
+def test_child_node__inherits_base_outputs_when_no_parent_outputs():
+    class ParentNode(BaseNode):  # No Outputs class here
+        pass
+
+    class ChildNode(ParentNode):
+        class Outputs:
+            foo: str
+
+        def run(self):
+            return self.Outputs(foo="bar")  # type: ignore
+
+    # TEST that ChildNode.Outputs is a subclass of BaseOutputs (since ParentNode has no Outputs)
+    assert issubclass(ChildNode.Outputs, BaseOutputs)
+
+    # TEST that ChildNode.Outputs has the correct attributes
+    assert hasattr(ChildNode.Outputs, "foo")
+
+    # WHEN the node is run
+    node = ChildNode()
+    outputs = node.run()
+
+    # THEN the outputs should be correct
+    assert outputs.foo == "bar"
+
+
+def test_outputs_preserves_non_object_bases():
+    class ParentNode(BaseNode):
+        class Outputs:
+            foo: str
+
+    class Foo:
+        bar: str
+
+    class ChildNode(ParentNode):
+        class Outputs(ParentNode.Outputs, Foo):
+            pass
+
+        def run(self):
+            return self.Outputs(foo="bar", bar="baz")  # type: ignore
+
+    # TEST that Outputs is a subclass of Foo and ParentNode.Outputs
+    assert Foo in ChildNode.Outputs.__bases__, "Foo should be preserved in bases"
+    assert ParentNode.Outputs in ChildNode.Outputs.__bases__, "ParentNode.Outputs should be preserved in bases"
+    assert object not in ChildNode.Outputs.__bases__, "object should not be in bases"
+
+    # TEST that Outputs has the correct attributes
+    assert hasattr(ChildNode.Outputs, "foo")
+    assert hasattr(ChildNode.Outputs, "bar")
+
+    # WHEN Outputs is instantiated
+    node = ChildNode()
+    outputs = node.run()
+
+    # THEN the output values should be correct
+    assert outputs.foo == "bar"
+    assert outputs.bar == "baz"

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

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING, Any, ClassVar, Dict, Generic, Iterator, Optional, Set, Tuple, Type, TypeVar, Union
 
-from vellum.workflows.constants import UNDEF
+from vellum.workflows.constants import undefined
 from vellum.workflows.context import execution_context, get_parent_context
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
@@ -67,7 +67,7 @@ class InlineSubworkflowNode(
     """
 
     subworkflow: Type["BaseWorkflow[InputsType, InnerStateType]"]
-    subworkflow_inputs: ClassVar[Union[EntityInputsInterface, BaseInputs, Type[UNDEF]]] = UNDEF
+    subworkflow_inputs: ClassVar[Union[EntityInputsInterface, BaseInputs, Type[undefined]]] = undefined
 
     def run(self) -> Iterator[BaseOutput]:
         with execution_context(parent_context=get_parent_context() or self._context.parent_context):
@@ -112,7 +112,7 @@ class InlineSubworkflowNode(
 
     def _compile_subworkflow_inputs(self) -> InputsType:
         inputs_class = self.subworkflow.get_inputs_class()
-        if self.subworkflow_inputs is UNDEF:
+        if self.subworkflow_inputs is undefined:
             inputs_dict = {}
             for descriptor in inputs_class:
                 if hasattr(self, descriptor.name):

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

@@ -66,6 +66,11 @@ class MapNode(BaseAdornmentNode[StateType], Generic[StateType, MapNodeItemType])
         for output_descripter in self.subworkflow.Outputs:
             mapped_items[output_descripter.name] = [None] * len(self.items)
 
+        if not self.items:
+            for output_name, output_list in mapped_items.items():
+                yield BaseOutput(name=output_name, value=output_list)
+            return
+
         self._event_queue: Queue[Tuple[int, WorkflowEvent]] = Queue()
         self._concurrency_queue: Queue[Thread] = Queue()
         fulfilled_iterations: List[bool] = []

vellum/workflows/nodes/core/map_node/tests/test_node.py

@@ -63,3 +63,25 @@ def test_map_node__use_parallelism():
     # THEN the node should have ran in parallel
     run_time = (end_ts - start_ts) / 10**9
     assert run_time < 0.2
+
+
+def test_map_node__empty_list():
+    # GIVEN a map node that is configured to use the parent's inputs and state
+    @MapNode.wrap(items=[])
+    class TestNode(BaseNode):
+        item = MapNode.SubworkflowInputs.item
+
+        class Outputs(BaseOutputs):
+            value: int
+
+        def run(self) -> Outputs:
+            time.sleep(0.03)
+            return self.Outputs(value=self.item + 1)
+
+    # WHEN the node is run
+    node = TestNode()
+    outputs = list(node.run())
+
+    # THEN the node should return an empty output
+    fulfilled_output = outputs[-1]
+    assert fulfilled_output == BaseOutput(name="value", value=[])

vellum/workflows/nodes/core/templating_node/tests/test_templating_node.py

@@ -1,8 +1,10 @@
+import pytest
 import json
-from typing import List
+from typing import List, Union
 
 from vellum.client.types.chat_message import ChatMessage
 from vellum.client.types.function_call import FunctionCall
+from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.nodes.core.templating_node.node import TemplatingNode
 from vellum.workflows.state import BaseState
@@ -155,3 +157,39 @@ def test_templating_node__function_call_output():
 
     # THEN the output is the expected function call
     assert outputs.result == FunctionCall(name="test", arguments={"key": "value"})
+
+
+def test_templating_node__blank_json_input():
+    """Test that templating node properly handles blank JSON input."""
+
+    # GIVEN a templating node that tries to parse blank JSON
+    class BlankJsonTemplateNode(TemplatingNode[BaseState, Json]):
+        template = "{{ json.loads(data) }}"
+        inputs = {
+            "data": "",  # Blank input
+        }
+
+    # WHEN the node is run
+    node = BlankJsonTemplateNode()
+
+    # THEN it should raise an appropriate error
+    with pytest.raises(NodeException) as exc_info:
+        node.run()
+
+    assert "Unable to render jinja template:\nCannot run json.loads() on empty input" in str(exc_info.value)
+
+
+def test_templating_node__union_float_int_output():
+    # GIVEN a templating node that outputs either a float or an int
+    class UnionTemplateNode(TemplatingNode[BaseState, Union[float, int]]):
+        template = """{{ obj[\"score\"] | float }}"""
+        inputs = {
+            "obj": {"score": 42.5},
+        }
+
+    # WHEN the node is run
+    node = UnionTemplateNode()
+    outputs = node.run()
+
+    # THEN it should correctly parse as a float
+    assert outputs.result == 42.5