vellum-ai 0.14.4__tar.gz → 0.14.5__tar.gz

{vellum_ai-0.14.4 → vellum_ai-0.14.5}/PKG-INFO

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

{vellum_ai-0.14.4 → vellum_ai-0.14.5}/ee/vellum_ee/workflows/display/nodes/vellum/__init__.py

@@ -1,4 +1,5 @@
 from .api_node import BaseAPINodeDisplay
+from .base_adornment_node import BaseAdornmentNodeDisplay
 from .code_execution_node import BaseCodeExecutionNodeDisplay
 from .conditional_node import BaseConditionalNodeDisplay
 from .error_node import BaseErrorNodeDisplay
@@ -18,6 +19,7 @@ from .try_node import BaseTryNodeDisplay
 
 # All node display classes must be imported here to be registered in BaseNodeDisplay's node display registry
 __all__ = [
+    "BaseAdornmentNodeDisplay",
     "BaseAPINodeDisplay",
     "BaseCodeExecutionNodeDisplay",
     "BaseConditionalNodeDisplay",

vellum_ai-0.14.5/ee/vellum_ee/workflows/display/nodes/vellum/base_adornment_node.py

@@ -0,0 +1,39 @@
+from uuid import UUID
+from typing import Any, Callable, Generic, Optional, TypeVar, cast
+
+from vellum.workflows.nodes.bases.base_adornment_node import BaseAdornmentNode
+from vellum.workflows.nodes.utils import get_wrapped_node
+from vellum.workflows.types.core import JsonArray, JsonObject
+from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
+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.types import WorkflowDisplayContext
+
+_BaseAdornmentNodeType = TypeVar("_BaseAdornmentNodeType", bound=BaseAdornmentNode)
+
+
+class BaseAdornmentNodeDisplay(BaseNodeVellumDisplay[_BaseAdornmentNodeType], Generic[_BaseAdornmentNodeType]):
+    def serialize(
+        self,
+        display_context: "WorkflowDisplayContext",
+        **kwargs: Any,
+    ) -> dict:
+        node = self._node
+        adornment = cast(Optional[JsonObject], kwargs.get("adornment"))
+        get_additional_kwargs = cast(Optional[Callable[[UUID], dict]], kwargs.get("get_additional_kwargs"))
+
+        wrapped_node = get_wrapped_node(node)
+        if not wrapped_node:
+            raise NotImplementedError(
+                "Unable to serialize standalone adornment nodes. Please use adornment nodes as a decorator."
+            )
+
+        wrapped_node_display_class = get_node_display_class(BaseNodeDisplay, wrapped_node)
+        wrapped_node_display = wrapped_node_display_class()
+        additional_kwargs = get_additional_kwargs(wrapped_node_display.node_id) if get_additional_kwargs else {}
+        serialized_wrapped_node = wrapped_node_display.serialize(display_context, **kwargs, **additional_kwargs)
+
+        adornments = cast(JsonArray, serialized_wrapped_node.get("adornments")) or []
+        serialized_wrapped_node["adornments"] = adornments + [adornment] if adornment else adornments
+
+        return serialized_wrapped_node

{vellum_ai-0.14.4 → vellum_ai-0.14.5}/ee/vellum_ee/workflows/display/nodes/vellum/map_node.py

@@ -3,8 +3,8 @@ from typing import Dict, Generic, List, Optional, TypeVar, cast
 
 from vellum.workflows.nodes import MapNode
 from vellum.workflows.types.core import JsonObject
-from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
 from vellum_ee.workflows.display.nodes.utils import raise_if_descriptor
+from vellum_ee.workflows.display.nodes.vellum.base_adornment_node import BaseAdornmentNodeDisplay
 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.workflows.get_vellum_workflow_display_class import get_workflow_display
@@ -12,7 +12,7 @@ from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class imp
 _MapNodeType = TypeVar("_MapNodeType", bound=MapNode)
 
 
-class BaseMapNodeDisplay(BaseNodeVellumDisplay[_MapNodeType], Generic[_MapNodeType]):
+class BaseMapNodeDisplay(BaseAdornmentNodeDisplay[_MapNodeType], Generic[_MapNodeType]):
     def serialize(
         self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
     ) -> JsonObject:

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

@@ -0,0 +1,42 @@
+import inspect
+from typing import Any, Generic, TypeVar, cast
+
+from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.nodes.core.retry_node.node import RetryNode
+from vellum.workflows.types.core import JsonArray, JsonObject
+from vellum.workflows.utils.uuids import uuid4_from_hash
+from vellum.workflows.workflows.base import BaseWorkflow
+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,
+        }
+
+        return super().serialize(display_context, adornment=adornment)

