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

vellum/utils/templating/constants.py

@@ -10,7 +10,7 @@ import pydash
 import pytz
 import yaml
 
-from vellum.utils.templating.custom_filters import is_valid_json_string
+from vellum.utils.templating.custom_filters import is_valid_json_string, replace
 
 DEFAULT_JINJA_GLOBALS: Dict[str, Any] = {
     "datetime": datetime,
@@ -23,6 +23,10 @@ DEFAULT_JINJA_GLOBALS: Dict[str, Any] = {
     "re": re,
     "yaml": yaml,
 }
-DEFAULT_JINJA_CUSTOM_FILTERS: Dict[str, Callable[[Union[str, bytes]], bool]] = {
+
+FilterFunc = Union[Callable[[Union[str, bytes]], bool], Callable[[Any, Any, Any], str]]
+
+DEFAULT_JINJA_CUSTOM_FILTERS: Dict[str, FilterFunc] = {
     "is_valid_json_string": is_valid_json_string,
+    "replace": replace,
 }

vellum/utils/templating/custom_filters.py

@@ -1,5 +1,7 @@
 import json
-from typing import Union
+from typing import Any, Union
+
+from vellum.workflows.state.encoder import DefaultStateEncoder
 
 
 def is_valid_json_string(value: Union[str, bytes]) -> bool:
@@ -10,3 +12,22 @@ def is_valid_json_string(value: Union[str, bytes]) -> bool:
     except ValueError:
         return False
     return True
+
+
+def replace(s: Any, old: Any, new: Any) -> str:
+    def encode_to_str(obj: Any) -> str:
+        """Encode an object for template rendering using DefaultStateEncoder."""
+        try:
+            if isinstance(obj, str):
+                return obj
+            return json.dumps(obj, cls=DefaultStateEncoder)
+        except TypeError:
+            return str(obj)
+
+    if old == "":
+        return encode_to_str(s)
+
+    s_str = encode_to_str(s)
+    old_str = encode_to_str(old)
+    new_str = encode_to_str(new)
+    return s_str.replace(old_str, new_str)

vellum/utils/templating/render.py

@@ -1,8 +1,9 @@
 import json
-from typing import Any, Callable, Dict, Optional, Union
+from typing import Any, Dict, Optional
 
 from jinja2.sandbox import SandboxedEnvironment
 
+from vellum.utils.templating.constants import FilterFunc
 from vellum.utils.templating.exceptions import JinjaTemplateError
 from vellum.workflows.state.encoder import DefaultStateEncoder
 
@@ -18,7 +19,7 @@ def render_sandboxed_jinja_template(
     *,
     template: str,
     input_values: Dict[str, Any],
-    jinja_custom_filters: Optional[Dict[str, Callable[[Union[str, bytes]], bool]]] = None,
+    jinja_custom_filters: Optional[Dict[str, FilterFunc]] = None,
     jinja_globals: Optional[Dict[str, Any]] = None,
 ) -> str:
     """Render a Jinja template within a sandboxed environment."""

vellum/utils/templating/tests/test_custom_filters.py

@@ -0,0 +1,19 @@
+import pytest
+
+from vellum.utils.templating.custom_filters import replace
+
+
+@pytest.mark.parametrize(
+    ["input_str", "old", "new", "expected"],
+    [
+        ("foo", "foo", "bar", "bar"),
+        ({"message": "hello"}, "hello", "world", '{"message": "world"}'),
+        ("Value: 123", 123, 456, "Value: 456"),
+        (123, 2, 4, "143"),
+        ("", "", "", ""),
+        ("foo", "", "bar", "foo"),
+    ],
+)
+def test_replace(input_str, old, new, expected):
+    actual = replace(input_str, old, new)
+    assert actual == expected

vellum/workflows/errors/types.py

@@ -13,6 +13,7 @@ class WorkflowErrorCode(Enum):
     INVALID_INPUTS = "INVALID_INPUTS"
     INVALID_OUTPUTS = "INVALID_OUTPUTS"
     INVALID_STATE = "INVALID_STATE"
+    INVALID_CODE = "INVALID_CODE"
     INVALID_TEMPLATE = "INVALID_TEMPLATE"
     INTERNAL_ERROR = "INTERNAL_ERROR"
     NODE_EXECUTION = "NODE_EXECUTION"
@@ -54,6 +55,7 @@ _WORKFLOW_EVENT_ERROR_CODE_TO_WORKFLOW_ERROR_CODE: Dict[WorkflowExecutionEventEr
     "INTERNAL_SERVER_ERROR": WorkflowErrorCode.INTERNAL_ERROR,
     "NODE_EXECUTION": WorkflowErrorCode.NODE_EXECUTION,
     "LLM_PROVIDER": WorkflowErrorCode.PROVIDER_ERROR,
+    "INVALID_CODE": WorkflowErrorCode.INVALID_CODE,
     "INVALID_TEMPLATE": WorkflowErrorCode.INVALID_TEMPLATE,
     "USER_DEFINED_ERROR": WorkflowErrorCode.USER_DEFINED_ERROR,
 }
@@ -71,6 +73,7 @@ _WORKFLOW_ERROR_CODE_TO_VELLUM_ERROR_CODE: Dict[WorkflowErrorCode, VellumErrorCo
     WorkflowErrorCode.INVALID_INPUTS: "INVALID_INPUTS",
     WorkflowErrorCode.INVALID_OUTPUTS: "INVALID_REQUEST",
     WorkflowErrorCode.INVALID_STATE: "INVALID_REQUEST",
+    WorkflowErrorCode.INVALID_CODE: "INVALID_CODE",
     WorkflowErrorCode.INVALID_TEMPLATE: "INVALID_INPUTS",
     WorkflowErrorCode.INTERNAL_ERROR: "INTERNAL_SERVER_ERROR",
     WorkflowErrorCode.NODE_EXECUTION: "USER_DEFINED_ERROR",

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

@@ -1,6 +1,6 @@
-from typing import Any, Callable, ClassVar, Dict, Generic, Mapping, Tuple, Type, TypeVar, Union, get_args
+from typing import Any, ClassVar, Dict, Generic, Mapping, Tuple, Type, TypeVar, get_args
 
-from vellum.utils.templating.constants import DEFAULT_JINJA_CUSTOM_FILTERS, DEFAULT_JINJA_GLOBALS
+from vellum.utils.templating.constants import DEFAULT_JINJA_CUSTOM_FILTERS, DEFAULT_JINJA_GLOBALS, FilterFunc
 from vellum.utils.templating.exceptions import JinjaTemplateError
 from vellum.utils.templating.render import render_sandboxed_jinja_template
 from vellum.workflows.errors import WorkflowErrorCode
@@ -54,7 +54,7 @@ class TemplatingNode(BaseNode[StateType], Generic[StateType, _OutputType], metac
     inputs: ClassVar[EntityInputsInterface]
 
     jinja_globals: Dict[str, Any] = DEFAULT_JINJA_GLOBALS
-    jinja_custom_filters: Mapping[str, Callable[[Union[str, bytes]], bool]] = DEFAULT_JINJA_CUSTOM_FILTERS
+    jinja_custom_filters: Mapping[str, FilterFunc] = DEFAULT_JINJA_CUSTOM_FILTERS
 
     class Outputs(BaseNode.Outputs):
         """

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

@@ -4,6 +4,7 @@ from typing import List, Union
 
 from vellum.client.types.chat_message import ChatMessage
 from vellum.client.types.function_call import FunctionCall
+from vellum.client.types.function_call_vellum_value import FunctionCallVellumValue
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.nodes.core.templating_node.node import TemplatingNode
@@ -193,3 +194,29 @@ def test_templating_node__union_float_int_output():
 
     # THEN it should correctly parse as a float
     assert outputs.result == 42.5
+
+
+def test_templating_node__replace_filter():
+    # GIVEN a templating node that outputs a complex object
+    class ReplaceFilterTemplateNode(TemplatingNode[BaseState, Json]):
+        template = """{{- prompt_outputs | selectattr(\'type\', \'equalto\', \'FUNCTION_CALL\') \
+        | list | replace(\"\\n\",\",\") -}}"""
+        inputs = {
+            "prompt_outputs": [FunctionCallVellumValue(value=FunctionCall(name="test", arguments={"key": "value"}))]
+        }
+
+    # WHEN the node is run
+    node = ReplaceFilterTemplateNode()
+    outputs = node.run()
+
+    # THEN the output is the expected JSON
+    assert outputs.result == [
+        {
+            "type": "FUNCTION_CALL",
+            "value": {
+                "name": "test",
+                "arguments": {"key": "value"},
+                "id": None,
+            },
+        }
+    ]

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

@@ -93,13 +93,14 @@ class CodeExecutionNode(BaseNode[StateType], Generic[StateType, _OutputType], me
         log: str
 
     def run(self) -> Outputs:
-        input_values = self._compile_code_inputs()
         output_type = self.__class__.get_output_type()
         code = self._resolve_code()
         if not self.packages and self.runtime == "PYTHON_3_11_6":
-            logs, result = run_code_inline(code, input_values, output_type)
+            logs, result = run_code_inline(code, self.code_inputs, output_type)
             return self.Outputs(result=result, log=logs)
+
         else:
+            input_values = self._compile_code_inputs()
             expected_output_type = primitive_type_to_vellum_variable_type(output_type)
 
             code_execution_result = self._context.vellum_client.execute_code(
@@ -131,7 +132,7 @@ class CodeExecutionNode(BaseNode[StateType], Generic[StateType, _OutputType], me
                 compiled_inputs.append(
                     StringInput(
                         name=input_name,
-                        value=str(input_value),
+                        value=input_value,
                     )
                 )
             elif isinstance(input_value, VellumSecret):
@@ -193,7 +194,7 @@ class CodeExecutionNode(BaseNode[StateType], Generic[StateType, _OutputType], me
                 )
             else:
                 raise NodeException(
-                    message=f"Unrecognized input type for input '{input_name}'",
+                    message=f"Unrecognized input type for input '{input_name}': {input_value.__class__.__name__}",
                     code=WorkflowErrorCode.INVALID_INPUTS,
                 )
 

vellum/workflows/nodes/displayable/code_execution_node/tests/test_code_execution_node.py

@@ -7,6 +7,7 @@ from vellum.client.types.code_execution_package import CodeExecutionPackage
 from vellum.client.types.code_executor_secret_input import CodeExecutorSecretInput
 from vellum.client.types.function_call import FunctionCall
 from vellum.client.types.number_input import NumberInput
+from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.displayable.code_execution_node import CodeExecutionNode
@@ -559,3 +560,53 @@ def main(arg1: List[Dict]) -> float:
 
     # AND we should not have invoked the Code via Vellum since it's running inline
     vellum_client.execute_code.assert_not_called()
+
+
+def test_run_node__code_execution_error():
+    # GIVEN a node that will raise an error during execution
+    class State(BaseState):
+        pass
+
+    class ExampleCodeExecutionNode(CodeExecutionNode[State, int]):
+        code = """\
+def main(arg1: int, arg2: int) -> int:
+    return arg1 + arg2 + arg3
+"""
+        runtime = "PYTHON_3_11_6"
+        code_inputs = {
+            "arg1": 1,
+            "arg2": 2,
+        }
+
+    # WHEN we run the node
+    node = ExampleCodeExecutionNode(state=State())
+
+    # THEN it should raise a NodeException with the execution error
+    with pytest.raises(NodeException) as exc_info:
+        node.run()
+
+    # AND the error should contain the execution error details
+    assert "name 'arg3' is not defined" in str(exc_info.value)
+    assert exc_info.value.code == WorkflowErrorCode.INVALID_CODE
+
+
+def test_run_node__array_of_bools_input():
+    # GIVEN a node that will raise an error during execution
+    class ExampleCodeExecutionNode(CodeExecutionNode[BaseState, int]):
+        code = """\
+def main(arg1: list[bool]) -> int:
+    return len(arg1)
+"""
+        runtime = "PYTHON_3_11_6"
+        code_inputs = {
+            "arg1": [True, False, True],
+        }
+
+    # WHEN we run the node
+    node = ExampleCodeExecutionNode()
+
+    # THEN it should raise a NodeException with the execution error
+    outputs = node.run()
+
+    # AND the error should contain the execution error details
+    assert outputs == {"result": 3, "log": ""}

vellum/workflows/nodes/displayable/code_execution_node/utils.py

@@ -1,14 +1,13 @@
 import io
 import os
 import re
-from typing import Any, List, Tuple, Union, get_args, get_origin
+from typing import Any, Tuple, Union, get_args, get_origin
 
 from pydantic import BaseModel, ValidationError
 
-from vellum import VellumValue
-from vellum.client.types.code_executor_input import CodeExecutorInput
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
+from vellum.workflows.types.core import EntityInputsInterface
 
 
 def read_file_from_path(node_filepath: str, script_filepath: str) -> Union[str, None]:
@@ -70,13 +69,11 @@ def _clean_for_dict_wrapper(obj):
 
 def run_code_inline(
     code: str,
-    input_values: List[CodeExecutorInput],
+    inputs: EntityInputsInterface,
     output_type: Any,
 ) -> Tuple[str, Any]:
     log_buffer = io.StringIO()
 
-    VELLUM_TYPES = get_args(VellumValue)
-
     def wrap_value(value):
         if isinstance(value, list):
             return ListWrapper(
@@ -84,7 +81,7 @@ def run_code_inline(
                     # Convert VellumValue to dict with its fields
                     (
                         item.model_dump()
-                        if isinstance(item, VELLUM_TYPES)
+                        if isinstance(item, BaseModel)
                         else _clean_for_dict_wrapper(item) if isinstance(item, (dict, list)) else item
                     )
                     for item in value
@@ -93,18 +90,23 @@ def run_code_inline(
         return _clean_for_dict_wrapper(value)
 
     exec_globals = {
-        "__arg__inputs": {input_value.name: wrap_value(input_value.value) for input_value in input_values},
+        "__arg__inputs": {name: wrap_value(value) for name, value in inputs.items()},
         "__arg__out": None,
         "print": lambda *args, **kwargs: log_buffer.write(f"{' '.join(args)}\n"),
     }
-    run_args = [f"{input_value.name}=__arg__inputs['{input_value.name}']" for input_value in input_values]
+    run_args = [f"{name}=__arg__inputs['{name}']" for name in inputs.keys()]
     execution_code = f"""\
 {code}
 
 __arg__out = main({", ".join(run_args)})
 """
-
-    exec(execution_code, exec_globals)
+    try:
+        exec(execution_code, exec_globals)
+    except Exception as e:
+        raise NodeException(
+            code=WorkflowErrorCode.INVALID_CODE,
+            message=str(e),
+        )
 
     logs = log_buffer.getvalue()
     result = exec_globals["__arg__out"]

{vellum_ai-0.14.1.dist-info → vellum_ai-0.14.2.dist-info}/METADATA

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

{vellum_ai-0.14.1.dist-info → vellum_ai-0.14.2.dist-info}/RECORD

@@ -6,7 +6,7 @@ vellum_cli/config.py,sha256=Bsb3mnvKvv3oOTcCuxpgC7lWPMqt6eJhgRA6VEE-vL4,9266
 vellum_cli/image_push.py,sha256=SJwhwWJsLjwGNezNVd_oCVpFMfPsAB3dfLWmriZZUtw,4419
 vellum_cli/logger.py,sha256=PuRFa0WCh4sAGFS5aqWB0QIYpS6nBWwPJrIXpWxugV4,1022
 vellum_cli/ping.py,sha256=lWyJw6sziXjyTopTYRdFF5hV-sYPVDdX0yVbG5fzcY4,585
-vellum_cli/pull.py,sha256=7yvg4oBOgsbBEsgXtCpYlNR4AOR8hPICamY-4HI-3kM,9031
+vellum_cli/pull.py,sha256=SA2EOHXbLO_jGKhzUHNrLyxEwaPbeLiU3TeRY5oeX_Y,8877
 vellum_cli/push.py,sha256=xjTNbLwOVFNU3kpBrm56Bk5QkSRrJ9z86qceghCzfIA,9655
 vellum_cli/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_cli/tests/conftest.py,sha256=AFYZryKA2qnUuCPBxBKmHLFoPiE0WhBFFej9tNwSHdc,1526
@@ -84,12 +84,12 @@ vellum_ee/workflows/display/types.py,sha256=bm355ZcZ-7WaesBvIB8RbWDD7qiFmazfcNb6
 vellum_ee/workflows/display/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/display/utils/expressions.py,sha256=9FpOslDI-RCR5m4TgAu9KCHh4aTVnh7CHR2ykyMUDw0,1151
 vellum_ee/workflows/display/utils/vellum.py,sha256=UjK_RxnSEmlIu9klGCPWU5RAQBmgZ7cRbRdgxaTbubE,8081
-vellum_ee/workflows/display/vellum.py,sha256=PVte2gcp1_4g-8ZaM0XVAaDwf3O-kSHy7-5Q-Co-YG0,8463
+vellum_ee/workflows/display/vellum.py,sha256=iiBzMIHTnRb-Xb4Q9-26vOxPpK_rDPKBlky3dBew8Gg,8480
 vellum_ee/workflows/display/workflows/__init__.py,sha256=kapXsC67VJcgSuiBMa86FdePG5A9kMB5Pi4Uy1O2ob4,207
 vellum_ee/workflows/display/workflows/base_workflow_display.py,sha256=Amow11LhE-GL3j8bNZ8rK1iYKjkNOhH1ECMQ-dvyLAU,17204
 vellum_ee/workflows/display/workflows/get_vellum_workflow_display_class.py,sha256=kp0u8LN_2IwshLrhMImhpZx1hRyAcD5gXY-kDuuaGMQ,1269
 vellum_ee/workflows/display/workflows/tests/test_workflow_display.py,sha256=yl1ytpl9_lijOGeDPWSypWYRJ7aOEVA7NgUg81jTuCs,2229
-vellum_ee/workflows/display/workflows/vellum_workflow_display.py,sha256=12miGvHL9_ZzXaU5r1u1TVTGSBrs8LHBVJU-DKfS0JE,18802
+vellum_ee/workflows/display/workflows/vellum_workflow_display.py,sha256=8roVFJ4SWrMRNpptwwneVcE6kJmoVtJPN-fmkfDNb7Q,19102
 vellum_ee/workflows/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/server/virtual_file_loader.py,sha256=X_DdNK7MfyOjKWekk6YQpOSCT6klKcdjT6nVJcBH1sM,1481
 vellum_ee/workflows/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -104,7 +104,7 @@ vellum_ee/workflows/tests/local_workflow/display/__init__.py,sha256=xo75Uqb4aErO
 vellum_ee/workflows/tests/local_workflow/display/nodes/__init__.py,sha256=szW_mgOUriyZ6v1vlnevBgkzNi8g83-ihS98UOLHVcE,155
 vellum_ee/workflows/tests/local_workflow/display/nodes/final_output.py,sha256=Kv92TCREiZsB9531KZYaBIq83uHn7e_ECw_yAbD1qfk,1017
 vellum_ee/workflows/tests/local_workflow/display/nodes/templating_node.py,sha256=5cankEe1rDZlXKgILFSPbmN0tUZhIdmcFgz_AguXTJc,1229
-vellum_ee/workflows/tests/local_workflow/display/workflow.py,sha256=I0uc9hmeQGMxUJMiOu1btBpUb2aSvIXUSNS05WiPeNA,2336
+vellum_ee/workflows/tests/local_workflow/display/workflow.py,sha256=XJCmx64TCsD2Zt55Q5SISdXSr1NO7n5xenkOtCk0WXI,2151
 vellum_ee/workflows/tests/local_workflow/inputs.py,sha256=4cgsZBoUbIY0Rs8gknC9yqxQ-sSoULclx_SAm1FT2RA,96
 vellum_ee/workflows/tests/local_workflow/metadata.json,sha256=rdu3h5qkFZiqhCAMxoyoWyMI0O8QALC5-URvSIW6F00,24
 vellum_ee/workflows/tests/local_workflow/nodes/__init__.py,sha256=1F6jxUpSKfPXPj4ZZKSbnX6Mg-VwF3euLJSZfGn6xkM,127
@@ -119,7 +119,7 @@ vellum/client/README.md,sha256=JkCJjmMZl4jrPj46pkmL9dpK4gSzQQmP5I7z4aME4LY,4749
 vellum/client/__init__.py,sha256=j6zi0NZ4BMC6JrwckvzMWuG5x8KoOvO4KqsLhvVCa68,117624
 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=AN4UTP8OvOr6qMSP_VqGlHKGOVsUnQj3CLqFDhB3p5E,1868
+vellum/client/core/client_wrapper.py,sha256=r8ZNshVLkA2wiH4k5knCrjqc-qjeEZ06Cpf5iE7nQ-g,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
@@ -1259,10 +1259,12 @@ vellum/types/workspace_read.py,sha256=9CvgvK8Li8vL6qC5KX7f3-nEHslJ4lw2w07bvXcrjA
 vellum/types/workspace_secret_read.py,sha256=Z6QNXHxVHRdrLXSI31KxngePRwJTVoJYMXVbtPQwrxs,159
 vellum/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/utils/templating/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/utils/templating/constants.py,sha256=XTNmDsKa7byjw4GMZmzx2dUeYUTeMLZrPgRHcc80Kvc,613
-vellum/utils/templating/custom_filters.py,sha256=Q0DahYRHP4KfaUXDt9XxN-DFLBrAxlv90yaVqxScoUw,264
+vellum/utils/templating/constants.py,sha256=8OHMO6WFAEimbIaiHc5gy6s91D7_KvW-vTlEMWwvl_M,711
+vellum/utils/templating/custom_filters.py,sha256=XVHriwazejRZmxB_eg4xHgCxl7AiQQ2sx-hRLMmylfU,885
 vellum/utils/templating/exceptions.py,sha256=cDp140PP4OnInW4qAvg3KqiSiF70C71UyEAKRBR1Abo,46
-vellum/utils/templating/render.py,sha256=2n6M10p2WtM2_6I10PKOIyH_gTmAo5EkxDYL2DR7F4U,2014
+vellum/utils/templating/render.py,sha256=ooQxCiBMAizPVfwJsIPS2feSBUuoalR1UeJMO0Df-3s,2029
+vellum/utils/templating/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vellum/utils/templating/tests/test_custom_filters.py,sha256=mkJwc7t1gE13SKgPxhF-lN_m2XGCkphCB9Te81dGekI,532
 vellum/utils/typing.py,sha256=wx_daFqD69cYkuJTVnvNrpjhqC3uuhbnyJ9_bIwC9OU,327
 vellum/utils/uuid.py,sha256=Ch6wWRgwICxLxJCTl5iE3EdRlZj2zADR-zUMUtjcMWM,214
 vellum/version.py,sha256=jq-1PlAYxN9AXuaZqbYk9ak27SgE2lw9Ia5gx1b1gVI,76
@@ -1282,7 +1284,7 @@ vellum/workflows/emitters/base.py,sha256=D5SADKIvnbgKwIBgYm77jaqvpo1o0rz4MmuX_mu
 vellum/workflows/environment/__init__.py,sha256=wGHslgSEZ7Octe4C-hNtl84EFelNimgmWQoi7px4-uw,71
 vellum/workflows/environment/environment.py,sha256=0XhJPBs8YASWmvPx8bkSdCvcbDmzpe9stfs2kgtNDRU,296
 vellum/workflows/errors/__init__.py,sha256=tWGPu5xyAU8gRb8_bl0fL7OfU3wxQ9UH6qVwy4X4P_Q,113
-vellum/workflows/errors/types.py,sha256=85tmSBt4d9OjUA4AdM5MvIy1vwVLpEu2MhkJhFF1q9k,3502
+vellum/workflows/errors/types.py,sha256=tVW7Il9zalnwWzdoDLqYPIvRTOhXIv6FPORZAbU7n5Q,3640
 vellum/workflows/events/__init__.py,sha256=6pxxceJo2dcaRkWtkDAYlUQZ-PHBQSZytIoyuUK48Qw,759
 vellum/workflows/events/node.py,sha256=uHT6If0esgZ3nLjrjmUPTKf3qbjGhoV_x5YKpjDBDcU,5280
 vellum/workflows/events/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -1348,8 +1350,8 @@ vellum/workflows/nodes/core/retry_node/node.py,sha256=loIZJUcCsN0y3mr4pw7f23l4eD
 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=RM_OHwxrHwyxvlQQBJPqVBxpedFuWQ9h2-Xa3kP75sc,4399
 vellum/workflows/nodes/core/templating_node/__init__.py,sha256=GmyuYo81_A1_Bz6id69ozVFS6FKiuDsZTiA3I6MaL2U,70
-vellum/workflows/nodes/core/templating_node/node.py,sha256=zCYhq88qLTvoC9LetVrD9sLXkwHZsaWekxMhru_nV70,3752
-vellum/workflows/nodes/core/templating_node/tests/test_templating_node.py,sha256=j6v3TTD4Fjq-sWcuOZOzX-okFUC18q2VKiPT9ot1bk8,5830
+vellum/workflows/nodes/core/templating_node/node.py,sha256=Vqlg4L-5XNuIdbZKQe-GEYqTIV7iXNjLO7QIRgz4ujc,3722
+vellum/workflows/nodes/core/templating_node/tests/test_templating_node.py,sha256=-53Vh0YOnk8sAcmZ7drdKgBcSCj68DYts5-jFNNsPRE,6755
 vellum/workflows/nodes/core/try_node/__init__.py,sha256=JVD4DrldTIqFQQFrubs9KtWCCc0YCAc7Fzol5ZWIWeM,56
 vellum/workflows/nodes/core/try_node/node.py,sha256=bk2uhYUl10yaPJlOBWxiL7igTUrL_7mM9S2nvsdWB68,4242
 vellum/workflows/nodes/core/try_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -1374,12 +1376,12 @@ vellum/workflows/nodes/displayable/bases/tests/test_utils.py,sha256=eqdqbKNRWVMD
 vellum/workflows/nodes/displayable/bases/types.py,sha256=C37B2Qh2YP7s7pUjd-EYKc2Zl1TbnCgI_mENuUSb8bo,1706
 vellum/workflows/nodes/displayable/bases/utils.py,sha256=ckMUenSsNkiYmSw6FmjSMHYaCk8Y8_sUjL6lkFFEqts,5412
 vellum/workflows/nodes/displayable/code_execution_node/__init__.py,sha256=0FLWMMktpzSnmBMizQglBpcPrP80fzVsoJwJgf822Cg,76
-vellum/workflows/nodes/displayable/code_execution_node/node.py,sha256=wgtqPljUqan9SILMysPCdSmZ0HoCpTTTNNaW0y9nQQI,9082
+vellum/workflows/nodes/displayable/code_execution_node/node.py,sha256=_yrQn_uLwy8zVW1RjFMoeomDEsbpbbKK7ifMGEBfNlk,9120
 vellum/workflows/nodes/displayable/code_execution_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/displayable/code_execution_node/tests/fixtures/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/displayable/code_execution_node/tests/fixtures/main.py,sha256=5QsbmkzSlSbcbWTG_JmIqcP-JNJzOPTKxGzdHos19W4,79
-vellum/workflows/nodes/displayable/code_execution_node/tests/test_code_execution_node.py,sha256=1i48vpyFZ-zR5DD9wCu4Ekd-aq4gLOsSWnn0BMdJIAs,16810
-vellum/workflows/nodes/displayable/code_execution_node/utils.py,sha256=m5y6_sRX5P9icmneNhT_DkXYDNz7l_8Q_Aa8-U5dWsQ,4529
+vellum/workflows/nodes/displayable/code_execution_node/tests/test_code_execution_node.py,sha256=5WHsW_uEKDn1ukM9_O2FsGCYELfONz-2h_kYnNRNYHE,18333
+vellum/workflows/nodes/displayable/code_execution_node/utils.py,sha256=rdWD1wtxPKHbdHRHEdTeRMSJi9sgAm2t0FqeAWuQHlQ,4534
 vellum/workflows/nodes/displayable/conditional_node/__init__.py,sha256=AS_EIqFdU1F9t8aLmbZU-rLh9ry6LCJ0uj0D8F0L5Uw,72
 vellum/workflows/nodes/displayable/conditional_node/node.py,sha256=Qjfl33gZ3JEgxBA1EgzSUebboGvsARthIxxcQyvx5Gg,1152
 vellum/workflows/nodes/displayable/final_output_node/__init__.py,sha256=G7VXM4OWpubvSJtVkGmMNeqgb9GkM7qZT838eL18XU4,72
@@ -1471,8 +1473,8 @@ vellum/workflows/workflows/base.py,sha256=tBivLLLPtMyMi2Bd5WjbwQ2_zZFpG8rNfEidfQ
 vellum/workflows/workflows/event_filters.py,sha256=GSxIgwrX26a1Smfd-6yss2abGCnadGsrSZGa7t7LpJA,2008
 vellum/workflows/workflows/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/workflows/tests/test_base_workflow.py,sha256=dz5F3DuGOk9qUMjmNd-GdEE3320G5ko5nJ6J0QJyVcY,2659
-vellum_ai-0.14.1.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
-vellum_ai-0.14.1.dist-info/METADATA,sha256=TGCti5BkhYzjafUugASpEkqaT-cfB5-0K0zWZQPi3II,5407
-vellum_ai-0.14.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-vellum_ai-0.14.1.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
-vellum_ai-0.14.1.dist-info/RECORD,,
+vellum_ai-0.14.2.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
+vellum_ai-0.14.2.dist-info/METADATA,sha256=w083H2Gds-z_b4DPwlYGdnCjD-UXv1q_3CqQAZtSLvI,5407
+vellum_ai-0.14.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+vellum_ai-0.14.2.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
+vellum_ai-0.14.2.dist-info/RECORD,,

vellum_cli/pull.py

@@ -2,14 +2,14 @@ import io
 import json
 import os
 from pathlib import Path
-from uuid import UUID
 import zipfile
-from typing import Optional, Union
+from typing import Optional
 
 from dotenv import load_dotenv
 from pydash import snake_case
 
 from vellum.client.core.pydantic_utilities import UniversalBaseModel
+from vellum.utils.uuid import is_valid_uuid
 from vellum.workflows.vellum_client import create_vellum_client
 from vellum_cli.config import VellumCliConfig, WorkflowConfig, load_vellum_cli_config
 from vellum_cli.logger import load_cli_logger
@@ -18,14 +18,6 @@ ERROR_LOG_FILE_NAME = "error.log"
 METADATA_FILE_NAME = "metadata.json"
 
 
-def _is_valid_uuid(val: Union[str, UUID, None]) -> bool:
-    try:
-        UUID(str(val))
-        return True
-    except (ValueError, TypeError):
-        return False
-
-
 class WorkflowConfigResolutionResult(UniversalBaseModel):
     workflow_config: Optional[WorkflowConfig] = None
     pk: Optional[str] = None
@@ -88,7 +80,7 @@ def _resolve_workflow_config(
     elif workflow_deployment:
         module = (
             f"workflow_{workflow_deployment.split('-')[0]}"
-            if _is_valid_uuid(workflow_deployment)
+            if is_valid_uuid(workflow_deployment)
             else snake_case(workflow_deployment)
         )
         workflow_config = WorkflowConfig(

vellum_ee/workflows/display/vellum.py

@@ -127,7 +127,7 @@ class WorkflowOutputVellumDisplayOverrides(WorkflowOutputDisplay, WorkflowOutput
     name: str
     label: str
     node_id: UUID
-    display_data: NodeDisplayData
+    display_data: Optional[NodeDisplayData] = None
     target_handle_id: Optional[UUID] = None
 
 

vellum_ee/workflows/display/workflows/vellum_workflow_display.py

@@ -176,6 +176,16 @@ class VellumWorkflowDisplay(
                     except IndexError:
                         source_node_display = None
 
+                synthetic_target_handle_id = (
+                    str(workflow_output_display.target_handle_id)
+                    if workflow_output_display.target_handle_id
+                    else str(uuid4_from_hash(f"{self.workflow_id}|target_handle_id|{workflow_output_display.name}"))
+                )
+                synthetic_display_data = (
+                    workflow_output_display.display_data.dict()
+                    if workflow_output_display.display_data
+                    else NodeDisplayData().dict()
+                )
                 nodes.append(
                     {
                         "id": str(final_output_node_id),
@@ -183,13 +193,13 @@ class VellumWorkflowDisplay(
                         "data": {
                             "label": workflow_output_display.label,
                             "name": workflow_output_display.name,
-                            "target_handle_id": str(workflow_output_display.target_handle_id),
+                            "target_handle_id": synthetic_target_handle_id,
                             "output_id": str(workflow_output_display.id),
                             "output_type": inferred_type,
                             "node_input_id": str(node_input.id),
                         },
                         "inputs": [node_input.dict()],
-                        "display_data": workflow_output_display.display_data.dict(),
+                        "display_data": synthetic_display_data,
                         "base": final_output_node_base,
                         "definition": None,
                     }
@@ -211,7 +221,7 @@ class VellumWorkflowDisplay(
                             "source_node_id": str(source_node_display.node_id),
                             "source_handle_id": str(source_handle_id),
                             "target_node_id": str(workflow_output_display.node_id),
-                            "target_handle_id": str(workflow_output_display.target_handle_id),
+                            "target_handle_id": synthetic_target_handle_id,
                             "type": "DEFAULT",
                         }
                     )
@@ -372,15 +382,12 @@ class VellumWorkflowDisplay(
 
         output_id = uuid4_from_hash(f"{self.workflow_id}|id|{output.name}")
         node_id = uuid4_from_hash(f"{self.workflow_id}|node_id|{output.name}")
-        target_handle_id = uuid4_from_hash(f"{self.workflow_id}|target_handle_id|{output.name}")
 
         return WorkflowOutputVellumDisplay(
             id=output_id,
             node_id=node_id,
             name=output.name,
             label="Final Output",
-            target_handle_id=target_handle_id,
-            display_data=NodeDisplayData(),
         )
 
     def _generate_edge_display(

vellum_ee/workflows/tests/local_workflow/display/workflow.py

@@ -50,7 +50,5 @@ class WorkflowDisplay(VellumWorkflowDisplay[Workflow]):
             node_id=UUID("f3ef4b2b-fec9-4026-9cc6-e5eac295307f"),
             name="final-output",
             label="Final Output",
-            target_handle_id=UUID("3ec34f6e-da48-40d5-a65b-a48fefa75763"),
-            display_data=NodeDisplayData(position=NodeDisplayPosition(x=2750, y=210), width=459, height=234),
         )
     }