vellum-ai 0.14.9__tar.gz → 0.14.11__tar.gz

{vellum_ai-0.14.9 → vellum_ai-0.14.11}/PKG-INFO

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

{vellum_ai-0.14.9 → vellum_ai-0.14.11}/ee/vellum_cli/image_push.py

@@ -1,5 +1,6 @@
 import json
 import logging
+import re
 import subprocess
 from typing import List, Optional
 
@@ -24,9 +25,11 @@ def image_push_command(image: str, tags: Optional[List[str]] = None) -> None:
     # listing all of the architectures of the image instead of just the one that matches the machine. We can fall back
     # to using normal inspect which returns the machine image for this case though. And in the future we could figure
     # out how to call the docker host directly to do this.
+    logger.info("Pre-validating image...")
     docker_client = docker.from_env()
     check_architecture(docker_client, image, logger)
 
+    logger.info("Authenticating...")
     auth = vellum_client.container_images.docker_service_token()
 
     docker_client.login(
@@ -70,9 +73,29 @@ def image_push_command(image: str, tags: Optional[List[str]] = None) -> None:
             except Exception:
                 continue
 
-    logger.info("Updating Vellum metadata and enforcing the first law of robotics...")
-    image_details = docker_client.api.inspect_image(image)
-    sha = image_details["Id"]
+    result = subprocess.run(
+        ["docker", "inspect", "--format='{{index .RepoDigests 0}}'", image],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
+
+    sha = ""
+    if result.returncode == 0:
+        match = re.search(r"sha256[^']*", result.stdout.decode("utf-8"))
+        if match and match.group(0):
+            sha = match.group(0)
+
+    if not sha:
+        # Fallback to using docker client if command line fails, at least on some systems
+        # this appears to give a bad sha.
+        logger.warning(
+            "Could not determine image hash with command line docker falling back to python docker client..."
+        )
+
+        image_details = docker_client.api.inspect_image(image)
+        sha = image_details["Id"]
+
+    logger.info(f"Updating Vellum metadata and validating image works in our system with image digest: {sha}...")
 
     vellum_client.container_images.push_container_image(
         name=image_name,
@@ -95,12 +118,12 @@ def check_architecture(docker_client: DockerClient, image: str, logger: logging.
         manifest = json.loads(result.stdout)
         architectures = [manifest_item["platform"]["architecture"] for manifest_item in manifest["manifests"]]
     except Exception:
-        logger.warning("Error parsing manifest response")
+        logger.debug("Error parsing manifest response")
         manifest_parse_failed = True
 
     # Fall back to inspect image if we errored out using docker command line
     if result.returncode != 0 or manifest_parse_failed:
-        logger.warning(f"Error inspecting manifest: {result.stderr.decode('utf-8').strip()}")
+        logger.debug(f"Error inspecting manifest: {result.stderr.decode('utf-8').strip()}")
         image_details = docker_client.api.inspect_image(image)
 
         if image_details["Architecture"] != _SUPPORTED_ARCHITECTURE:

vellum_ai-0.14.11/ee/vellum_ee/workflows/display/nodes/vellum/retry_node.py

@@ -0,0 +1,132 @@
+import inspect
+from typing import Any, Callable, Generic, Optional, Tuple, Type, TypeVar, cast
+
+from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.errors.types import WorkflowErrorCode
+from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.nodes.core.retry_node.node import RetryNode
+from vellum.workflows.nodes.utils import ADORNMENT_MODULE_NAME
+from vellum.workflows.references.output import OutputReference
+from vellum.workflows.types.core import JsonArray, JsonObject
+from vellum.workflows.types.utils import get_original_base
+from vellum.workflows.utils.uuids import uuid4_from_hash
+from vellum.workflows.workflows.base import BaseWorkflow
+from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
+from vellum_ee.workflows.display.nodes.get_node_display_class import get_node_display_class
+from vellum_ee.workflows.display.nodes.types import NodeOutputDisplay
+from vellum_ee.workflows.display.nodes.vellum.base_adornment_node import BaseAdornmentNodeDisplay
+from vellum_ee.workflows.display.types import WorkflowDisplayContext
+
+_RetryNodeType = TypeVar("_RetryNodeType", bound=RetryNode)
+
+
+class BaseRetryNodeDisplay(BaseAdornmentNodeDisplay[_RetryNodeType], Generic[_RetryNodeType]):
+    def serialize(self, display_context: WorkflowDisplayContext, **kwargs: Any) -> JsonObject:
+        node = self._node
+        node_id = self.node_id
+
+        attributes: JsonArray = []
+        for attribute in node:
+            if inspect.isclass(attribute.instance) and issubclass(attribute.instance, BaseWorkflow):
+                # We don't need to serialize attributes that are workflows
+                continue
+
+            id = str(uuid4_from_hash(f"{node_id}|{attribute.name}"))
+            attributes.append(
+                {
+                    "id": id,
+                    "name": attribute.name,
+                    "value": self.serialize_value(display_context, cast(BaseDescriptor, attribute.instance)),
+                }
+            )
+
+        adornment: JsonObject = {
+            "id": str(node_id),
+            "label": node.__qualname__,
+            "base": self.get_base().dict(),
+            "attributes": attributes,
+        }
+
+        serialized_node = super().serialize(
+            display_context,
+            adornment=adornment,
+        )
+
+        if serialized_node["type"] == "GENERIC":
+            return serialized_node
+
+        serialized_node_definition = serialized_node.get("definition")
+        if isinstance(serialized_node_definition, dict):
+            serialized_node_definition_module = serialized_node_definition.get("module")
+            if isinstance(serialized_node_definition_module, list):
+                serialized_node_definition_module.extend(
+                    [
+                        serialized_node_definition["name"],
+                        ADORNMENT_MODULE_NAME,
+                    ]
+                )
+                serialized_node_definition["name"] = node.__name__
+
+        return serialized_node
+
+    def get_node_output_display(self, output: OutputReference) -> Tuple[Type[BaseNode], NodeOutputDisplay]:
+        inner_node = self._node.__wrapped_node__
+        if not inner_node:
+            return super().get_node_output_display(output)
+
+        node_display_class = get_node_display_class(BaseNodeDisplay, inner_node)
+        node_display = node_display_class()
+
+        inner_output = getattr(inner_node.Outputs, output.name)
+        return node_display.get_node_output_display(inner_output)
+
+    @classmethod
+    def wrap(
+        cls,
+        max_attempts: int,
+        delay: Optional[float] = None,
+        retry_on_error_code: Optional[WorkflowErrorCode] = None,
+        retry_on_condition: Optional[BaseDescriptor] = None,
+    ) -> Callable[..., Type["BaseRetryNodeDisplay"]]:
+        _max_attempts = max_attempts
+        _delay = delay
+        _retry_on_error_code = retry_on_error_code
+        _retry_on_condition = retry_on_condition
+
+        NodeDisplayType = TypeVar("NodeDisplayType", bound=BaseNodeDisplay)
+
+        def decorator(inner_cls: Type[NodeDisplayType]) -> Type[NodeDisplayType]:
+            node_class = inner_cls.infer_node_class()
+            wrapped_node_class = cast(Type[BaseNode], node_class.__wrapped_node__)
+
+            class RetryNodeDisplay(BaseRetryNodeDisplay[node_class]):  # type: ignore[valid-type]
+                max_attempts = _max_attempts
+                delay = _delay
+                retry_on_error_code = _retry_on_error_code
+                retry_on_condition = _retry_on_condition
+
+            setattr(inner_cls, "__adorned_by__", RetryNodeDisplay)
+
+            # We must edit the node display class to use __wrapped_node__ everywhere it
+            # references the adorned node class, which is three places:
+
+            # 1. The node display class' parameterized type
+            original_base_node_display = get_original_base(inner_cls)
+            original_base_node_display.__args__ = (wrapped_node_class,)
+            inner_cls._node_display_registry[wrapped_node_class] = inner_cls
+
+            # 2. The node display class' output displays
+            old_outputs = list(inner_cls.output_display.keys())
+            for old_output in old_outputs:
+                new_output = getattr(wrapped_node_class.Outputs, old_output.name)
+                inner_cls.output_display[new_output] = inner_cls.output_display.pop(old_output)
+
+            # 3. The node display class' port displays
+            old_ports = list(inner_cls.port_displays.keys())
+            for old_port in old_ports:
+                new_port = getattr(wrapped_node_class.Ports, old_port.name)
+                inner_cls.port_displays[new_port] = inner_cls.port_displays.pop(old_port)
+
+            return inner_cls
+
+        return decorator

vellum_ai-0.14.11/ee/vellum_ee/workflows/display/nodes/vellum/tests/test_retry_node.py

@@ -0,0 +1,47 @@
+from typing import Any, Dict, cast
+
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.errors.types import WorkflowErrorCode
+from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.nodes.core.retry_node.node import RetryNode
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+from vellum_ee.workflows.display.workflows.vellum_workflow_display import VellumWorkflowDisplay
+
+
+def test_retry_node_parameters():
+    """Test that RetryNode parameters are correctly serialized."""
+
+    # GIVEN a RetryNode with specific parameters
+    @RetryNode.wrap(max_attempts=5, delay=2.5, retry_on_error_code=WorkflowErrorCode.INVALID_INPUTS)
+    class MyRetryNode(BaseNode):
+        pass
+
+    # AND a workflow using the node
+    class MyWorkflow(BaseWorkflow):
+        graph = MyRetryNode
+
+    # WHEN we serialize the workflow
+    workflow_display = get_workflow_display(base_display_class=VellumWorkflowDisplay, workflow_class=MyWorkflow)
+    serialized_workflow = cast(Dict[str, Any], workflow_display.serialize())
+
+    # THEN the correct inputs should be serialized on the node
+    serialized_node = next(
+        node for node in serialized_workflow["workflow_raw_data"]["nodes"] if node["type"] != "ENTRYPOINT"
+    )
+
+    retry_adornment = next(
+        adornment for adornment in serialized_node["adornments"] if adornment["label"] == "RetryNode"
+    )
+
+    max_attempts_attribute = next(attr for attr in retry_adornment["attributes"] if attr["name"] == "max_attempts")
+    assert max_attempts_attribute["value"]["value"]["value"] == 5
+
+    delay_attribute = next(attr for attr in retry_adornment["attributes"] if attr["name"] == "delay")
+    assert delay_attribute["value"]["value"]["value"] == 2.5
+
+    retry_on_error_code_attribute = next(
+        attr for attr in retry_adornment["attributes"] if attr["name"] == "retry_on_error_code"
+    )
+
+    assert retry_on_error_code_attribute["value"]["value"]["type"] == "STRING"
+    assert retry_on_error_code_attribute["value"]["value"]["value"] == "INVALID_INPUTS"

{vellum_ai-0.14.9 → vellum_ai-0.14.11}/ee/vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_adornments_serialization.py

@@ -29,11 +29,8 @@ class InnerRetryGenericNode(BaseNode):
         output: str
 
 
-class InnerRetryGenericNodeDisplay(BaseNodeDisplay[InnerRetryGenericNode.__wrapped_node__]):  # type: ignore
-    pass
-
-
-class OuterRetryNodeDisplay(BaseRetryNodeDisplay[InnerRetryGenericNode]):  # type: ignore
+@BaseRetryNodeDisplay.wrap(max_attempts=3)
+class InnerRetryGenericNodeDisplay(BaseNodeDisplay[InnerRetryGenericNode]):
     pass
 
 
@@ -44,7 +41,6 @@ def test_serialize_node__retry(serialize_node):
         global_workflow_input_displays={Inputs.input: WorkflowInputsDisplay(id=input_id)},
         global_node_displays={
             InnerRetryGenericNode.__wrapped_node__: InnerRetryGenericNodeDisplay,
-            InnerRetryGenericNode: OuterRetryNodeDisplay,
         },
     )
 

{vellum_ai-0.14.9 → vellum_ai-0.14.11}/ee/vellum_ee/workflows/display/workflows/base_workflow_display.py

@@ -9,7 +9,7 @@ from typing import Any, Dict, Generic, Iterator, List, Optional, Tuple, Type, Un
 from vellum.workflows import BaseWorkflow
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.edges import Edge
-from vellum.workflows.events.workflow import NodeDisplay, WorkflowEventDisplayContext
+from vellum.workflows.events.workflow import NodeEventDisplayContext, WorkflowEventDisplayContext
 from vellum.workflows.expressions.coalesce_expression import CoalesceExpression
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.utils import get_wrapped_node
@@ -34,7 +34,9 @@ from vellum_ee.workflows.display.base import (
 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
 from vellum_ee.workflows.display.nodes.types import NodeOutputDisplay, PortDisplay, PortDisplayOverrides
+from vellum_ee.workflows.display.nodes.utils import raise_if_descriptor
 from vellum_ee.workflows.display.types import NodeDisplayType, WorkflowDisplayContext
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
 
 logger = logging.getLogger(__name__)
 
@@ -383,10 +385,15 @@ class BaseWorkflowDisplay(
         except ModuleNotFoundError:
             return None
 
-        display_context = display_class.WorkflowDisplay(workflow_class).display_context
-        if not isinstance(display_context, WorkflowDisplayContext):
+        workflow_display = display_class.WorkflowDisplay(workflow_class)
+        if not isinstance(workflow_display, BaseWorkflowDisplay):
             return None
 
+        return workflow_display.get_event_display_context()
+
+    def get_event_display_context(self):
+        display_context = self.display_context
+
         workflow_outputs = {
             output.name: display_context.workflow_output_displays[output].id
             for output in display_context.workflow_output_displays
@@ -398,27 +405,44 @@ class BaseWorkflowDisplay(
         node_displays = {
             str(node.__id__): display_context.node_displays[node] for node in display_context.node_displays
         }
-        temp_node_displays = {}
-        for node in node_displays:
-            current_node = node_displays[node]
+        node_event_displays = {}
+        for node_id in node_displays:
+            current_node_display = node_displays[node_id]
             input_display = {}
-            if isinstance(current_node, BaseNodeVellumDisplay):
-                input_display = current_node.node_input_ids_by_name
+            if isinstance(current_node_display, BaseNodeVellumDisplay):
+                input_display = current_node_display.node_input_ids_by_name
             node_display_meta = {
-                output.name: current_node.output_display[output].id for output in current_node.output_display
+                output.name: current_node_display.output_display[output].id
+                for output in current_node_display.output_display
             }
-            port_display_meta = {port.name: current_node.port_displays[port].id for port in current_node.port_displays}
-
-            temp_node_displays[node] = NodeDisplay(
+            port_display_meta = {
+                port.name: current_node_display.port_displays[port].id for port in current_node_display.port_displays
+            }
+            node = current_node_display._node
+            subworkflow_display_context: Optional[WorkflowEventDisplayContext] = None
+            if hasattr(node, "subworkflow"):
+                # All nodes that have a subworkflow attribute are currently expected to call them `subworkflow`
+                # This will change if in the future we decide to support multiple subworkflows on a single node
+                subworkflow_attribute = raise_if_descriptor(getattr(node, "subworkflow"))
+                if issubclass(subworkflow_attribute, BaseWorkflow):
+                    subworkflow_display = get_workflow_display(
+                        base_display_class=display_context.workflow_display_class,
+                        workflow_class=subworkflow_attribute,
+                        parent_display_context=display_context,
+                    )
+                    subworkflow_display_context = subworkflow_display.get_event_display_context()
+
+            node_event_displays[node_id] = NodeEventDisplayContext(
                 input_display=input_display,
                 output_display=node_display_meta,
                 port_display=port_display_meta,
+                subworkflow_display=subworkflow_display_context,
             )
 
         display_meta = WorkflowEventDisplayContext(
             workflow_outputs=workflow_outputs,
             workflow_inputs=workflow_inputs,
-            node_displays=temp_node_displays,
+            node_displays=node_event_displays,
         )
         return display_meta
 

{vellum_ai-0.14.9 → vellum_ai-0.14.11}/ee/vellum_ee/workflows/display/workflows/tests/test_workflow_display.py

@@ -1,6 +1,7 @@
 import pytest
 
 from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.nodes.core.inline_subworkflow_node.node import InlineSubworkflowNode
 from vellum.workflows.workflows.base import BaseWorkflow
 from vellum_ee.workflows.display.nodes import BaseNodeDisplay
 from vellum_ee.workflows.display.vellum import NodeDisplayData, NodeDisplayPosition
@@ -92,3 +93,29 @@ def test_serialize_workflow__node_display_class_not_registered():
 
     # THEN it should should succeed
     assert data is not None
+
+
+def test_get_event_display_context__node_display_to_include_subworkflow_display():
+    # GIVEN a simple workflow
+    class InnerNode(BaseNode):
+        pass
+
+    class Subworkflow(BaseWorkflow):
+        graph = InnerNode
+
+    # AND a workflow that includes the subworkflow
+    class SubworkflowNode(InlineSubworkflowNode):
+        subworkflow = Subworkflow
+
+    class MyWorkflow(BaseWorkflow):
+        graph = SubworkflowNode
+
+    # WHEN we gather the event display context
+    display_context = VellumWorkflowDisplay(MyWorkflow).get_event_display_context()
+
+    # THEN the subworkflow display should be included
+    assert str(SubworkflowNode.__id__) in display_context.node_displays
+    node_event_display = display_context.node_displays[str(SubworkflowNode.__id__)]
+
+    assert node_event_display.subworkflow_display is not None
+    assert str(InnerNode.__id__) in node_event_display.subworkflow_display.node_displays

{vellum_ai-0.14.9 → vellum_ai-0.14.11}/ee/vellum_ee/workflows/tests/test_display_meta.py

@@ -40,11 +40,13 @@ def test_base_class_dynamic_import(files):
                 },
                 "output_display": {"result": UUID("423bc529-1a1a-4f72-af4d-cbdb5f0a5929")},
                 "port_display": {"default": UUID("afda9a19-0618-42e1-9b63-5d0db2a88f62")},
+                "subworkflow_display": None,
             },
             "f3ef4b2b-fec9-4026-9cc6-e5eac295307f": {
                 "input_display": {"node_input": UUID("fe6cba85-2423-4b5e-8f85-06311a8be5fb")},
                 "output_display": {"value": UUID("5469b810-6ea6-4362-9e79-e360d44a1405")},
                 "port_display": {},
+                "subworkflow_display": None,
             },
         },
         "workflow_inputs": {"input_value": UUID("2268a996-bd17-4832-b3ff-f5662d54b306")},

{vellum_ai-0.14.9 → vellum_ai-0.14.11}/pyproject.toml

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

{vellum_ai-0.14.9 → vellum_ai-0.14.11}/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.9",
+            "X-Fern-SDK-Version": "0.14.11",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

{vellum_ai-0.14.9 → vellum_ai-0.14.11}/src/vellum/utils/templating/render.py

@@ -2,6 +2,7 @@ import json
 from typing import Any, Dict, Optional
 
 from jinja2.sandbox import SandboxedEnvironment
+from pydantic import BaseModel
 
 from vellum.utils.templating.constants import FilterFunc
 from vellum.utils.templating.exceptions import JinjaTemplateError
@@ -12,6 +13,9 @@ def finalize(obj: Any) -> str:
     if isinstance(obj, (dict, list)):
         return json.dumps(obj, cls=DefaultStateEncoder)
 
+    if isinstance(obj, BaseModel):
+        return json.dumps(obj.model_dump(), cls=DefaultStateEncoder)
+
     return str(obj)
 
 
@@ -23,7 +27,6 @@ def render_sandboxed_jinja_template(
     jinja_globals: Optional[Dict[str, Any]] = None,
 ) -> str:
     """Render a Jinja template within a sandboxed environment."""
-
     try:
         environment = SandboxedEnvironment(
             keep_trailing_newline=True,

{vellum_ai-0.14.9 → vellum_ai-0.14.11}/src/vellum/workflows/events/types.py

@@ -75,6 +75,7 @@ class BaseDeploymentParentContext(BaseParentContext):
     release_tag_id: UUID
     release_tag_name: str
     external_id: Optional[str]
+    metadata: Optional[dict]
 
 
 class WorkflowDeploymentParentContext(BaseDeploymentParentContext):
@@ -104,6 +105,10 @@ class WorkflowSandboxParentContext(BaseParentContext):
     scenario_id: UUID
 
 
+class APIRequestParentContext(BaseParentContext):
+    type: Literal["API_REQUEST"] = "API_REQUEST"
+
+
 # Define the discriminated union
 ParentContext = Annotated[
     Union[
@@ -112,6 +117,7 @@ ParentContext = Annotated[
         WorkflowDeploymentParentContext,
         PromptDeploymentParentContext,
         WorkflowSandboxParentContext,
+        APIRequestParentContext,
     ],
     Field(discriminator="type"),
 ]

{vellum_ai-0.14.9 → vellum_ai-0.14.11}/src/vellum/workflows/events/workflow.py

@@ -39,14 +39,15 @@ class _BaseWorkflowEvent(BaseEvent):
         return self.body.workflow_definition
 
 
-class NodeDisplay(UniversalBaseModel):
+class NodeEventDisplayContext(UniversalBaseModel):
     input_display: Dict[str, UUID]
     output_display: Dict[str, UUID]
     port_display: Dict[str, UUID]
+    subworkflow_display: Optional["WorkflowEventDisplayContext"] = None
 
 
 class WorkflowEventDisplayContext(UniversalBaseModel):
-    node_displays: Dict[str, NodeDisplay]
+    node_displays: Dict[str, NodeEventDisplayContext]
     workflow_inputs: Dict[str, UUID]
     workflow_outputs: Dict[str, UUID]
 

{vellum_ai-0.14.9 → vellum_ai-0.14.11}/src/vellum/workflows/nodes/core/templating_node/node.py

@@ -82,7 +82,6 @@ class TemplatingNode(BaseNode[StateType], Generic[StateType, _OutputType], metac
     def run(self) -> Outputs:
         rendered_template = self._render_template()
         result = self._cast_rendered_template(rendered_template)
-
         return self.Outputs(result=result)
 
     def _render_template(self) -> str:

{vellum_ai-0.14.9 → vellum_ai-0.14.11}/src/vellum/workflows/nodes/core/templating_node/tests/test_templating_node.py

@@ -234,3 +234,52 @@ def test_templating_node__last_chat_message():
 
     # THEN the output is the expected JSON
     assert outputs.result == [ChatMessage(role="USER", text="Hello")]
+
+
+def test_templating_node__function_call_value_input():
+    # GIVEN a templating node that receives a FunctionCallVellumValue
+    class FunctionCallTemplateNode(TemplatingNode[BaseState, FunctionCall]):
+        template = """{{ function_call }}"""
+        inputs = {
+            "function_call": FunctionCallVellumValue(
+                type="FUNCTION_CALL",
+                value=FunctionCall(name="test_function", arguments={"key": "value"}, id="test_id", state="FULFILLED"),
+            )
+        }
+
+    # WHEN the node is run
+    node = FunctionCallTemplateNode()
+    outputs = node.run()
+
+    # THEN the output is the expected function call
+    assert outputs.result == FunctionCall(
+        name="test_function", arguments={"key": "value"}, id="test_id", state="FULFILLED"
+    )
+
+
+def test_templating_node__function_call_as_json():
+    # GIVEN a node that receives a FunctionCallVellumValue but outputs as Json
+    class JsonOutputNode(TemplatingNode[BaseState, Json]):
+        template = """{{ function_call }}"""
+        inputs = {
+            "function_call": FunctionCallVellumValue(
+                type="FUNCTION_CALL",
+                value=FunctionCall(name="test_function", arguments={"key": "value"}, id="test_id", state="FULFILLED"),
+            )
+        }
+
+    # WHEN the node is run
+    node = JsonOutputNode()
+    outputs = node.run()
+
+    # THEN we get just the FunctionCall data as JSON
+    assert outputs.result == {
+        "name": "test_function",
+        "arguments": {"key": "value"},
+        "id": "test_id",
+        "state": "FULFILLED",
+    }
+
+    # AND we can access fields directly
+    assert outputs.result["arguments"] == {"key": "value"}
+    assert outputs.result["name"] == "test_function"

{vellum_ai-0.14.9 → vellum_ai-0.14.11}/src/vellum/workflows/nodes/displayable/code_execution_node/tests/test_code_execution_node.py

@@ -458,16 +458,7 @@ def main(word: str) -> int:
         node.run()
 
     # THEN the node should have produced the exception we expected
-    assert (
-        exc_info.value.message
-        == """\
-2 validation errors for FunctionCall
-arguments
-  Field required [type=missing, input_value={'n': 'hello', 'a': {}}, input_type=dict]
-name
-  Field required [type=missing, input_value={'n': 'hello', 'a': {}}, input_type=dict]\
-"""
-    )
+    assert exc_info.value.message == "Expected an output of type 'FunctionCall', but received 'dict'"
 
 
 def test_run_node__run_inline__valid_dict_to_pydantic_any_type():
@@ -743,3 +734,46 @@ Node.js v21.7.3
 
     # AND the error should contain the execution error details
     assert exc_info.value.message == message
+
+
+def test_run_node__execute_code__list_extends():
+    # GIVEN a node that will return a list with output type Json
+    class ExampleCodeExecutionNode(CodeExecutionNode[BaseState, Json]):
+        code = """\
+def main(left, right):
+    all = []
+    all.extend(left)
+    all.extend(right)
+    return all
+"""
+        code_inputs = {
+            "left": [1, 2, 3],
+            "right": [4, 5, 6],
+        }
+        runtime = "PYTHON_3_11_6"
+
+    # WHEN we run the node
+    node = ExampleCodeExecutionNode()
+    outputs = node.run()
+
+    # AND the result should be the correct output
+    assert outputs == {"result": [1, 2, 3, 4, 5, 6], "log": ""}
+
+
+def test_run_node__execute_code__non_str_print():
+    # GIVEN a node that will print a non-string value
+    class ExampleCodeExecutionNode(CodeExecutionNode[BaseState, str]):
+        code = """\
+def main():
+    print(type(1))
+    return "hello"
+"""
+        code_inputs = {}
+        runtime = "PYTHON_3_11_6"
+
+    # WHEN we run the node
+    node = ExampleCodeExecutionNode()
+    outputs = node.run()
+
+    # AND the result should be the correct output
+    assert outputs == {"result": "hello", "log": "<class 'int'>\n"}