{vellum_ai-0.14.4 → vellum_ai-0.14.5}/ee/vellum_ee/workflows/display/nodes/vellum/try_node.py

@@ -1,55 +1,69 @@
+import inspect
 from uuid import UUID
 from typing import Any, Callable, ClassVar, Generic, Optional, Tuple, Type, TypeVar, cast
 
+from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.nodes.core.try_node.node import TryNode
-from vellum.workflows.nodes.utils import ADORNMENT_MODULE_NAME, get_wrapped_node
+from vellum.workflows.nodes.utils import ADORNMENT_MODULE_NAME
 from vellum.workflows.references.output import OutputReference
-from vellum.workflows.types.core import JsonObject
+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.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
-from vellum_ee.workflows.display.nodes.utils import raise_if_descriptor
+from vellum_ee.workflows.display.nodes.vellum.base_adornment_node import BaseAdornmentNodeDisplay
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
 
 _TryNodeType = TypeVar("_TryNodeType", bound=TryNode)
 
 
-class BaseTryNodeDisplay(BaseNodeVellumDisplay[_TryNodeType], Generic[_TryNodeType]):
+class BaseTryNodeDisplay(BaseAdornmentNodeDisplay[_TryNodeType], Generic[_TryNodeType]):
     error_output_id: ClassVar[Optional[UUID]] = None
 
-    def serialize(self, display_context: WorkflowDisplayContext, **kwargs: Any) -> JsonObject:
+    def serialize(self, display_context: "WorkflowDisplayContext", **kwargs: Any) -> JsonObject:
         node = self._node
+        node_id = self.node_id
+
+        # We let the inner node serialize first and then append to it
+        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)),
+                }
+            )
 
-        inner_node = get_wrapped_node(node)
-        if not inner_node:
-            subworkflow = raise_if_descriptor(node.subworkflow)
-            if not isinstance(subworkflow.graph, type) or not issubclass(subworkflow.graph, BaseNode):
-                raise NotImplementedError(
-                    "Unable to serialize Try Nodes that wrap subworkflows containing more than one Node."
-                )
-
-            inner_node = subworkflow.graph
-        elif inner_node.__bases__[0] is BaseNode:
-            # If the wrapped node is a generic node, we let generic node do adornment handling
-            class TryBaseNodeDisplay(BaseNodeDisplay[node]):  # type: ignore[valid-type]
-                pass
-
-            return TryBaseNodeDisplay().serialize(display_context)
-
-        # We need the node display class of the underlying node because
-        # it contains the logic for serializing the node and potential display overrides
-        node_display_class = get_node_display_class(BaseNodeDisplay, inner_node)
-        node_display = node_display_class()
-
-        serialized_node = node_display.serialize(
+        adornment: JsonObject = {
+            "id": str(node_id),
+            "label": node.__qualname__,
+            "base": self.get_base().dict(),
+            "attributes": attributes,
+        }
+
+        # We need the inner node's ID to generate the error output ID
+        # Long term we want to hoist error_output_id append from inner node displays to this display,
+        # But that's a lot of work and this allows us to punt a little longer
+        serialized_node = super().serialize(
             display_context,
-            error_output_id=self.error_output_id or uuid4_from_hash(f"{node_display.node_id}|error_output_id"),
+            adornment=adornment,
+            get_additional_kwargs=lambda node_id: {
+                "error_output_id": self.error_output_id or uuid4_from_hash(f"{node_id}|error_output_id")
+            },
         )
 
+        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")

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

@@ -1,3 +1,4 @@
+import pytest
 from uuid import uuid4
 
 from deepdiff import DeepDiff
@@ -11,6 +12,7 @@ from vellum.workflows.workflows.base import BaseWorkflow
 from vellum_ee.workflows.display.base import WorkflowInputsDisplay
 from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
 from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
+from vellum_ee.workflows.display.nodes.vellum.retry_node import BaseRetryNodeDisplay
 from vellum_ee.workflows.display.nodes.vellum.try_node import BaseTryNodeDisplay
 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
@@ -32,7 +34,7 @@ class InnerRetryGenericNodeDisplay(BaseNodeDisplay[InnerRetryGenericNode.__wrapp
     pass
 
 
-class OuterRetryNodeDisplay(BaseNodeDisplay[InnerRetryGenericNode]):
+class OuterRetryNodeDisplay(BaseRetryNodeDisplay[InnerRetryGenericNode]):  # type: ignore
     pass
 
 
@@ -213,3 +215,25 @@ def test_serialize_node__try(serialize_node):
         },
         serialized_node,
     )
+
+
+@pytest.mark.skip(reason="Not implemented")
+def test_serialize_node__stacked():
+    @TryNode.wrap()
+    @RetryNode.wrap(max_attempts=5)
+    class InnerStackedGenericNode(BaseNode):
+        pass
+
+    # AND a workflow that uses the adornment node
+    class StackedWorkflow(BaseWorkflow):
+        graph = InnerStackedGenericNode
+
+    # WHEN we serialize the workflow
+    workflow_display = get_workflow_display(
+        base_display_class=VellumWorkflowDisplay,
+        workflow_class=StackedWorkflow,
+    )
+    exec_config = workflow_display.serialize()
+
+    # THEN the workflow display is created successfully
+    assert exec_config is not None

{vellum_ai-0.14.4 → vellum_ai-0.14.5}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_code_execution_node_serialization.py

@@ -596,6 +596,20 @@ def test_serialize_workflow__try_wrapped():
             ],
             "name": "TryNode",
         },
