vellum-ai 0.14.1__tar.gz → 0.14.3__tar.gz

{vellum_ai-0.14.1 → vellum_ai-0.14.3}/PKG-INFO

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

{vellum_ai-0.14.1 → vellum_ai-0.14.3}/ee/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_ai-0.14.1 → vellum_ai-0.14.3}/ee/vellum_ee/workflows/display/base.py

@@ -74,14 +74,15 @@ EntrypointDisplayOverridesType = TypeVar("EntrypointDisplayOverridesType", bound
 
 
 @dataclass
-class WorkflowOutputDisplayOverrides:
+class WorkflowOutputDisplay:
     id: UUID
+    name: str
 
 
 @dataclass
-class WorkflowOutputDisplay(WorkflowOutputDisplayOverrides):
-    pass
-
+class WorkflowOutputDisplayOverrides(WorkflowOutputDisplay):
+    """
+    DEPRECATED: Use WorkflowOutputDisplay instead. Will be removed in 0.15.0
+    """
 
-WorkflowOutputDisplayType = TypeVar("WorkflowOutputDisplayType", bound=WorkflowOutputDisplay)
-WorkflowOutputDisplayOverridesType = TypeVar("WorkflowOutputDisplayOverridesType", bound=WorkflowOutputDisplayOverrides)
+    pass

{vellum_ai-0.14.1 → vellum_ai-0.14.3}/ee/vellum_ee/workflows/display/nodes/vellum/inline_subworkflow_node.py

@@ -1,5 +1,5 @@
 from uuid import UUID
-from typing import ClassVar, Dict, Generic, List, Optional, Tuple, Type, TypeVar, cast
+from typing import ClassVar, Dict, Generic, List, Optional, Tuple, Type, TypeVar
 
 from vellum import VellumVariable
 from vellum.workflows.inputs.base import BaseInputs
@@ -10,7 +10,7 @@ from vellum_ee.workflows.display.nodes.utils import raise_if_descriptor
 from vellum_ee.workflows.display.nodes.vellum.utils import create_node_input
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
 from vellum_ee.workflows.display.utils.vellum import infer_vellum_variable_type
-from vellum_ee.workflows.display.vellum import NodeInput, WorkflowOutputVellumDisplay
+from vellum_ee.workflows.display.vellum import NodeInput
 from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
 
 _InlineSubworkflowNodeType = TypeVar("_InlineSubworkflowNodeType", bound=InlineSubworkflowNode)
@@ -110,9 +110,7 @@ class BaseInlineSubworkflowNodeDisplay(
     ) -> List[VellumVariable]:
         workflow_outputs: List[VellumVariable] = []
         for output_descriptor in raise_if_descriptor(node.subworkflow).Outputs:  # type: ignore[union-attr]
-            workflow_output_display = cast(
-                WorkflowOutputVellumDisplay, display_context.workflow_output_displays[output_descriptor]
-            )
+            workflow_output_display = display_context.workflow_output_displays[output_descriptor]
             output_type = infer_vellum_variable_type(output_descriptor)
             workflow_outputs.append(
                 VellumVariable(id=str(workflow_output_display.id), key=workflow_output_display.name, type=output_type)

{vellum_ai-0.14.1 → vellum_ai-0.14.3}/ee/vellum_ee/workflows/display/types.py

@@ -13,7 +13,7 @@ from vellum_ee.workflows.display.base import (
     StateValueDisplayType,
     WorkflowInputsDisplayType,
     WorkflowMetaDisplayType,
-    WorkflowOutputDisplayType,
+    WorkflowOutputDisplay,
 )
 
 if TYPE_CHECKING:
@@ -45,7 +45,6 @@ class WorkflowDisplayContext(
         StateValueDisplayType,
         NodeDisplayType,
         EntrypointDisplayType,
-        WorkflowOutputDisplayType,
         EdgeDisplayType,
     ]
 ):
@@ -63,6 +62,6 @@ class WorkflowDisplayContext(
         default_factory=dict
     )
     entrypoint_displays: Dict[Type[BaseNode], EntrypointDisplayType] = field(default_factory=dict)
-    workflow_output_displays: Dict[BaseDescriptor, WorkflowOutputDisplayType] = field(default_factory=dict)
+    workflow_output_displays: Dict[BaseDescriptor, WorkflowOutputDisplay] = field(default_factory=dict)
     edge_displays: Dict[Tuple[Port, Type[BaseNode]], EdgeDisplayType] = field(default_factory=dict)
     port_displays: Dict[Port, "PortDisplay"] = field(default_factory=dict)

{vellum_ai-0.14.1 → vellum_ai-0.14.3}/ee/vellum_ee/workflows/display/vellum.py

@@ -20,7 +20,6 @@ from vellum_ee.workflows.display.base import (
     WorkflowInputsDisplayOverrides,
     WorkflowMetaDisplay,
     WorkflowMetaDisplayOverrides,
-    WorkflowOutputDisplay,
     WorkflowOutputDisplayOverrides,
 )
 
@@ -123,16 +122,23 @@ class EntrypointVellumDisplay(EntrypointVellumDisplayOverrides):
 
 
 @dataclass
-class WorkflowOutputVellumDisplayOverrides(WorkflowOutputDisplay, WorkflowOutputDisplayOverrides):
-    name: str
-    label: str
-    node_id: UUID
-    display_data: NodeDisplayData
+class WorkflowOutputVellumDisplayOverrides(WorkflowOutputDisplayOverrides):
+    """
+    DEPRECATED: Use WorkflowOutputDisplay instead. Will be removed in 0.15.0
+    """
+
+    label: Optional[str] = None
+    node_id: Optional[UUID] = None
+    display_data: Optional[NodeDisplayData] = None
     target_handle_id: Optional[UUID] = None
 
 
 @dataclass
 class WorkflowOutputVellumDisplay(WorkflowOutputVellumDisplayOverrides):
+    """
+    DEPRECATED: Use WorkflowOutputDisplay instead. Will be removed in 0.15.0
+    """
+
     pass
 
 

{vellum_ai-0.14.1 → vellum_ai-0.14.3}/ee/vellum_ee/workflows/display/workflows/base_workflow_display.py

@@ -28,8 +28,7 @@ from vellum_ee.workflows.display.base import (
     WorkflowInputsDisplayType,
     WorkflowMetaDisplayOverridesType,
     WorkflowMetaDisplayType,
-    WorkflowOutputDisplayOverridesType,
-    WorkflowOutputDisplayType,
+    WorkflowOutputDisplay,
 )
 from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
 from vellum_ee.workflows.display.nodes.get_node_display_class import get_node_display_class
@@ -58,8 +57,6 @@ class BaseWorkflowDisplay(
         EntrypointDisplayOverridesType,
         EdgeDisplayType,
         EdgeDisplayOverridesType,
-        WorkflowOutputDisplayType,
-        WorkflowOutputDisplayOverridesType,
     ]
 ):
     # Used to specify the display data for a workflow.
