vellum-ai 0.12.8__py3-none-any.whl → 0.12.9__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.12.8",
+            "X-Fern-SDK-Version": "0.12.9",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

vellum/evaluations/resources.py

@@ -12,7 +12,6 @@ from vellum.evaluations.constants import DEFAULT_MAX_POLLING_DURATION_MS, DEFAUL
 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.evaluations.utils.uuid import is_valid_uuid
 from vellum.types import (
     ExternalTestCaseExecutionRequest,
     NamedTestCaseVariableValueRequest,
@@ -24,6 +23,7 @@ from vellum.types import (
     TestSuiteRunState,
 )
 from vellum.utils.typing import cast_not_optional
+from vellum.utils.uuid import is_valid_uuid
 
 logger = logging.getLogger(__name__)
 

vellum/prompts/blocks/compilation.py

@@ -104,16 +104,16 @@ def compile_prompt_blocks(
                 chat_message_blocks = _compile_chat_messages_as_prompt_blocks(compiled_input.value)
                 compiled_blocks.extend(chat_message_blocks)
             else:
-                raise ValueError(f"Invalid input type for variable block: {compiled_input.type}")
+                raise PromptCompilationError(f"Invalid input type for variable block: {compiled_input.type}")
 
         elif block.block_type == "RICH_TEXT":
             value_block = _compile_rich_text_block_as_value_block(block=block, inputs=sanitized_inputs)
             compiled_blocks.append(value_block)
 
         elif block.block_type == "FUNCTION_DEFINITION":
-            raise ValueError("Function definitions shouldn't go through compilation process")
+            raise PromptCompilationError("Function definitions shouldn't go through compilation process")
         else:
-            raise ValueError(f"Unknown block_type: {block.block_type}")
+            raise PromptCompilationError(f"Unknown block_type: {block.block_type}")
 
     return compiled_blocks
 
@@ -172,7 +172,7 @@ def _compile_rich_text_block_as_value_block(
                     f"Input variable '{child_block.input_variable}' must be of type STRING or JSON"
                 )
         else:
-            raise ValueError(f"Invalid child block_type for RICH_TEXT: {child_block.block_type}")
+            raise PromptCompilationError(f"Invalid child block_type for RICH_TEXT: {child_block.block_type}")
 
     return CompiledValuePromptBlock(content=StringVellumValue(value=value), cache_config=block.cache_config)
 

vellum/workflows/nodes/bases/__init__.py

@@ -1,7 +1,5 @@
 from .base import BaseNode
-from .base_subworkflow_node import BaseSubworkflowNode
 
 __all__ = [
     "BaseNode",
-    "BaseSubworkflowNode",
 ]

vellum/workflows/nodes/bases/base.py

@@ -344,8 +344,8 @@ class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
         all_inputs = {}
         for key, value in inputs.items():
             path_parts = key.split(".")
-            node_attribute_discriptor = getattr(self.__class__, path_parts[0])
-            inputs_key = reduce(lambda acc, part: acc[part], path_parts[1:], node_attribute_discriptor)
+            node_attribute_descriptor = getattr(self.__class__, path_parts[0])
+            inputs_key = reduce(lambda acc, part: acc[part], path_parts[1:], node_attribute_descriptor)
             all_inputs[inputs_key] = value
 
         self._inputs = MappingProxyType(all_inputs)
@@ -355,7 +355,3 @@ class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
 
     def __repr__(self) -> str:
         return str(self.__class__)
-
-
-class MyNode2(BaseNode):
-    pass

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

@@ -1,12 +1,14 @@
-from typing import TYPE_CHECKING, Generic, Iterator, Optional, Set, Type, TypeVar
+from typing import TYPE_CHECKING, ClassVar, Generic, Iterator, Optional, Set, Type, TypeVar, Union
 
 from vellum.workflows.context import execution_context, get_parent_context
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
-from vellum.workflows.nodes.bases.base_subworkflow_node import BaseSubworkflowNode
+from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.outputs.base import BaseOutput, BaseOutputs
 from vellum.workflows.state.base import BaseState
 from vellum.workflows.state.context import WorkflowContext
+from vellum.workflows.types.core import EntityInputsInterface
 from vellum.workflows.types.generics import StateType, WorkflowInputsType
 
 if TYPE_CHECKING:
@@ -15,7 +17,7 @@ if TYPE_CHECKING:
 InnerStateType = TypeVar("InnerStateType", bound=BaseState)
 
 
-class InlineSubworkflowNode(BaseSubworkflowNode[StateType], Generic[StateType, WorkflowInputsType, InnerStateType]):
+class InlineSubworkflowNode(BaseNode[StateType], Generic[StateType, WorkflowInputsType, InnerStateType]):
     """
     Used to execute a Subworkflow defined inline.
 
@@ -24,14 +26,13 @@ class InlineSubworkflowNode(BaseSubworkflowNode[StateType], Generic[StateType, W
     """
 
     subworkflow: Type["BaseWorkflow[WorkflowInputsType, InnerStateType]"]
+    subworkflow_inputs: ClassVar[Union[EntityInputsInterface, BaseInputs]] = {}
 
     def run(self) -> Iterator[BaseOutput]:
         with execution_context(parent_context=get_parent_context() or self._context.parent_context):
             subworkflow = self.subworkflow(
                 parent_state=self.state,
-                context=WorkflowContext(
-                    _vellum_client=self._context._vellum_client,
-                ),
+                context=WorkflowContext(vellum_client=self._context.vellum_client),
             )
             subworkflow_stream = subworkflow.stream(
                 inputs=self._compile_subworkflow_inputs(),
@@ -68,4 +69,9 @@ class InlineSubworkflowNode(BaseSubworkflowNode[StateType], Generic[StateType, W
 
     def _compile_subworkflow_inputs(self) -> WorkflowInputsType:
         inputs_class = self.subworkflow.get_inputs_class()
-        return inputs_class(**self.subworkflow_inputs)
+        if isinstance(self.subworkflow_inputs, dict):
+            return inputs_class(**self.subworkflow_inputs)
+        elif isinstance(self.subworkflow_inputs, inputs_class):
+            return self.subworkflow_inputs
+        else:
+            raise ValueError(f"Invalid subworkflow inputs type: {type(self.subworkflow_inputs)}")

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

@@ -0,0 +1,41 @@
+import pytest
+
+from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.nodes.core.inline_subworkflow_node.node import InlineSubworkflowNode
+from vellum.workflows.outputs.base import BaseOutput
+from vellum.workflows.state.base import BaseState
+from vellum.workflows.workflows.base import BaseWorkflow
+
+
+class Inputs(BaseInputs):
+    foo: str
+
+
+class MyInnerNode(BaseNode):
+    class Outputs(BaseNode.Outputs):
+        out = Inputs.foo
+
+
+class MySubworkflow(BaseWorkflow[Inputs, BaseState]):
+    graph = MyInnerNode
+
+    class Outputs(BaseWorkflow.Outputs):
+        out = MyInnerNode.Outputs.out
+
+
+@pytest.mark.parametrize("inputs", [{"foo": "bar"}, Inputs(foo="bar")])
+def test_inline_subworkflow_node__inputs(inputs):
+    # GIVEN a node setup with subworkflow inputs
+    class MyNode(InlineSubworkflowNode):
+        subworkflow = MySubworkflow
+        subworkflow_inputs = inputs
+
+    # WHEN the node is run
+    node = MyNode()
+    events = list(node.run())
+
+    # THEN the output is as expected
+    assert events == [
+        BaseOutput(name="out", value="bar"),
+    ]

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

@@ -108,7 +108,7 @@ class MapNode(BaseNode, Generic[StateType, MapNodeItemType]):
             self._run_subworkflow(item=item, index=index)
 
     def _run_subworkflow(self, *, item: MapNodeItemType, index: int) -> None:
-        context = WorkflowContext(_vellum_client=self._context._vellum_client)
+        context = WorkflowContext(vellum_client=self._context.vellum_client)
         subworkflow = self.subworkflow(parent_state=self.state, context=context)
         events = subworkflow.stream(
             inputs=self.SubworkflowInputs(index=index, item=item, all_items=self.items),

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

@@ -1,3 +1,4 @@
+import json
 from typing import Any, Callable, ClassVar, Dict, Generic, Mapping, Tuple, Type, TypeVar, Union, get_args
 
 from vellum.utils.templating.constants import DEFAULT_JINJA_CUSTOM_FILTERS, DEFAULT_JINJA_GLOBALS
@@ -7,7 +8,7 @@ from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.bases.base import BaseNodeMeta
-from vellum.workflows.types.core import EntityInputsInterface
+from vellum.workflows.types.core import EntityInputsInterface, Json
 from vellum.workflows.types.generics import StateType
 from vellum.workflows.types.utils import get_original_base
 
@@ -87,6 +88,12 @@ class TemplatingNode(BaseNode[StateType], Generic[StateType, _OutputType], metac
         if output_type is bool:
             return bool(rendered_template)
 
+        if output_type is Json:
+            try:
+                return json.loads(rendered_template)
+            except json.JSONDecodeError:
+                raise ValueError("Invalid JSON format for rendered_template")
+
         raise ValueError(f"Unsupported output type: {output_type}")
 
     def run(self) -> Outputs:

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

@@ -2,6 +2,8 @@ import json
 
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.nodes.core.templating_node.node import TemplatingNode
+from vellum.workflows.state import BaseState
+from vellum.workflows.types.core import Json
 
 
 def test_templating_node__dict_output():
@@ -22,6 +24,70 @@ def test_templating_node__dict_output():
     assert json.loads(outputs.result) == {"key": "value"}
 
 
+def test_templating_node__int_output():
+    # GIVEN a templating node that outputs an integer
+    class IntTemplateNode(TemplatingNode[BaseState, int]):
+        template = "{{ data }}"
+        inputs = {
+            "data": 42,
+        }
+
+    # WHEN the node is run
+    node = IntTemplateNode()
+    outputs = node.run()
+
+    # THEN the output is the expected integer
+    assert outputs.result == 42
+
+
+def test_templating_node__float_output():
+    # GIVEN a templating node that outputs a float
+    class FloatTemplateNode(TemplatingNode[BaseState, float]):
+        template = "{{ data }}"
+        inputs = {
+            "data": 42.5,
+        }
+
+    # WHEN the node is run
+    node = FloatTemplateNode()
+    outputs = node.run()
+
+    # THEN the output is the expected float
+    assert outputs.result == 42.5
+
+
+def test_templating_node__bool_output():
+    # GIVEN a templating node that outputs a bool
+    class BoolTemplateNode(TemplatingNode[BaseState, bool]):
+        template = "{{ data }}"
+        inputs = {
+            "data": True,
+        }
+
+    # WHEN the node is run
+    node = BoolTemplateNode()
+    outputs = node.run()
+
+    # THEN the output is the expected bool
+    assert outputs.result is True
+
+
+def test_templating_node__json_output():
+    # GIVEN a templating node that outputs JSON
+    class JSONTemplateNode(TemplatingNode[BaseState, Json]):
+        template = "{{ data }}"
+        inputs = {
+            "data": {"key": "value"},
+        }
+
+    # WHEN the node is run
+    node = JSONTemplateNode()
+    outputs = node.run()
+
+    # THEN the output is the expected JSON
+    assert outputs.result == {"key": "value"}
+
+
 def test_templating_node__execution_count_reference():
     # GIVEN a random node
     class OtherNode(BaseNode):

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

@@ -73,9 +73,7 @@ class TryNode(BaseNode[StateType], Generic[StateType], metaclass=_TryNodeMeta):
     def run(self) -> Iterator[BaseOutput]:
         subworkflow = self.subworkflow(
             parent_state=self.state,
-            context=WorkflowContext(
-                _vellum_client=self._context._vellum_client,
-            ),
+            context=WorkflowContext(vellum_client=self._context.vellum_client),
         )
         subworkflow_stream = subworkflow.stream(
             event_filter=all_workflow_event_filter,

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

@@ -103,7 +103,7 @@ def test_try_node__use_parent_execution_context():
     # WHEN the node is run with a custom vellum client
     node = TestNode(
         context=WorkflowContext(
-            _vellum_client=Vellum(api_key="test-key"),
+            vellum_client=Vellum(api_key="test-key"),
         )
     )
     outputs = list(node.run())

vellum/workflows/nodes/displayable/bases/api_node/node.py

@@ -26,11 +26,11 @@ class BaseAPINode(BaseNode, Generic[StateType]):
     url: str
     method: APIRequestMethod
     data: Optional[str] = None
-    json: Optional["Json"] = None
+    json: Optional[Json] = None
     headers: Optional[Dict[str, Union[str, VellumSecret]]] = None
 
     class Outputs(BaseOutputs):
-        json: Optional["Json"]
+        json: Optional[Json]
         headers: Dict[str, str]
         status_code: int
         text: str

vellum/workflows/nodes/displayable/bases/search_node.py

@@ -12,6 +12,7 @@ from vellum import (
     SearchWeightsRequest,
 )
 from vellum.core import ApiError, RequestOptions
+from vellum.utils.uuid import is_valid_uuid
 from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases import BaseNode
@@ -73,11 +74,13 @@ class BaseSearchNode(BaseNode[StateType], Generic[StateType]):
         results: List[SearchResult]
 
     def _perform_search(self) -> SearchResponse:
+        index_is_uuid = True if isinstance(self.document_index, UUID) else is_valid_uuid(self.document_index)
+
         try:
             return self._context.vellum_client.search(
                 query=self.query,
-                index_id=str(self.document_index) if isinstance(self.document_index, UUID) else None,
-                index_name=self.document_index if isinstance(self.document_index, str) else None,
+                index_id=str(self.document_index) if index_is_uuid else None,
+                index_name=str(self.document_index) if not index_is_uuid else None,
                 options=self.options,
             )
         except NotFoundError:

vellum/workflows/nodes/displayable/subworkflow_deployment_node/node.py

@@ -17,12 +17,13 @@ from vellum.workflows.context import get_parent_context
 from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.errors.types import workflow_event_error_to_workflow_error
 from vellum.workflows.exceptions import NodeException
-from vellum.workflows.nodes.bases.base_subworkflow_node.node import BaseSubworkflowNode
+from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.outputs.base import BaseOutput
+from vellum.workflows.types.core import EntityInputsInterface
 from vellum.workflows.types.generics import StateType
 
 
-class SubworkflowDeploymentNode(BaseSubworkflowNode[StateType], Generic[StateType]):
+class SubworkflowDeploymentNode(BaseNode[StateType], Generic[StateType]):
     """
     Used to execute a Workflow Deployment.
 
@@ -38,6 +39,7 @@ class SubworkflowDeploymentNode(BaseSubworkflowNode[StateType], Generic[StateTyp
 
     # Either the Workflow Deployment's UUID or its name.
     deployment: ClassVar[Union[UUID, str]]
+    subworkflow_inputs: ClassVar[EntityInputsInterface] = {}
 
     release_tag: str = LATEST_RELEASE_TAG
     external_id: Optional[str] = OMIT

vellum/workflows/sandbox.py

@@ -1,4 +1,4 @@
-from typing import Generic, Sequence, Type
+from typing import Generic, Sequence
 
 import dotenv
 
@@ -9,8 +9,8 @@ from vellum.workflows.types.generics import WorkflowType
 from vellum.workflows.workflows.event_filters import root_workflow_event_filter
 
 
-class SandboxRunner(Generic[WorkflowType]):
-    def __init__(self, workflow: Type[WorkflowType], inputs: Sequence[BaseInputs]):
+class WorkflowSandboxRunner(Generic[WorkflowType]):
+    def __init__(self, workflow: WorkflowType, inputs: Sequence[BaseInputs]):
         if not inputs:
             raise ValueError("Inputs are required to have at least one defined inputs")
 
@@ -30,8 +30,7 @@ class SandboxRunner(Generic[WorkflowType]):
 
         selected_inputs = self._inputs[index]
 
-        workflow = self._workflow()
-        events = workflow.stream(
+        events = self._workflow.stream(
             inputs=selected_inputs,
             event_filter=root_workflow_event_filter,
         )

vellum/workflows/state/context.py

@@ -13,11 +13,12 @@ if TYPE_CHECKING:
 class WorkflowContext:
     def __init__(
         self,
-        _vellum_client: Optional[Vellum] = None,
-        _parent_context: Optional[ParentContext] = None,
+        *,
+        vellum_client: Optional[Vellum] = None,
+        parent_context: Optional[ParentContext] = None,
     ):
-        self._vellum_client = _vellum_client
-        self._parent_context = _parent_context
+        self._vellum_client = vellum_client
+        self._parent_context = parent_context
         self._event_queue: Optional[Queue["WorkflowEvent"]] = None
 
     @cached_property

vellum/workflows/tests/test_sandbox.py

@@ -3,7 +3,7 @@ from typing import List
 
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases.base import BaseNode
-from vellum.workflows.sandbox import SandboxRunner
+from vellum.workflows.sandbox import WorkflowSandboxRunner
 from vellum.workflows.state.base import BaseState
 from vellum.workflows.workflows.base import BaseWorkflow
 
@@ -49,7 +49,7 @@ def test_sandbox_runner__happy_path(mock_logger, run_kwargs, expected_last_log):
     ]
 
     # WHEN we run the sandbox
-    runner = SandboxRunner(workflow=Workflow, inputs=inputs)
+    runner = WorkflowSandboxRunner(workflow=Workflow(), inputs=inputs)
     runner.run(**run_kwargs)
 
     # THEN we see the logs

vellum/workflows/utils/tests/test_vellum_variables.py

@@ -2,6 +2,7 @@ import pytest
 from typing import List, Optional
 
 from vellum import ChatMessage, SearchResult
+from vellum.workflows.types.core import Json
 from vellum.workflows.utils.vellum_variables import primitive_type_to_vellum_variable_type
 
 
@@ -18,6 +19,8 @@ from vellum.workflows.utils.vellum_variables import primitive_type_to_vellum_var
         (Optional[List[ChatMessage]], "CHAT_HISTORY"),
         (List[SearchResult], "SEARCH_RESULTS"),
         (Optional[List[SearchResult]], "SEARCH_RESULTS"),
+        (Json, "JSON"),
+        (Optional[Json], "JSON"),
     ],
 )
 def test_primitive_type_to_vellum_variable_type(type_, expected):

vellum/workflows/utils/vellum_variables.py

@@ -35,14 +35,15 @@ def primitive_type_to_vellum_variable_type(type_: Union[Type, BaseDescriptor]) -
         if len(types) != 1:
             # Check explicitly for our internal JSON type.
             # Matches the type found at vellum.workflows.utils.vellum_variables.Json
-            if types == [
+            actual_types_with_explicit_ref = [
                 bool,
                 int,
                 float,
                 str,
-                typing.List[typing.ForwardRef("Json")],  # type: ignore [misc]
-                typing.Dict[str, typing.ForwardRef("Json")],  # type: ignore [misc]
-            ]:
+                typing.List[Json],
+                typing.Dict[str, Json],
+            ]
+            if types == actual_types_with_explicit_ref:
                 return "JSON"
             raise ValueError(f"Expected Descriptor to only have one type, got {types}")
 

vellum/workflows/workflows/base.py

@@ -121,10 +121,11 @@ class BaseWorkflow(Generic[WorkflowInputsType, StateType], metaclass=_BaseWorkfl
 
     def __init__(
         self,
+        *,
+        context: Optional[WorkflowContext] = None,
         parent_state: Optional[BaseState] = None,
         emitters: Optional[List[BaseWorkflowEmitter]] = None,
         resolvers: Optional[List[BaseWorkflowResolver]] = None,
-        context: Optional[WorkflowContext] = None,
     ):
         self._parent_state = parent_state
         self.emitters = emitters or (self.emitters if hasattr(self, "emitters") else [])
@@ -188,6 +189,7 @@ class BaseWorkflow(Generic[WorkflowInputsType, StateType], metaclass=_BaseWorkfl
     def run(
         self,
         inputs: Optional[WorkflowInputsType] = None,
+        *,
         state: Optional[StateType] = None,
         entrypoint_nodes: Optional[RunFromNodeArg] = None,
         external_inputs: Optional[ExternalInputsArg] = None,
@@ -281,8 +283,9 @@ class BaseWorkflow(Generic[WorkflowInputsType, StateType], metaclass=_BaseWorkfl
 
     def stream(
         self,
-        event_filter: Optional[Callable[[Type["BaseWorkflow"], WorkflowEvent], bool]] = None,
         inputs: Optional[WorkflowInputsType] = None,
+        *,
+        event_filter: Optional[Callable[[Type["BaseWorkflow"], WorkflowEvent], bool]] = None,
         state: Optional[StateType] = None,
         entrypoint_nodes: Optional[RunFromNodeArg] = None,
         external_inputs: Optional[ExternalInputsArg] = None,

{vellum_ai-0.12.8.dist-info → vellum_ai-0.12.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vellum-ai
-Version: 0.12.8
+Version: 0.12.9
 Summary: 
 License: MIT
 Requires-Python: >=3.9,<4.0

{vellum_ai-0.12.8.dist-info → vellum_ai-0.12.9.dist-info}/RECORD

@@ -12,7 +12,7 @@ vellum_cli/tests/conftest.py,sha256=eFGwBxib3Nki830lIFintB0b6r4x8T_KMnmzhlTY5x0,
 vellum_cli/tests/test_config.py,sha256=uvKGDc8BoVyT9_H0Z-g8469zVxomn6Oi3Zj-vK7O_wU,2631
 vellum_cli/tests/test_main.py,sha256=qDZG-aQauPwBwM6A2DIu1494n47v3pL28XakTbLGZ-k,272
 vellum_cli/tests/test_pull.py,sha256=Bnf21VjfiRb_j495idz5N8afucagtiktNCtVMvU8tGs,18977
-vellum_cli/tests/test_push.py,sha256=V2iGcskh2X3OHj2uV5Vx_BhmtyfmUkyx0lrp8DDOExc,5824
+vellum_cli/tests/test_push.py,sha256=NpwGXuZSzrR7B6hBO1UF9O8im13_LlpSqncVSdzYDiQ,5812
 vellum_ee/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -34,7 +34,7 @@ vellum_ee/workflows/display/nodes/vellum/error_node.py,sha256=ygTjSjYDI4DtkxADWu
 vellum_ee/workflows/display/nodes/vellum/final_output_node.py,sha256=t5iJQVoRT5g-v2IiUb4kFYdvUVKch0zn27016pzDZoo,2761
 vellum_ee/workflows/display/nodes/vellum/guardrail_node.py,sha256=3TJvHX_Uuf_gr94VkYc_zmNH8I5p71ChIeoAbJZ3ddY,2158
 vellum_ee/workflows/display/nodes/vellum/inline_prompt_node.py,sha256=DYhxHgFT06CNCpovO4Z-wFPqCjFKxyl89ygFs8AucRQ,7189
-vellum_ee/workflows/display/nodes/vellum/inline_subworkflow_node.py,sha256=x5wiuWbRjxNcPGu8BoBEKHwPeqCpHE-vrGjAdM5TJOs,4721
+vellum_ee/workflows/display/nodes/vellum/inline_subworkflow_node.py,sha256=IqPQdlxLdaMirgDbOSxq17d8bolqqjjRPy4t3YCBhmc,5028
 vellum_ee/workflows/display/nodes/vellum/map_node.py,sha256=AqUlItgSZij12qRKguKVmDbbaLuDy3Cdom5uOlJPqrc,3640
 vellum_ee/workflows/display/nodes/vellum/merge_node.py,sha256=jzO63B9KiEAncnBqmz2ZTcxjmEHozMEe7WnfpcpsQYg,3195
 vellum_ee/workflows/display/nodes/vellum/note_node.py,sha256=9VpC3h0RYOxJuRbjDwidBYlLKakkmlEnDMBh2C7lHcY,1107
@@ -60,6 +60,7 @@ vellum_ee/workflows/display/tests/workflow_serialization/test_basic_merge_node_s
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_prompt_deployment_serialization.py,sha256=NkpgaTbu6nLr3iwgsSNtiHyiNDCUaFakd1JaoW6CC6Y,9489
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_search_node_serialization.py,sha256=9R6ELHBn9tsp3cy15q1qp1OByyCxFOVdrM67EwCYY50,12984
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_subworkflow_deployment_serialization.py,sha256=8bz0vm_EyQKSjnwS5vqqgnjE9ygvm-CaPKcwCfeOrlo,12704
+vellum_ee/workflows/display/tests/workflow_serialization/test_basic_templating_node_serialization.py,sha256=6LrGPS7e9CWpjFq2hpliSzP9kDpZ9KqvBNlNO3sq8cs,8063
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_terminal_node_serialization.py,sha256=xG8nKA1iKXxUe1fnD2X6qm7cUGW14iq2P-L16zhcKC8,4271
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_try_node_serialization.py,sha256=1_02RbghUwhKMr8VtRaPjHOXAX59hgWw1rJ2EDyKs-E,2880
 vellum_ee/workflows/display/tests/workflow_serialization/test_complex_terminal_node_serialization.py,sha256=BGCgJ3WWiYK5fWJp_Yz-aWQPli5sIKOhLTVYfG9Tpq8,9177
@@ -76,7 +77,7 @@ vellum/client/README.md,sha256=JkCJjmMZl4jrPj46pkmL9dpK4gSzQQmP5I7z4aME4LY,4749
 vellum/client/__init__.py,sha256=o4m7iRZWEV8rP3GkdaztHAjNmjxjWERlarviFoHzuKI,110927
 vellum/client/core/__init__.py,sha256=SQ85PF84B9MuKnBwHNHWemSGuy-g_515gFYNFhvEE0I,1438
 vellum/client/core/api_error.py,sha256=RE8LELok2QCjABadECTvtDp7qejA1VmINCh6TbqPwSE,426
-vellum/client/core/client_wrapper.py,sha256=oWk19_A_3mvqQM_W3wJgQnObX6YIE918NEp9olVAuEo,1868
+vellum/client/core/client_wrapper.py,sha256=W6xaTM0O9LGmf_593EW5mnu33zCfMxGoWxp7zMTtbok,1868
 vellum/client/core/datetime_utils.py,sha256=nBys2IsYrhPdszxGKCNRPSOCwa-5DWOHG95FB8G9PKo,1047
 vellum/client/core/file.py,sha256=X9IbmkZmB2bB_DpmZAO3crWdXagOakAyn6UCOCImCPg,2322
 vellum/client/core/http_client.py,sha256=R0pQpCppnEtxccGvXl4uJ76s7ro_65Fo_erlNNLp_AI,19228
@@ -649,19 +650,18 @@ vellum/errors/not_found_error.py,sha256=gC71YBdPyHR46l3RNTs0v9taVvAY0gWRFrcKpKzb
 vellum/evaluations/__init__.py,sha256=hNsLoHSykqXDJP-MwFvu2lExImxo9KEyEJjt_fdAzpE,77
 vellum/evaluations/constants.py,sha256=Vteml4_csZsMgo_q3-71E3JRCAoN6308TXLu5nfLhmU,116
 vellum/evaluations/exceptions.py,sha256=6Xacoyv43fJvVf6Dt6Io5a-f9vF12Tx51jzsQRNSqhY,56
-vellum/evaluations/resources.py,sha256=33IDRHOjrRsC20JHs0BtRlaSYCY9Gg-AkA6qkPjBrWo,12676
+vellum/evaluations/resources.py,sha256=7xS4eYeRLLz44KLMDL0wwIY80wMy2carFREB85k_Avk,12664
 vellum/evaluations/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/evaluations/utils/env.py,sha256=Xj_nxsoU5ox06EOTjRopR4lrigQI6Le6qbWGltYoEGU,276
 vellum/evaluations/utils/exceptions.py,sha256=dXMAkzqbHV_AP5FjjbegPlfUE0zQDlpA3qOsoOJUxfg,49
 vellum/evaluations/utils/paginator.py,sha256=rEED_BJAXAM6tM1yMwHePNzszjq_tTq4NbQvi1jWQ_Q,697
-vellum/evaluations/utils/uuid.py,sha256=Ch6wWRgwICxLxJCTl5iE3EdRlZj2zADR-zUMUtjcMWM,214
 vellum/plugins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/plugins/pydantic.py,sha256=EbI0pJMhUS9rLPSkzmAELfnCHrWCJzOrU06T8ommwdw,2334
 vellum/plugins/utils.py,sha256=U9ZY9KdE3RRvbcG01hXxu9CvfJD6Fo7nJDgcHjQn0FI,606
 vellum/plugins/vellum_mypy.py,sha256=VC15EzjTsXOb9uF1bky4rcxePP-0epMVmCsLB2z4Dh8,24816
 vellum/prompts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/prompts/blocks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/prompts/blocks/compilation.py,sha256=hBN_ajq77tSkVyUIcDlO-Qu77PSeJ1OzVhp70NmQd2k,7458
+vellum/prompts/blocks/compilation.py,sha256=GVxV0iaVp72RCNMlLtUasfg25jBjbeEu3u97QUSbrQo,7506
 vellum/prompts/blocks/exceptions.py,sha256=vmk5PV6Vyw9nKjZYQDUDW0LH8MfQNIgFvFb_mFWdIRI,50
 vellum/prompts/blocks/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/prompts/blocks/tests/test_compilation.py,sha256=0DhMoc4huHR6YnNL-0aBLmWSyUfw2BpRq_gEdKsQmAc,3693
@@ -1210,6 +1210,7 @@ vellum/utils/templating/custom_filters.py,sha256=Q0DahYRHP4KfaUXDt9XxN-DFLBrAxlv
 vellum/utils/templating/exceptions.py,sha256=cDp140PP4OnInW4qAvg3KqiSiF70C71UyEAKRBR1Abo,46
 vellum/utils/templating/render.py,sha256=0vgkwhu2A6o64aT4fUdTSLFCEMbeRjAKAuvv2k2LYGY,1772
 vellum/utils/typing.py,sha256=wx_daFqD69cYkuJTVnvNrpjhqC3uuhbnyJ9_bIwC9OU,327
+vellum/utils/uuid.py,sha256=Ch6wWRgwICxLxJCTl5iE3EdRlZj2zADR-zUMUtjcMWM,214
 vellum/version.py,sha256=jq-1PlAYxN9AXuaZqbYk9ak27SgE2lw9Ia5gx1b1gVI,76
 vellum/workflows/README.md,sha256=MLNm-ihc0ao6I8gwwOhXQQBf0jOf-EsA9C519ALYI1o,3610
 vellum/workflows/__init__.py,sha256=CssPsbNvN6rDhoLuqpEv7MMKGa51vE6dvAh6U31Pcio,71
@@ -1271,19 +1272,19 @@ vellum/workflows/inputs/__init__.py,sha256=AbFEteIYEvCb14fM3EK7bhM-40-6s494rSlIh
 vellum/workflows/inputs/base.py,sha256=1kMgr0WqCYdWUqgFvgSoAMw2067FAlgwhGXLgbIOrLY,2391
 vellum/workflows/logging.py,sha256=_a217XogktV4Ncz6xKFz7WfYmZAzkfVRVuC0rWob8ls,437
 vellum/workflows/nodes/__init__.py,sha256=aVdQVv7Y3Ro3JlqXGpxwaU2zrI06plDHD2aumH5WUIs,1157
-vellum/workflows/nodes/bases/__init__.py,sha256=Ll1Ti6t3e_HKtGLsQTHAJevDmfo0QtfgPZUZ9FCRduI,140
-vellum/workflows/nodes/bases/base.py,sha256=oqNO8rEeSu86wBuXQ8pGIOCZP7Bc_PdDL1etz_ef2A0,14271
-vellum/workflows/nodes/bases/base_subworkflow_node/__init__.py,sha256=0nkHQiFC4IpA1ZGx60XG0BLUWF6hwUpgqmS3ZrlFGhg,80
-vellum/workflows/nodes/bases/base_subworkflow_node/node.py,sha256=vC0gUBQewAUNtP3i2G0-LUpE_kY-r_ijBD_tS1XkQ1E,383
+vellum/workflows/nodes/bases/__init__.py,sha256=cniHuz_RXdJ4TQgD8CBzoiKDiPxg62ErdVpCbWICX64,58
+vellum/workflows/nodes/bases/base.py,sha256=_Ms_Yov6sIsgWnKb0OWnOG7liqgjFSat0y1OIX36hFA,14235
 vellum/workflows/nodes/bases/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/bases/tests/test_base_node.py,sha256=ghpLm_ljNBxWs43GlvIId47hOVwKU50XpvZxmlg6_8g,3439
 vellum/workflows/nodes/core/__init__.py,sha256=5zDMCmyt1v0HTJzlUBwq3U9L825yZGZhT9JL18-mRR4,455
 vellum/workflows/nodes/core/error_node/__init__.py,sha256=g7RRnlHhqu4qByfLjBwCunmgGA8dI5gNsjS3h6TwlSI,60
 vellum/workflows/nodes/core/error_node/node.py,sha256=MFHU5vITYSK-L9CuMZ49In2ZeNLWnhZD0f8r5dWvb5Y,1270
 vellum/workflows/nodes/core/inline_subworkflow_node/__init__.py,sha256=nKNEH1QTl-1PcvmYoqSWEl0-t6gAur8GLTXHzklRQfM,84
-vellum/workflows/nodes/core/inline_subworkflow_node/node.py,sha256=vSlDEKwJsd2YazkWPRXPiNKZtbyhTBhfO3dJxcNiSWE,3059
+vellum/workflows/nodes/core/inline_subworkflow_node/node.py,sha256=btscTP3T5VzvuNpbzaUlRZ1ahMkTox0Vyv17tI7YFUw,3467
+vellum/workflows/nodes/core/inline_subworkflow_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vellum/workflows/nodes/core/inline_subworkflow_node/tests/test_node.py,sha256=99LLPgHMqohGL-G4KqOSjeVlDR_FH8Rv1gtRii85MC4,1143
 vellum/workflows/nodes/core/map_node/__init__.py,sha256=MXpZYmGfhsMJHqqlpd64WiJRtbAtAMQz-_3fCU_cLV0,56
-vellum/workflows/nodes/core/map_node/node.py,sha256=vubEWObFh6rVUZ9GGHSi7H9b-Y-SHCwEgYkgdb3QTgM,7288
+vellum/workflows/nodes/core/map_node/node.py,sha256=5Bqi0co1T9Ex_sTlyTDMGahwsUWd9NCO0vTY6UqsZeQ,7286
 vellum/workflows/nodes/core/map_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/core/map_node/tests/test_node.py,sha256=RHSZs7t6mW3UWvRrXnHZqaXVdRT2ZquOK_YHJ-gzXsU,1871
 vellum/workflows/nodes/core/retry_node/__init__.py,sha256=lN2bIy5a3Uzhs_FYCrooADyYU6ZGShtvLKFWpelwPvo,60
@@ -1291,25 +1292,25 @@ vellum/workflows/nodes/core/retry_node/node.py,sha256=IjNcpzFmHyBUjOHEoULLbKf85B
 vellum/workflows/nodes/core/retry_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/core/retry_node/tests/test_node.py,sha256=QXTnHwmJHISxXjvZMeuuEo0iVugVMJyaJoggI8yKXfI,3132
 vellum/workflows/nodes/core/templating_node/__init__.py,sha256=GmyuYo81_A1_Bz6id69ozVFS6FKiuDsZTiA3I6MaL2U,70
-vellum/workflows/nodes/core/templating_node/node.py,sha256=mWNzsa6TLosrD3higKIsiqEv54OIfNY7YzFDkuQgm6k,3964
-vellum/workflows/nodes/core/templating_node/tests/test_templating_node.py,sha256=0BtXeSix7KGIuKzlPFTMLATpNnFPhut1UV_srGptkt0,1120
+vellum/workflows/nodes/core/templating_node/node.py,sha256=N-NOBd-UY91qO9orCcW4KEbhNvDQivZPA-PCxs-M0RM,4204
+vellum/workflows/nodes/core/templating_node/tests/test_templating_node.py,sha256=nW_kyJ9RAqz45_kJE_rlhOOvbV4OO3hecP-P-ydQpkw,2845
 vellum/workflows/nodes/core/try_node/__init__.py,sha256=JVD4DrldTIqFQQFrubs9KtWCCc0YCAc7Fzol5ZWIWeM,56
-vellum/workflows/nodes/core/try_node/node.py,sha256=_xkpUNIfHXuwjivMBxdU5DegsNge2ITW5nBifWmBPTY,6670
+vellum/workflows/nodes/core/try_node/node.py,sha256=e4gavIJ9AHM0JCKOrBIeKC4aHxmJK3j17XTBaipqfpc,6637
 vellum/workflows/nodes/core/try_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/nodes/core/try_node/tests/test_node.py,sha256=uqMU7ZPPHI6a-VoWnMSVwTHoRmqCk6w8wzaXogTV_J4,4093
+vellum/workflows/nodes/core/try_node/tests/test_node.py,sha256=Wc2kLl-MkffsBxl3IiFaqLd16e2Iosxhk7qBnojPvQg,4092
 vellum/workflows/nodes/displayable/__init__.py,sha256=6F_4DlSwvHuilWnIalp8iDjjDXl0Nmz4QzJV2PYe5RI,1023
 vellum/workflows/nodes/displayable/api_node/__init__.py,sha256=MoxdQSnidIj1Nf_d-hTxlOxcZXaZnsWFDbE-PkTK24o,56
 vellum/workflows/nodes/displayable/api_node/node.py,sha256=ehvJNkI-L_WLn8pszCaRkQuhRDgioCLaX6TT72KM_9E,2111
 vellum/workflows/nodes/displayable/bases/__init__.py,sha256=0mWIx3qUrzllV7jqt7wN03vWGMuI1WrrLZeMLT2Cl2c,304
 vellum/workflows/nodes/displayable/bases/api_node/__init__.py,sha256=1jwx4WC358CLA1jgzl_UD-rZmdMm2v9Mps39ndwCD7U,64
-vellum/workflows/nodes/displayable/bases/api_node/node.py,sha256=x0RQVoG1yvokaPfGgf719qd0Lt5qxCvKFqyehYiGyqA,2481
+vellum/workflows/nodes/displayable/bases/api_node/node.py,sha256=ywPwCxDesgnE86Wjyf2ZyG2Dr2O7xW8D4tPHZB5Se_s,2477
 vellum/workflows/nodes/displayable/bases/base_prompt_node/__init__.py,sha256=Org3xTvgp1pA0uUXFfnJr29D3HzCey2lEdYF4zbIUgo,70
 vellum/workflows/nodes/displayable/bases/base_prompt_node/node.py,sha256=EvylK1rGKpd4iiooEW9O5A9Q8DMTtBwETe_GtQT8M-E,2139
 vellum/workflows/nodes/displayable/bases/inline_prompt_node/__init__.py,sha256=Hl35IAoepRpE-j4cALaXVJIYTYOF3qszyVbxTj4kS1s,82
 vellum/workflows/nodes/displayable/bases/inline_prompt_node/constants.py,sha256=fnjiRWLoRlC4Puo5oQcpZD5Hd-EesxsAo9l5tGAkpZQ,270
 vellum/workflows/nodes/displayable/bases/inline_prompt_node/node.py,sha256=fypgmZHgaDtGqSBC8rjYiyryJ0H58LPt_CafLfAprO0,6341
 vellum/workflows/nodes/displayable/bases/prompt_deployment_node.py,sha256=zdpNJoawB5PedsCCfgOGDDoWuif0jNtlV-K9sFL6cNQ,4968
-vellum/workflows/nodes/displayable/bases/search_node.py,sha256=pqiui8G6l_9FLE1HH4rCdFC73Bl7_AIBAmQQMjqe190,3570
+vellum/workflows/nodes/displayable/bases/search_node.py,sha256=Gq6CqvTxg4TPm7OBbAA9wnuSwtiKoxFINjMHX-_oNdE,3687
 vellum/workflows/nodes/displayable/code_execution_node/__init__.py,sha256=0FLWMMktpzSnmBMizQglBpcPrP80fzVsoJwJgf822Cg,76
 vellum/workflows/nodes/displayable/code_execution_node/node.py,sha256=JgyTgZRSb-gSXL4ccHn4VkPcPZFOkVK5ohPazPqSWFw,8652
 vellum/workflows/nodes/displayable/code_execution_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -1336,7 +1337,7 @@ vellum/workflows/nodes/displayable/prompt_deployment_node/node.py,sha256=cpOrqQQ
 vellum/workflows/nodes/displayable/search_node/__init__.py,sha256=hpBpvbrDYf43DElRZFLzieSn8weXiwNiiNOJurERQbs,62
 vellum/workflows/nodes/displayable/search_node/node.py,sha256=yhFWulbNmSQoDAwtTSGD4AtKmBbcykezRGRG16xga_0,1311
 vellum/workflows/nodes/displayable/subworkflow_deployment_node/__init__.py,sha256=9yYM6001YZeqI1VOk1QuEM_yrffk_EdsO7qaPzINKds,92
-vellum/workflows/nodes/displayable/subworkflow_deployment_node/node.py,sha256=pnbRCgdzWXrXhm5jDkDDASl5xu5w3DxskC34yJVmWUs,7147
+vellum/workflows/nodes/displayable/subworkflow_deployment_node/node.py,sha256=FgS1ZMnIBliqEMNKX2ChE80bw4IVHEQ6IGiTDvF0RZw,7226
 vellum/workflows/nodes/displayable/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/displayable/tests/test_inline_text_prompt_node.py,sha256=UI_RMmXn9qwB-StnFPvkDd9FctBQAg43wrfouqvPepk,4701
 vellum/workflows/nodes/displayable/tests/test_search_node_wth_text_output.py,sha256=4CMwDtXwTaEvFfDpA6j2iLqc7S6IICSkvVZOobEpeps,6954
@@ -1367,16 +1368,16 @@ vellum/workflows/resolvers/__init__.py,sha256=eH6hTvZO4IciDaf_cf7aM2vs-DkBDyJPyc
 vellum/workflows/resolvers/base.py,sha256=WHra9LRtlTuB1jmuNqkfVE2JUgB61Cyntn8f0b0WZg4,411
 vellum/workflows/runner/__init__.py,sha256=i1iG5sAhtpdsrlvwgH6B-m49JsINkiWyPWs8vyT-bqM,72
 vellum/workflows/runner/runner.py,sha256=RXnLEmSJFbp0u4vKF7rvD2fscuYfcRYkspIJINnvFAI,27607
-vellum/workflows/sandbox.py,sha256=1aL5BoUgJX6dbIN3pqui20Wk3VyzXV16BUaZz-clmFs,2269
+vellum/workflows/sandbox.py,sha256=GVJzVjMuYzOBnSrboB0_6MMRZWBluAyQ2o7syeaeBd0,2235
 vellum/workflows/state/__init__.py,sha256=yUUdR-_Vl7UiixNDYQZ-GEM_kJI9dnOia75TtuNEsnE,60
 vellum/workflows/state/base.py,sha256=jpSzF1OQd3-fqi6dMGlNsQl-7JnJxCdzWIigmX8Wz-I,14425
-vellum/workflows/state/context.py,sha256=oXiEdNsWJi1coRB85IreTgUeR6_CrWWBXndtLff9S7M,1272
+vellum/workflows/state/context.py,sha256=_NeGQpYo8yNuh0Tfh3OvcB_bG_-GC8b3ZLLl83Pf8-I,1279
 vellum/workflows/state/encoder.py,sha256=kRrqwD0vFCiSRZR3rg8Sjkh8sDEerQQhlvmdSYQAOl8,1741
 vellum/workflows/state/store.py,sha256=VYGBQgN1bpd1as5eGiouV_7scg8QsRs4_1aqZAGIsRQ,793
 vellum/workflows/state/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/state/tests/test_state.py,sha256=BQjcdREIK1MPuGhivRUgpynVJLftjEpH9RG3cRKxQEY,3310
 vellum/workflows/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/tests/test_sandbox.py,sha256=OMN15LuFUV58-XnAhtBiLcEjNt-Pj6bZgetDr8miCiw,1808
+vellum/workflows/tests/test_sandbox.py,sha256=JKwaluI-lODQo7Ek9sjDstjL_WTdSqUlVik6ZVTfVOA,1826
 vellum/workflows/types/__init__.py,sha256=KxUTMBGzuRCfiMqzzsykOeVvrrkaZmTTo1a7SLu8gRM,68
 vellum/workflows/types/core.py,sha256=D2NcSBwGgWj_mtXZqe3KnEQcb5qd5HzqAwnxwmlCfCw,899
 vellum/workflows/types/generics.py,sha256=ZkfoRhWs042i5IjA99v2wIhmh1u-Wieo3LzosgGWJVk,600
@@ -1391,15 +1392,15 @@ vellum/workflows/utils/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NM
 vellum/workflows/utils/tests/test_functions.py,sha256=ytdruS55aO2egsb5sAv8_9jf68L1cJoZu2uKV2iamrg,8083
 vellum/workflows/utils/tests/test_names.py,sha256=aOqpyvMsOEK_9mg_-yaNxQDW7QQfwqsYs37PseyLhxw,402
 vellum/workflows/utils/tests/test_uuids.py,sha256=i77ABQ0M3S-aFLzDXHJq_yr5FPkJEWCMBn1HJ3DObrE,437
-vellum/workflows/utils/tests/test_vellum_variables.py,sha256=0ISy1xjY7_rci0Mt_naK0xrmurE1REZLMCgPOCLFKRM,776
+vellum/workflows/utils/tests/test_vellum_variables.py,sha256=6H-BpmbIEmVRO75QQ3Rfy4bEUMMP2qwGzx2Gp1uXbfw,879
 vellum/workflows/utils/uuids.py,sha256=DFzPv9RCvsKhvdTEIQyfSek2A31D6S_QcmeLPbgrgTY,739
-vellum/workflows/utils/vellum_variables.py,sha256=DsjVj_M_vTafpi5OUDs4KNrmbU2n4LR7fcLhuHb67Z4,3123
+vellum/workflows/utils/vellum_variables.py,sha256=g5xHYB8etfHE32ek19nP6Anf8NyjhmUtOwO2KmQ5xZU,3111
 vellum/workflows/vellum_client.py,sha256=ODrq_TSl-drX2aezXegf7pizpWDVJuTXH-j6528t75s,683
 vellum/workflows/workflows/__init__.py,sha256=KY45TqvavCCvXIkyCFMEc0dc6jTMOUci93U2DUrlZYc,66
-vellum/workflows/workflows/base.py,sha256=zpspOEdO5Ye_0ZvN-Wkzv9iQSiF1sD201ba8lhbnPbs,17086
+vellum/workflows/workflows/base.py,sha256=FxK6ZNrQtuqcgZxWXy4_ole1LeeTiZI8VlxavRd3VbA,17119
 vellum/workflows/workflows/event_filters.py,sha256=GSxIgwrX26a1Smfd-6yss2abGCnadGsrSZGa7t7LpJA,2008
-vellum_ai-0.12.8.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
-vellum_ai-0.12.8.dist-info/METADATA,sha256=FI7BG5Gx3Dd3exq5uqBWnHu8kuqFrVpE_9tcdUuYwdk,5160
-vellum_ai-0.12.8.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-vellum_ai-0.12.8.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
-vellum_ai-0.12.8.dist-info/RECORD,,
+vellum_ai-0.12.9.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
+vellum_ai-0.12.9.dist-info/METADATA,sha256=XnLz57ZnuFRq6HV_sXjLRLt2cBE7jKWY0HoCKn7G1Fs,5160
+vellum_ai-0.12.9.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+vellum_ai-0.12.9.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
+vellum_ai-0.12.9.dist-info/RECORD,,

vellum_cli/tests/test_push.py

@@ -8,7 +8,7 @@ from uuid import uuid4
 from click.testing import CliRunner
 
 from vellum.client.types.workflow_push_response import WorkflowPushResponse
-from vellum.evaluations.utils.uuid import is_valid_uuid
+from vellum.utils.uuid import is_valid_uuid
 from vellum_cli import main as cli_main
 
 

vellum_ee/workflows/display/nodes/vellum/inline_subworkflow_node.py

@@ -61,6 +61,11 @@ class BaseInlineSubworkflowNodeDisplay(
         display_context: WorkflowDisplayContext,
     ) -> Tuple[List[NodeInput], List[VellumVariable]]:
         subworkflow_inputs = raise_if_descriptor(node.subworkflow_inputs)
+        subworkflow_entries = (
+            [(variable_name, variable_value) for variable_name, variable_value in subworkflow_inputs.items()]
+            if isinstance(subworkflow_inputs, dict)
+            else [(variable_ref.name, variable_value) for variable_ref, variable_value in subworkflow_inputs]
+        )
         node_inputs = [
             create_node_input(
                 node_id=node_id,
@@ -69,7 +74,7 @@ class BaseInlineSubworkflowNodeDisplay(
                 display_context=display_context,
                 input_id=self.workflow_input_ids_by_name.get(variable_name),
             )
-            for variable_name, variable_value in subworkflow_inputs.items()
+            for variable_name, variable_value in subworkflow_entries
         ]
         node_inputs_by_key = {node_input.key: node_input for node_input in node_inputs}
         workflow_inputs = [

vellum_ee/workflows/display/tests/workflow_serialization/test_basic_templating_node_serialization.py

@@ -0,0 +1,207 @@
+from deepdiff import DeepDiff
+
+from vellum_ee.workflows.display.workflows import VellumWorkflowDisplay
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+from tests.workflows.basic_templating_node.workflow_with_json_input import BasicTemplatingNodeWorkflowWithJson
+
+
+def test_serialize_workflow():
+    # GIVEN a Workflow that uses a vellum templating node",
+
+    # WHEN we serialize it
+    workflow_display = get_workflow_display(
+        base_display_class=VellumWorkflowDisplay, workflow_class=BasicTemplatingNodeWorkflowWithJson
+    )
+
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN we should get a serialized representation of the Workflow
+    assert serialized_workflow.keys() == {
+        "workflow_raw_data",
+        "input_variables",
+        "output_variables",
+    }
+
+    # AND its input variables should be what we expect
+    input_variables = serialized_workflow["input_variables"]
+    assert len(input_variables) == 1
+    assert input_variables == [
+        {
+            "id": "f4435f88-703f-40e5-9197-d39b0e43ab72",
+            "key": "info",
+            "type": "JSON",
+            "default": None,
+            "required": True,
+            "extensions": {"color": None},
+        }
+    ]
+
+    # AND its output variables should be what we expect
+    output_variables = serialized_workflow["output_variables"]
+    assert len(output_variables) == 1
+    assert not DeepDiff(
+        [{"id": "62ec9b08-6437-4f8d-bc20-983d317bc348", "key": "result", "type": "JSON"}],
+        output_variables,
+        ignore_order=True,
+    )
+
+    # AND its raw data should be what we expect
+    workflow_raw_data = serialized_workflow["workflow_raw_data"]
+    assert workflow_raw_data.keys() == {"edges", "nodes", "display_data", "definition"}
+    assert len(workflow_raw_data["edges"]) == 2
+    assert len(workflow_raw_data["nodes"]) == 3
+
+    # AND each node should be serialized correctly
+    entrypoint_node = workflow_raw_data["nodes"][0]
+    assert entrypoint_node == {
+        "id": "09579c0a-acbf-4e04-8724-2230a8aa6534",
+        "type": "ENTRYPOINT",
+        "inputs": [],
+        "data": {"label": "Entrypoint Node", "source_handle_id": "34069190-0942-4e0c-8700-b33b9dea4ea0"},
+        "display_data": {"position": {"x": 0.0, "y": 0.0}},
+        "definition": {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"], "bases": []},
+    }
+
+    templating_node = workflow_raw_data["nodes"][1]
+    assert not DeepDiff(
+        {
+            "id": "51cbe21d-0232-4362-bc54-5bc283297aa6",
+            "type": "TEMPLATING",
+            "inputs": [
+                {
+                    "id": "7c775379-d589-4d79-b876-dcd224d72966",
+                    "key": "template",
+                    "value": {
+                        "rules": [
+                            {
+                                "type": "CONSTANT_VALUE",
+                                "data": {"type": "STRING", "value": "The meaning of {{ info }} is not known"},
+                            }
+                        ],
+                        "combinator": "OR",
+                    },
+                },
+                {
+                    "id": "bb712499-4265-4d71-bc14-0c3d8ca6a7de",
+                    "key": "info",
+                    "value": {
+                        "rules": [
+                            {
+                                "type": "INPUT_VARIABLE",
+                                "data": {"input_variable_id": "f4435f88-703f-40e5-9197-d39b0e43ab72"},
+                            }
+                        ],
+                        "combinator": "OR",
+                    },
+                },
+            ],
+            "data": {
+                "label": "Example Templating Node",
+                "output_id": "6834cae4-8173-4fa6-88f7-bc09d335bdd1",
+                "error_output_id": None,
+                "source_handle_id": "39317827-df43-4f5a-bfbc-20bffc839748",
+                "target_handle_id": "58427684-3848-498a-8299-c6b0fc70265d",
+                "template_node_input_id": "7c775379-d589-4d79-b876-dcd224d72966",
+                "output_type": "JSON",
+            },
+            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+            "definition": {
+                "name": "ExampleTemplatingNode",
+                "module": ["tests", "workflows", "basic_templating_node", "workflow_with_json_input"],
+                "bases": [
+                    {
+                        "name": "TemplatingNode",
+                        "module": ["vellum", "workflows", "nodes", "core", "templating_node", "node"],
+                    }
+                ],
+            },
+        },
+        templating_node,
+    )
+
+    final_output_node = workflow_raw_data["nodes"][-1]
+    assert not DeepDiff(
+        {
+            "id": "9f75228b-1d5b-4c30-a581-6087e6a1b738",
+            "type": "TERMINAL",
+            "data": {
+                "label": "Final Output",
+                "name": "result",
+                "target_handle_id": "16ba108e-61a8-4338-8a5b-4f1278d7fd7b",
+                "output_id": "62ec9b08-6437-4f8d-bc20-983d317bc348",
+                "output_type": "JSON",
+                "node_input_id": "310072db-6d07-4d29-8e5c-9c6909300925",
+            },
+            "inputs": [
+                {
+                    "id": "310072db-6d07-4d29-8e5c-9c6909300925",
+                    "key": "node_input",
+                    "value": {
+                        "rules": [
+                            {
+                                "type": "NODE_OUTPUT",
+                                "data": {
+                                    "node_id": "51cbe21d-0232-4362-bc54-5bc283297aa6",
+                                    "output_id": "6834cae4-8173-4fa6-88f7-bc09d335bdd1",
+                                },
+                            }
+                        ],
+                        "combinator": "OR",
+                    },
+                }
+            ],
+            "display_data": {"position": {"x": 0.0, "y": 0.0}},
+            "definition": {
+                "name": "FinalOutputNode",
+                "module": ["vellum", "workflows", "nodes", "displayable", "final_output_node", "node"],
+                "bases": [
+                    {"name": "BaseNode", "module": ["vellum", "workflows", "nodes", "bases", "base"], "bases": []}
+                ],
+            },
+        },
+        final_output_node,
+        ignore_order=True,
+    )
+
+    # AND each edge should be serialized correctly
+    serialized_edges = workflow_raw_data["edges"]
+    assert not DeepDiff(
+        [
+            {
+                "id": "9f753b40-68de-4186-838e-806a14853935",
+                "source_node_id": "09579c0a-acbf-4e04-8724-2230a8aa6534",
+                "source_handle_id": "34069190-0942-4e0c-8700-b33b9dea4ea0",
+                "target_node_id": "51cbe21d-0232-4362-bc54-5bc283297aa6",
+                "target_handle_id": "58427684-3848-498a-8299-c6b0fc70265d",
+                "type": "DEFAULT",
+            },
+            {
+                "id": "00cbff5c-5cce-4ef4-81b2-1a11d9b42597",
+                "source_node_id": "51cbe21d-0232-4362-bc54-5bc283297aa6",
+                "source_handle_id": "39317827-df43-4f5a-bfbc-20bffc839748",
+                "target_node_id": "9f75228b-1d5b-4c30-a581-6087e6a1b738",
+                "target_handle_id": "16ba108e-61a8-4338-8a5b-4f1278d7fd7b",
+                "type": "DEFAULT",
+            },
+        ],
+        serialized_edges,
+        ignore_order=True,
+    )
+
+    # AND the display data should be what we expect
+    display_data = workflow_raw_data["display_data"]
+    assert display_data == {
+        "viewport": {
+            "x": 0.0,
+            "y": 0.0,
+            "zoom": 1.0,
+        }
+    }
+
+    # AND the definition should be what we expect
+    definition = workflow_raw_data["definition"]
+    assert definition == {
+        "name": "BasicTemplatingNodeWorkflowWithJson",
+        "module": ["tests", "workflows", "basic_templating_node", "workflow_with_json_input"],
+    }

vellum/workflows/nodes/bases/base_subworkflow_node/__init__.py

@@ -1,5 +0,0 @@
-from .node import BaseSubworkflowNode
-
-__all__ = [
-    "BaseSubworkflowNode",
-]

vellum/workflows/nodes/bases/base_subworkflow_node/node.py

@@ -1,10 +0,0 @@
-from typing import ClassVar, Generic
-
-from vellum.workflows.nodes.bases import BaseNode
-from vellum.workflows.types.core import EntityInputsInterface
-from vellum.workflows.types.generics import StateType
-
-
-class BaseSubworkflowNode(BaseNode[StateType], Generic[StateType]):
-    # Inputs that are passed to the Subworkflow
-    subworkflow_inputs: ClassVar[EntityInputsInterface] = {}