+        "adornments": [
+            {
+                "id": "3344083c-a32c-4a32-920b-0fb5093448fa",
+                "label": "TryNode",
+                "base": {"name": "TryNode", "module": ["vellum", "workflows", "nodes", "core", "try_node", "node"]},
+                "attributes": [
+                    {
+                        "id": "ab2fbab0-e2a0-419b-b1ef-ce11ecf11e90",
+                        "name": "on_error_code",
+                        "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+                    }
+                ],
+            }
+        ],
     }
 
     final_output_nodes = workflow_raw_data["nodes"][2:]

{vellum_ai-0.14.4 → vellum_ai-0.14.5}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_try_node_serialization.py

@@ -1,9 +1,11 @@
+import pytest
+
 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_try_node.workflow import SimpleTryExample
+from tests.workflows.basic_try_node.workflow import SimpleTryExample, StandaloneTryExample
 
 
 def test_serialize_workflow():
@@ -69,3 +71,19 @@ def test_serialize_workflow():
 
     try_node = workflow_raw_data["nodes"][1]
     assert try_node["id"] == "1381c078-efa2-4255-89a1-7b4cb742c7fc"
+
+
+def test_serialize_workflow__standalone():
+    # GIVEN a Workflow with a standalone TryNode
+    # WHEN we serialize it
+    with pytest.raises(NotImplementedError) as exc:
+        workflow_display = get_workflow_display(
+            base_display_class=VellumWorkflowDisplay, workflow_class=StandaloneTryExample
+        )
+        workflow_display.serialize()
+
+    # THEN we should get an error
+    assert (
+        exc.value.args[0]
+        == "Unable to serialize standalone adornment nodes. Please use adornment nodes as a decorator."
+    )

{vellum_ai-0.14.4 → vellum_ai-0.14.5}/pyproject.toml

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

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

{vellum_ai-0.14.4 → vellum_ai-0.14.5}/src/vellum/workflows/context.py

@@ -1,5 +1,6 @@
 from contextlib import contextmanager
 import threading
+from uuid import UUID
 from typing import Iterator, Optional, cast
 
 from vellum.client.core import UniversalBaseModel
@@ -8,6 +9,7 @@ from vellum.workflows.events.types import ParentContext
 
 class ExecutionContext(UniversalBaseModel):
     parent_context: Optional[ParentContext] = None