@@ -75,7 +72,7 @@ class BaseWorkflowDisplay(
     entrypoint_displays: Dict[Type[BaseNode], EntrypointDisplayOverridesType] = {}
 
     # Used to explicitly specify display data for a workflow's outputs.
-    output_displays: Dict[BaseDescriptor, WorkflowOutputDisplayOverridesType] = {}
+    output_displays: Dict[BaseDescriptor, WorkflowOutputDisplay] = {}
 
     # Used to explicitly specify display data for a workflow's edges.
     edge_displays: Dict[Tuple[Port, Type[BaseNode]], EdgeDisplayOverridesType] = {}
@@ -101,7 +98,6 @@ class BaseWorkflowDisplay(
                 StateValueDisplayType,
                 NodeDisplayType,
                 EntrypointDisplayType,
-                WorkflowOutputDisplayType,
                 EdgeDisplayType,
             ]
         ] = None,
@@ -202,7 +198,6 @@ class BaseWorkflowDisplay(
         StateValueDisplayType,
         NodeDisplayType,
         EntrypointDisplayType,
-        WorkflowOutputDisplayType,
         EdgeDisplayType,
     ]:
         workflow_display = self._generate_workflow_meta_display()
@@ -285,7 +280,7 @@ class BaseWorkflowDisplay(
                 edge, node_displays, port_displays, overrides=edge_display_overrides
             )
 
-        workflow_output_displays: Dict[BaseDescriptor, WorkflowOutputDisplayType] = {}
+        workflow_output_displays: Dict[BaseDescriptor, WorkflowOutputDisplay] = {}
         for workflow_output in self._workflow.Outputs:
             if workflow_output in workflow_output_displays:
                 continue
@@ -298,9 +293,9 @@ class BaseWorkflowDisplay(
             ):
                 raise ValueError("Expected to find a descriptor instance on the workflow output")
 