+    trace_id: Optional[UUID] = None
 
 
 _CONTEXT_KEY = "_execution_context"
@@ -30,11 +32,14 @@ def get_parent_context() -> ParentContext:
 
 
 @contextmanager
-def execution_context(parent_context: Optional[ParentContext] = None) -> Iterator[None]:
+def execution_context(
+    parent_context: Optional[ParentContext] = None, trace_id: Optional[UUID] = None
+) -> Iterator[None]:
     """Context manager for handling execution context."""
     prev_context = get_execution_context()
-    set_context = ExecutionContext(parent_context=parent_context) if parent_context else prev_context
-
+    set_trace_id = prev_context.trace_id or trace_id
+    set_parent_context = parent_context or prev_context.parent_context
+    set_context = ExecutionContext(parent_context=set_parent_context, trace_id=set_trace_id)
     try:
         set_execution_context(set_context)
         yield

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

@@ -1,12 +1,16 @@
 import pytest
 import os
-from typing import Any, Union
+from typing import Any, List, Union
+
+from pydantic import BaseModel
 
 from vellum import CodeExecutorResponse, NumberVellumValue, StringInput, StringVellumValue
+from vellum.client.types.chat_message import ChatMessage
 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.client.types.string_chat_message_content import StringChatMessageContent
 from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.inputs.base import BaseInputs
@@ -610,3 +614,79 @@ def main(arg1: list[bool]) -> int:
 
     # AND the error should contain the execution error details
     assert outputs == {"result": 3, "log": ""}
+
+
+def test_run_node__union_output_type__pydantic_children():
+    # GIVEN a node that is a union type with a pydantic child
+    class OptionOne(BaseModel):
+        foo: str
+
+    class OptionTwo(BaseModel):
+        bar: int
+
+    class ExampleCodeExecutionNode(CodeExecutionNode[BaseState, Union[OptionOne, OptionTwo]]):
+        code = """\
+def main():
+    return { "foo": "hello" }
+"""
+        runtime = "PYTHON_3_11_6"
+        code_inputs = {}
+
+    # WHEN we run the node
+    node = ExampleCodeExecutionNode()
+
+    # THEN it should run successfully
+    outputs = node.run()
+
+    # AND the result should be the correct type
+    assert outputs == {"result": OptionOne(foo="hello"), "log": ""}
+
+
+def test_run_node__union_output_type__miss():
+    # GIVEN a node that is a union type
+    class ExampleCodeExecutionNode(CodeExecutionNode[BaseState, Union[int, float]]):
+        code = """\
+def main():
+    return "hello"
+"""
+        runtime = "PYTHON_3_11_6"
+        code_inputs = {}
+
+    # WHEN we run the node
+    node = ExampleCodeExecutionNode()
+
+    # 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 exc_info.value.message == "Expected an output of type 'int | float', but received 'str'"
+
+
+def test_run_node__chat_history_output_type():
+    # GIVEN a node that that has a chat history return type
+    class ExampleCodeExecutionNode(CodeExecutionNode[BaseState, List[ChatMessage]]):
+        code = """\
+def main():
+    return [
+        {
+            "role": "USER",
+            "content": {
+                "type": "STRING",
+                "value": "Hello, world!",
+            }
+        }
+    ]
+"""
+        code_inputs = {}
+        runtime = "PYTHON_3_11_6"
+
+    # WHEN we run the node
+    node = ExampleCodeExecutionNode()
+    outputs = node.run()
+
+    # AND the error should contain the execution error details
+    assert outputs == {
+        "result": [ChatMessage(role="USER", content=StringChatMessageContent(value="Hello, world!"))],
+        "log": "",
+    }

{vellum_ai-0.14.4 → vellum_ai-0.14.5}/src/vellum/workflows/nodes/displayable/code_execution_node/utils.py

@@ -67,6 +67,49 @@ def _clean_for_dict_wrapper(obj):
     return obj
 
 
+def _get_type_name(obj: Any) -> str:
+    if isinstance(obj, type):
+        return obj.__name__
+
+    if get_origin(obj) is Union:
+        children = [_get_type_name(child) for child in get_args(obj)]
+        return " | ".join(children)
+
+    return str(obj)
+
+
+def _cast_to_output_type(result: Any, output_type: Any) -> Any:
+    is_valid_output_type = isinstance(output_type, type)
+    if get_origin(output_type) is Union:
+        allowed_types = get_args(output_type)
+        for allowed_type in allowed_types:
+            try:
+                return _cast_to_output_type(result, allowed_type)
+            except NodeException:
+                continue
+    elif get_origin(output_type) is list:
+        allowed_item_type = get_args(output_type)[0]
+        if isinstance(result, list):
+            return [_cast_to_output_type(item, allowed_item_type) for item in result]
+    elif is_valid_output_type and issubclass(output_type, BaseModel) and not isinstance(result, output_type):
+        try:
+            return output_type.model_validate(result)
+        except ValidationError as e:
+            raise NodeException(
+                code=WorkflowErrorCode.INVALID_OUTPUTS,
+                message=re.sub(r"\s+For further information visit [^\s]+", "", str(e)),
+            ) from e
+    elif is_valid_output_type and isinstance(result, output_type):
+        return result
+
+    output_type_name = _get_type_name(output_type)
+    result_type_name = _get_type_name(type(result))
+    raise NodeException(
+        code=WorkflowErrorCode.INVALID_OUTPUTS,
+        message=f"Expected an output of type '{output_type_name}', but received '{result_type_name}'",
+    )
+
+
 def run_code_inline(
     code: str,
     inputs: EntityInputsInterface,
@@ -112,25 +155,6 @@ __arg__out = main({", ".join(run_args)})
     result = exec_globals["__arg__out"]
 
     if output_type != Any:
-        if get_origin(output_type) is Union:
-            allowed_types = get_args(output_type)
-            if not isinstance(result, allowed_types):
-                raise NodeException(
-                    code=WorkflowErrorCode.INVALID_OUTPUTS,
-                    message=f"Expected output to be in types {allowed_types}, but received '{type(result).__name__}'",
-                )
-        elif issubclass(output_type, BaseModel) and not isinstance(result, output_type):
-            try:
-                result = output_type.model_validate(result)
-            except ValidationError as e:
-                raise NodeException(
-                    code=WorkflowErrorCode.INVALID_OUTPUTS,
-                    message=re.sub(r"\s+For further information visit [^\s]+", "", str(e)),
-                ) from e
-        elif not isinstance(result, output_type):
-            raise NodeException(
-                code=WorkflowErrorCode.INVALID_OUTPUTS,
-                message=f"Expected an output of type '{output_type.__name__}', but received '{type(result).__name__}'",
-            )
+        result = _cast_to_output_type(result, output_type)
 
     return logs, result

{vellum_ai-0.14.4 → vellum_ai-0.14.5}/src/vellum/workflows/nodes/displayable/prompt_deployment_node/node.py

@@ -1,3 +1,4 @@
+import json
 from typing import Iterator
 
 from vellum.workflows.errors import WorkflowErrorCode
@@ -44,13 +45,19 @@ class PromptDeploymentNode(BasePromptDeploymentNode[StateType]):
                 code=WorkflowErrorCode.INTERNAL_ERROR,
             )
 
-        string_output = next((output for output in outputs if output.type == "STRING"), None)
-        if not string_output or string_output.value is None:
-            output_types = {output.type for output in outputs}
-            is_plural = len(output_types) > 1
-            raise NodeException(
-                message=f"Expected to receive a non-null string output from Prompt. Only found outputs of type{'s' if is_plural else ''}: {', '.join(output_types)}",  # noqa: E501
-                code=WorkflowErrorCode.INTERNAL_ERROR,
-            )
-
-        yield BaseOutput(name="text", value=string_output.value)
+        string_outputs = []
+        for output in outputs:
+            if output.value is None:
+                continue
+
+            if output.type == "STRING":
+                string_outputs.append(output.value)
+            elif output.type == "JSON":
+                string_outputs.append(json.dumps(output.value, indent=4))
+            elif output.type == "FUNCTION_CALL":
+                string_outputs.append(output.value.model_dump_json(indent=4))
+            else:
+                string_outputs.append(output.value.message)
+
+        value = "\n".join(string_outputs)
+        yield BaseOutput(name="text", value=value)