-            workflow_output_display_overrides = self.output_displays.get(workflow_output)
-            workflow_output_displays[workflow_output] = self._generate_workflow_output_display(
-                workflow_output, overrides=workflow_output_display_overrides
+            workflow_output_display = self.output_displays.get(workflow_output)
+            workflow_output_displays[workflow_output] = (
+                workflow_output_display or self._generate_workflow_output_display(workflow_output)
             )
 
         return WorkflowDisplayContext(
@@ -345,13 +340,10 @@ class BaseWorkflowDisplay(
     ) -> EntrypointDisplayType:
         pass
 
-    @abstractmethod
-    def _generate_workflow_output_display(
-        self,
-        output: BaseDescriptor,
-        overrides: Optional[WorkflowOutputDisplayOverridesType] = None,
-    ) -> WorkflowOutputDisplayType:
-        pass
+    def _generate_workflow_output_display(self, output: BaseDescriptor) -> WorkflowOutputDisplay:
+        output_id = uuid4_from_hash(f"{self.workflow_id}|id|{output.name}")
+
+        return WorkflowOutputDisplay(id=output_id, name=output.name)
 
     @abstractmethod
     def _generate_edge_display(

{vellum_ai-0.14.1 → vellum_ai-0.14.3}/ee/vellum_ee/workflows/display/workflows/vellum_workflow_display.py

@@ -31,8 +31,6 @@ from vellum_ee.workflows.display.vellum import (
     WorkflowInputsVellumDisplayOverrides,
     WorkflowMetaVellumDisplay,
     WorkflowMetaVellumDisplayOverrides,
-    WorkflowOutputVellumDisplay,
-    WorkflowOutputVellumDisplayOverrides,
 )
 from vellum_ee.workflows.display.workflows.base_workflow_display import BaseWorkflowDisplay
 
@@ -53,8 +51,6 @@ class VellumWorkflowDisplay(
         EntrypointVellumDisplayOverrides,
         EdgeVellumDisplay,
         EdgeVellumDisplayOverrides,
-        WorkflowOutputVellumDisplay,
-        WorkflowOutputVellumDisplayOverrides,
     ]
 ):
     node_display_base_class = BaseNodeDisplay
@@ -144,7 +140,7 @@ class VellumWorkflowDisplay(
 
         # Add a synthetic Terminal Node and track the Workflow's output variables for each Workflow output
         for workflow_output, workflow_output_display in self.display_context.workflow_output_displays.items():
-            final_output_node_id = workflow_output_display.node_id
+            final_output_node_id = uuid4_from_hash(f"{self.workflow_id}|node_id|{workflow_output.name}")
             inferred_type = infer_vellum_variable_type(workflow_output)
 
             # Remove the terminal node output from the unreferenced set
@@ -176,20 +172,25 @@ class VellumWorkflowDisplay(
                     except IndexError:
                         source_node_display = None
 
+                synthetic_target_handle_id = str(
+                    uuid4_from_hash(f"{self.workflow_id}|target_handle_id|{workflow_output_display.name}")
+                )
+                synthetic_display_data = NodeDisplayData().dict()
+                synthetic_node_label = "Final Output"
                 nodes.append(
                     {
                         "id": str(final_output_node_id),
                         "type": "TERMINAL",
                         "data": {
-                            "label": workflow_output_display.label,
+                            "label": synthetic_node_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,
                     }
@@ -210,8 +211,8 @@ class VellumWorkflowDisplay(
                             "id": str(uuid4_from_hash(f"{self.workflow_id}|edge_id|{workflow_output_display.name}")),
                             "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_node_id": str(final_output_node_id),
+                            "target_handle_id": synthetic_target_handle_id,
                             "type": "DEFAULT",
                         }
                     )
@@ -355,34 +356,6 @@ class VellumWorkflowDisplay(
 
         return EntrypointVellumDisplay(id=entrypoint_id, edge_display=edge_display)
 
-    def _generate_workflow_output_display(
-        self,
-        output: BaseDescriptor,
-        overrides: Optional[WorkflowOutputVellumDisplayOverrides] = None,
-    ) -> WorkflowOutputVellumDisplay:
-        if overrides:
-            return WorkflowOutputVellumDisplay(
-                id=overrides.id,
-                name=overrides.name,
-                label=overrides.label,
-                node_id=overrides.node_id,
-                target_handle_id=overrides.target_handle_id,
-                display_data=overrides.display_data,
-            )
-
-        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(
         self,
         edge: Edge,

{vellum_ai-0.14.1 → vellum_ai-0.14.3}/ee/vellum_ee/workflows/tests/local_workflow/display/workflow.py

@@ -47,10 +47,6 @@ class WorkflowDisplay(VellumWorkflowDisplay[Workflow]):
     output_displays = {
         Workflow.Outputs.final_output: WorkflowOutputVellumDisplayOverrides(
             id=UUID("5469b810-6ea6-4362-9e79-e360d44a1405"),
-            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),
         )
     }

{vellum_ai-0.14.1 → vellum_ai-0.14.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "vellum-ai"
-version = "0.14.1"
+version = "0.14.3"
 description = ""
 readme = "README.md"
 authors = []

{vellum_ai-0.14.1 → vellum_ai-0.14.3}/src/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.3",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

{vellum_ai-0.14.1 → vellum_ai-0.14.3}/src/vellum/prompts/blocks/compilation.py

@@ -19,7 +19,7 @@ from vellum.client.types.vellum_audio import VellumAudio
 from vellum.client.types.vellum_image import VellumImage
 from vellum.prompts.blocks.exceptions import PromptCompilationError
 from vellum.prompts.blocks.types import CompiledChatMessagePromptBlock, CompiledPromptBlock, CompiledValuePromptBlock
-from vellum.utils.templating.constants import DEFAULT_JINJA_CUSTOM_FILTERS
+from vellum.utils.templating.constants import DEFAULT_JINJA_CUSTOM_FILTERS, DEFAULT_JINJA_GLOBALS
 from vellum.utils.templating.render import render_sandboxed_jinja_template
 from vellum.utils.typing import cast_not_optional
 
@@ -74,7 +74,7 @@ def compile_prompt_blocks(
                 template=block.template,
                 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,
+                jinja_globals=DEFAULT_JINJA_GLOBALS,
             )
             jinja_content = StringVellumValue(value=rendered_template)
 

{vellum_ai-0.14.1 → vellum_ai-0.14.3}/src/vellum/prompts/blocks/tests/test_compilation.py

@@ -37,6 +37,14 @@ from vellum.prompts.blocks.types import CompiledChatMessagePromptBlock, Compiled
                 CompiledValuePromptBlock(content=StringVellumValue(value="Repeat back to me Hello, world!")),
             ],
         ),
+        (
+            [JinjaPromptBlock(template="{{ re.search('test', message).group() }}")],
+            [PromptRequestStringInput(key="message", value="testing")],
+            [VellumVariable(id="1", type="STRING", key="message")],
+            [
+                CompiledValuePromptBlock(content=StringVellumValue(value="test")),
+            ],
+        ),
         # Rich Text
         (
             [
@@ -127,6 +135,7 @@ from vellum.prompts.blocks.types import CompiledChatMessagePromptBlock, Compiled
         "empty",
         "jinja-no-variables",
         "jinja-with-variables",
+        "jinja-with-custom-global",
         "rich-text-no-variables",
         "rich-text-with-variables",
         "chat-message",

{vellum_ai-0.14.1 → vellum_ai-0.14.3}/src/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_ai-0.14.3/src/vellum/utils/templating/custom_filters.py

@@ -0,0 +1,33 @@
+import json
+from typing import Any, Union
+
+from vellum.workflows.state.encoder import DefaultStateEncoder
+
+
+def is_valid_json_string(value: Union[str, bytes]) -> bool:
+    """Determines whether the given value is a valid JSON string."""
+
+    try:
+        json.loads(value)
+    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_ai-0.14.1 → vellum_ai-0.14.3}/src/vellum/utils/templating/render.py

@@ -1,14 +1,15 @@
 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
 
 
 def finalize(obj: Any) -> str:
-    if isinstance(obj, dict):
+    if isinstance(obj, (dict, list)):
         return json.dumps(obj, cls=DefaultStateEncoder)
 
     return str(obj)
@@ -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_ai-0.14.3/src/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_ai-0.14.1 → vellum_ai-0.14.3}/src/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_ai-0.14.1 → vellum_ai-0.14.3}/src/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_ai-0.14.1 → vellum_ai-0.14.3}/src/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,43 @@ 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,
+            },
+        }
+    ]
+
+
+def test_templating_node__last_chat_message():
+    # GIVEN a templating node that outputs a complex object
+    class LastChatMessageTemplateNode(TemplatingNode[BaseState, List[ChatMessage]]):
+        template = """{{ chat_history[:-1] }}"""
+        inputs = {"chat_history": [ChatMessage(role="USER", text="Hello"), ChatMessage(role="ASSISTANT", text="World")]}
+
+    # WHEN the node is run
+    node = LastChatMessageTemplateNode()
+    outputs = node.run()
+
+    # THEN the output is the expected JSON
+    assert outputs.result == [ChatMessage(role="USER", text="Hello")]

{vellum_ai-0.14.1 → vellum_ai-0.14.3}/src/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,
                 )