vellum-ai 0.14.63__py3-none-any.whl → 1.11.2__py3-none-any.whl

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

@@ -1,9 +1,11 @@
-from typing import Any, Dict, Generic, Tuple, Type, TypeVar, get_args
+from typing import Any, Dict, Generic, Tuple, Type, TypeVar, get_args, get_origin
 
 from vellum.workflows.constants import undefined
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.bases.base import BaseNodeMeta
 from vellum.workflows.nodes.utils import cast_to_output_type
+from vellum.workflows.ports import NodePorts
+from vellum.workflows.references.output import OutputReference
 from vellum.workflows.types import MergeBehavior
 from vellum.workflows.types.generics import StateType
 from vellum.workflows.types.utils import get_original_base
@@ -26,6 +28,7 @@ class _FinalOutputNodeMeta(BaseNodeMeta):
             **annotations,
             "value": parent.get_output_type(),
         }
+
         return parent
 
     def get_output_type(cls) -> Type:
@@ -37,6 +40,73 @@ class _FinalOutputNodeMeta(BaseNodeMeta):
         else:
             return all_args[1]
 
+    def __validate__(cls) -> None:
+        cls._validate_output_type_consistency(cls)
+
+    @classmethod
+    def _validate_output_type_consistency(mcs, cls: Type) -> None:
+        """
+        Validates that the declared output type of FinalOutputNode matches
+        the type of the descriptor assigned to the 'value' attribute in its Outputs class.
+
+        Raises ValueError if there's a type mismatch.
+        """
+        if not hasattr(cls, "Outputs"):
+            return
+
+        outputs_class = cls.Outputs
+        if not hasattr(outputs_class, "value"):
+            return
+
+        declared_output_type = cls.get_output_type()
+
+        if declared_output_type is Any:
+            return
+
+        value_descriptor = None
+
+        if "value" in outputs_class.__dict__:
+            value_descriptor = outputs_class.__dict__["value"]
+        else:
+            value_descriptor = getattr(outputs_class, "value")
+
+        if isinstance(value_descriptor, OutputReference):
+            descriptor_types = value_descriptor.types
+
+            type_mismatch = True
+            for descriptor_type in descriptor_types:
+                if descriptor_type == declared_output_type:
+                    type_mismatch = False
+                    break
+                if (
+                    get_origin(descriptor_type) == declared_output_type
+                    or get_origin(declared_output_type) == descriptor_type
+                ):
+                    type_mismatch = False
+                    break
+                try:
+                    if issubclass(descriptor_type, declared_output_type) or issubclass(
+                        declared_output_type, descriptor_type
+                    ):
+                        type_mismatch = False
+                        break
+                except TypeError:
+                    # Handle cases where types aren't classes (e.g., Union)
+                    if str(descriptor_type) == str(declared_output_type):
+                        type_mismatch = False
+                        break
+
+            if type_mismatch:
+                declared_type_name = getattr(declared_output_type, "__name__", str(declared_output_type))
+                descriptor_type_names = [getattr(t, "__name__", str(t)) for t in descriptor_types]
+
+                raise ValueError(
+                    f"Output type mismatch in {cls.__name__}: "
+                    f"FinalOutputNode is declared with output type '{declared_type_name}' "
+                    f"but the 'value' descriptor has type(s) {descriptor_type_names}. "
+                    f"The output descriptor type must match the declared FinalOutputNode output type."
+                )
+
 
 class FinalOutputNode(BaseNode[StateType], Generic[StateType, _OutputType], metaclass=_FinalOutputNodeMeta):
     """
@@ -44,9 +114,16 @@ class FinalOutputNode(BaseNode[StateType], Generic[StateType, _OutputType], meta
     This provides backward compatibility with Vellum's Final Output Node.
     """
 
+    class Display(BaseNode.Display):
+        icon = "vellum:icon:circle-stop"
+        color = "teal"
+
     class Trigger(BaseNode.Trigger):
         merge_behavior = MergeBehavior.AWAIT_ANY
 
+    class Ports(NodePorts):
+        pass
+
     class Outputs(BaseNode.Outputs):
         # We use our mypy plugin to override the _OutputType with the actual output type
         # for downstream references to this output.
@@ -61,3 +138,5 @@ class FinalOutputNode(BaseNode[StateType], Generic[StateType, _OutputType], meta
                 self.__class__.get_output_type(),
             )
         )
+
+    __simulates_workflow_output__ = True

vellum/workflows/nodes/displayable/final_output_node/tests/test_node.py

@@ -1,11 +1,16 @@
 import pytest
+from typing import Any, Dict
 
 from vellum.workflows.exceptions import NodeException
+from vellum.workflows.nodes.core.templating_node import TemplatingNode
 from vellum.workflows.nodes.displayable.final_output_node import FinalOutputNode
+from vellum.workflows.nodes.displayable.inline_prompt_node import InlinePromptNode
+from vellum.workflows.references.output import OutputReference
 from vellum.workflows.state.base import BaseState
+from vellum.workflows.types.core import Json
 
 
-def test_final_output_node__mismatched_output_type():
+def test_final_output_node__mismatched_output_type_should_raise_exception_when_ran():
     # GIVEN a FinalOutputNode with a mismatched output type
     class StringOutputNode(FinalOutputNode[BaseState, str]):
         class Outputs(FinalOutputNode.Outputs):
@@ -18,3 +23,93 @@ def test_final_output_node__mismatched_output_type():
 
     # THEN an error is raised
     assert str(exc_info.value) == "Expected an output of type 'str', but received 'dict'"
+
+
+def test_final_output_node__mismatched_output_type_should_raise_exception():
+    # GIVEN a FinalOutputNode declared with list output type but has a string value type
+    class Output(FinalOutputNode[BaseState, list]):
+        """Output the extracted invoice line items as an array of objects."""
+
+        class Outputs(FinalOutputNode.Outputs):
+            value = InlinePromptNode.Outputs.text
+
+    # WHEN attempting to validate the node class
+    # THEN a ValueError should be raised during validation
+    with pytest.raises(ValueError) as exc_info:
+        Output.__validate__()
+
+    # AND the error message should indicate the type mismatch
+    assert (
+        str(exc_info.value)
+        == "Output type mismatch in Output: FinalOutputNode is declared with output type 'list' but "
+        "the 'value' descriptor has type(s) ['str']. The output descriptor type must match the "
+        "declared FinalOutputNode output type."
+    )
+
+
+def test_final_output_node__matching_output_type_should_pass_validation():
+    # GIVEN a FinalOutputNode declared with correct matching types
+    class CorrectOutput(FinalOutputNode[BaseState, str]):
+        """Output with correct type matching."""
+
+        class Outputs(FinalOutputNode.Outputs):
+            value = InlinePromptNode.Outputs.text
+
+    # WHEN attempting to validate the node class
+    # THEN validation should pass without raising an exception
+    try:
+        CorrectOutput.__validate__()
+    except ValueError:
+        pytest.fail("Validation should not raise an exception for correct type matching")
+
+
+def test_final_output_node__dict_and_Dict_should_be_compatible():
+    """
+    Tests that FinalOutputNode validation recognizes dict and Dict[str, Any] as compatible types.
+    """
+
+    # GIVEN a FinalOutputNode declared with dict output type
+    # AND the value descriptor has Dict[str, Any] type
+    class DictOutputNode(FinalOutputNode[BaseState, dict]):
+        """Output with dict type."""
+
+        class Outputs(FinalOutputNode.Outputs):
+            value = OutputReference(
+                name="value",
+                types=(Dict[str, Any],),
+                instance=None,
+                outputs_class=FinalOutputNode.Outputs,
+            )
+
+    # WHEN attempting to validate the node class
+    # THEN validation should pass without raising an exception
+    try:
+        DictOutputNode.__validate__()
+    except ValueError as e:
+        pytest.fail(f"Validation should not raise an exception for dict/Dict compatibility: {e}")
+
+
+def test_final_output_node__any_output_type_should_accept_json():
+    """
+    Tests that FinalOutputNode with Any output type accepts a TemplatingNode with Json output type.
+    """
+
+    # GIVEN a TemplatingNode with Json output type
+    class JsonTemplatingNode(TemplatingNode[BaseState, Json]):
+        """Templating node that outputs Json."""
+
+        template = '{"key": "value"}'
+
+    # AND a FinalOutputNode with Any output type referencing the TemplatingNode
+    class AnyOutputNode(FinalOutputNode[BaseState, Any]):
+        """Output with Any type."""
+
+        class Outputs(FinalOutputNode.Outputs):
+            value = JsonTemplatingNode.Outputs.result
+
+    # WHEN attempting to validate the node class
+    # THEN validation should pass without raising an exception
+    try:
+        AnyOutputNode.__validate__()
+    except ValueError as e:
+        pytest.fail(f"Validation should not raise an exception when Any accepts Json: {e}")

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

@@ -3,12 +3,11 @@ from typing import Any, ClassVar, Dict, Generic, List, Optional, Union, cast
 
 from vellum import ChatHistoryInput, ChatMessage, JsonInput, MetricDefinitionInput, NumberInput, StringInput
 from vellum.client import ApiError
-from vellum.core import RequestOptions
+from vellum.client.core import RequestOptions
 from vellum.workflows.constants import LATEST_RELEASE_TAG
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases import BaseNode
-from vellum.workflows.outputs.base import BaseOutputs
 from vellum.workflows.types.core import EntityInputsInterface, MergeBehavior
 from vellum.workflows.types.generics import StateType
 
@@ -23,6 +22,10 @@ class GuardrailNode(BaseNode[StateType], Generic[StateType]):
     request_options: Optional[RequestOptions] - The request options to use for the Metric
     """
 
+    class Display(BaseNode.Display):
+        icon = "vellum:icon:shield-check"
+        color = "rose"
+
     metric_definition: ClassVar[Union[UUID, str]]
 
     metric_inputs: ClassVar[EntityInputsInterface] = {}
@@ -33,7 +36,7 @@ class GuardrailNode(BaseNode[StateType], Generic[StateType]):
     class Trigger(BaseNode.Trigger):
         merge_behavior = MergeBehavior.AWAIT_ANY
 
-    class Outputs(BaseOutputs):
+    class Outputs(BaseNode.Outputs):
         score: float
         normalized_score: Optional[float]
         log: Optional[str]
@@ -98,7 +101,13 @@ class GuardrailNode(BaseNode[StateType], Generic[StateType]):
         else:
             reason = None
 
-        return self.Outputs(score=score, normalized_score=normalized_score, log=log, reason=reason, **metric_outputs)
+        return self.Outputs(
+            score=score,
+            normalized_score=normalized_score,
+            log=log,
+            reason=reason,
+            **metric_outputs,  # type: ignore [arg-type]
+        )
 
     def _compile_metric_inputs(self) -> List[MetricDefinitionInput]:
         # TODO: We may want to consolidate with prompt deployment input compilation

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

@@ -1,16 +1,16 @@
-import json
-from typing import Any, Dict, Iterator, Type, Union
+from typing import Any, Dict, Generic, Iterator, Type, Union
 
 from vellum.workflows.constants import undefined
 from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.displayable.bases import BaseInlinePromptNode as BaseInlinePromptNode
+from vellum.workflows.nodes.displayable.bases.utils import process_additional_prompt_outputs
 from vellum.workflows.outputs import BaseOutput
 from vellum.workflows.types import MergeBehavior
 from vellum.workflows.types.generics import StateType
 
 
-class InlinePromptNode(BaseInlinePromptNode[StateType]):
+class InlinePromptNode(BaseInlinePromptNode[StateType], Generic[StateType]):
     """
     Used to execute a Prompt defined inline.
 
@@ -23,6 +23,10 @@ class InlinePromptNode(BaseInlinePromptNode[StateType]):
     request_options: Optional[RequestOptions] - The request options to use for the Prompt Execution
     """
 
+    class Display(BaseInlinePromptNode.Display):
+        icon = "vellum:icon:text-size"
+        color = "navy"
+
     class Trigger(BaseInlinePromptNode.Trigger):
         merge_behavior = MergeBehavior.AWAIT_ANY
 
@@ -45,39 +49,8 @@ class InlinePromptNode(BaseInlinePromptNode[StateType]):
                 code=WorkflowErrorCode.INTERNAL_ERROR,
             )
 
-        string_outputs = []
-        json_output = None
-
-        should_parse_json = False
-        if hasattr(self, "parameters"):
-            custom_params = self.parameters.custom_parameters
-            if custom_params and isinstance(custom_params, dict):
-                json_schema = custom_params.get("json_schema", {})
-                if (isinstance(json_schema, dict) and "schema" in json_schema) or custom_params.get("json_mode", {}):
-                    should_parse_json = True
-
-        for output in outputs:
-            if output.value is None:
-                continue
-
-            if output.type == "STRING":
-                string_outputs.append(output.value)
-                if should_parse_json:
-                    try:
-                        parsed_json = json.loads(output.value)
-                        json_output = parsed_json
-                    except (json.JSONDecodeError, TypeError):
-                        pass
-            elif output.type == "JSON":
-                string_outputs.append(json.dumps(output.value, indent=4))
-                json_output = output.value
-            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)
+        text_output, json_output = process_additional_prompt_outputs(outputs)
+        yield BaseOutput(name="text", value=text_output)
 
         if json_output:
             yield BaseOutput(name="json", value=json_output)

vellum/workflows/nodes/displayable/inline_prompt_node/tests/test_node.py

@@ -197,6 +197,9 @@ def test_inline_prompt_node__api_error__invalid_inputs_node_exception(
     assert e.value.code == expected_code
     assert e.value.message == expected_message
 
+    # AND the node exception includes the response body in raw_data
+    assert e.value.raw_data == exception.body
+
 
 def test_inline_prompt_node__chat_history_inputs(vellum_adhoc_prompt_client):
     # GIVEN a prompt node with a chat history input

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

@@ -1,12 +1,19 @@
+from typing import Generic
+
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.types import MergeBehavior
+from vellum.workflows.types.generics import StateType
 
 
-class MergeNode(BaseNode):
+class MergeNode(BaseNode[StateType], Generic[StateType]):
     """
     Used to merge the control flow of multiple nodes into a single node. This node exists to be backwards compatible
     with Vellum's Merge Node, and for most cases, you should extend from `BaseNode.Trigger` directly.
     """
 
+    class Display(BaseNode.Display):
+        icon = "vellum:icon:merge"
+        color = "tomato"
+
     class Trigger(BaseNode.Trigger):
         merge_behavior = MergeBehavior.AWAIT_ANY

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

@@ -1,12 +1,19 @@
+from typing import Generic
+
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.types import MergeBehavior
+from vellum.workflows.types.generics import StateType
 
 
-class NoteNode(BaseNode):
+class NoteNode(BaseNode[StateType], Generic[StateType]):
     """
     A no-op Node purely used to display a note in the Vellum UI.
     """
 
+    class Display(BaseNode.Display):
+        icon = "vellum:icon:note"
+        color = "cyan"
+
     class Trigger(BaseNode.Trigger):
         merge_behavior = MergeBehavior.AWAIT_ANY
 

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

@@ -1,10 +1,10 @@
-import json
 from typing import Any, Dict, Iterator, Type, Union
 
 from vellum.workflows.constants import undefined
 from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.displayable.bases import BasePromptDeploymentNode as BasePromptDeploymentNode
+from vellum.workflows.nodes.displayable.bases.utils import process_additional_prompt_outputs
 from vellum.workflows.outputs import BaseOutput
 from vellum.workflows.types import MergeBehavior
 from vellum.workflows.types.generics import StateType
@@ -26,6 +26,10 @@ class PromptDeploymentNode(BasePromptDeploymentNode[StateType]):
     request_options: Optional[RequestOptions] - The request options to use for the Prompt Execution
     """
 
+    class Display(BasePromptDeploymentNode.Display):
+        icon = "vellum:icon:text-size"
+        color = "navy"
+
     class Trigger(BasePromptDeploymentNode.Trigger):
         merge_behavior = MergeBehavior.AWAIT_ANY
 
@@ -48,28 +52,8 @@ class PromptDeploymentNode(BasePromptDeploymentNode[StateType]):
                 code=WorkflowErrorCode.INTERNAL_ERROR,
             )
 
-        string_outputs = []
-        json_output = None
-
-        for output in outputs:
-            if output.value is None:
-                continue
-
-            if output.type == "STRING":
-                string_outputs.append(output.value)
-                try:
-                    json_output = json.loads(output.value)
-                except (json.JSONDecodeError, TypeError):
-                    pass
-            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)
+        text_output, json_output = process_additional_prompt_outputs(outputs)
+        yield BaseOutput(name="text", value=text_output)
 
         if json_output:
             yield BaseOutput(name="json", value=json_output)

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

@@ -1,8 +1,11 @@
 import json
 from typing import ClassVar
 
+from vellum.utils.json_encoder import VellumJsonEncoder
+from vellum.workflows.constants import undefined
+from vellum.workflows.errors import WorkflowErrorCode
+from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.displayable.bases import BaseSearchNode as BaseSearchNode
-from vellum.workflows.state.encoder import DefaultStateEncoder
 from vellum.workflows.types import MergeBehavior
 from vellum.workflows.types.generics import StateType
 
@@ -19,6 +22,10 @@ class SearchNode(BaseSearchNode[StateType]):
     chunk_separator: str = "\n\n#####\n\n" - The separator to use when joining the text of each search result
     """
 
+    class Display(BaseSearchNode.Display):
+        icon = "vellum:icon:magnifying-glass-waveform"
+        color = "purple"
+
     chunk_separator: ClassVar[str] = "\n\n#####\n\n"
 
     class Trigger(BaseSearchNode.Trigger):
@@ -35,8 +42,14 @@ class SearchNode(BaseSearchNode[StateType]):
         text: str
 
     def run(self) -> Outputs:
+        if self.query is undefined or self.query is None or self.query == "":
+            raise NodeException(
+                message="Search query is required but was not provided",
+                code=WorkflowErrorCode.INVALID_INPUTS,
+            )
+
         if not isinstance(self.query, str):
-            self.query = json.dumps(self.query, cls=DefaultStateEncoder)
+            self.query = json.dumps(self.query, cls=VellumJsonEncoder)
 
         results = self._perform_search().results
         text = self.chunk_separator.join([r.text for r in results])

vellum/workflows/nodes/displayable/search_node/tests/test_node.py

@@ -1,3 +1,4 @@
+import pytest
 import json
 
 from vellum import SearchResponse, SearchResult, SearchResultDocument
@@ -10,6 +11,8 @@ from vellum.client.types.search_weights_request import SearchWeightsRequest
 from vellum.client.types.string_vellum_value_request import StringVellumValueRequest
 from vellum.client.types.vellum_value_logical_condition_group_request import VellumValueLogicalConditionGroupRequest
 from vellum.client.types.vellum_value_logical_condition_request import VellumValueLogicalConditionRequest
+from vellum.workflows.errors import WorkflowErrorCode
+from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.displayable.bases.types import (
     MetadataLogicalCondition,
     MetadataLogicalConditionGroup,
@@ -215,3 +218,33 @@ def test_run_workflow__chat_history_as_query(vellum_client):
     assert json.loads(vellum_client.search.call_args.kwargs["query"]) == [
         {"role": "USER", "text": "Hello, world!", "source": None, "content": None}
     ]
+
+
+@pytest.mark.parametrize("invalid_query", [None, ""])
+def test_run_workflow__invalid_query_raises_validation_error(invalid_query):
+    """Confirm that missing/None/empty query raises proper user-facing validation error"""
+
+    class MySearchNode(SearchNode):
+        query = invalid_query  # type: ignore[assignment]
+        document_index = "document_index"
+
+    with pytest.raises(NodeException) as exc_info:
+        MySearchNode().run()
+
+    assert exc_info.value.code == WorkflowErrorCode.INVALID_INPUTS
+    assert "query" in exc_info.value.message.lower()
+    assert "required" in exc_info.value.message.lower() or "missing" in exc_info.value.message.lower()
+
+
+def test_run_workflow__missing_query_attribute_raises_validation_error():
+    """Confirm that a SearchNode without a query attribute defined raises INVALID_INPUTS"""
+
+    class MySearchNode(SearchNode):
+        document_index = "document_index"
+
+    with pytest.raises(NodeException) as exc_info:
+        MySearchNode().run()
+
+    assert exc_info.value.code == WorkflowErrorCode.INVALID_INPUTS
+    assert "query" in exc_info.value.message.lower()
+    assert "required" in exc_info.value.message.lower()

vellum/workflows/nodes/displayable/set_state_node/__init__.py

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

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

@@ -0,0 +1,71 @@
+from typing import Any, ClassVar, Dict, Generic
+
+from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.utils import resolve_value
+from vellum.workflows.errors import WorkflowErrorCode
+from vellum.workflows.exceptions import NodeException
+from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.outputs import BaseOutputs
+from vellum.workflows.types.generics import StateType
+
+
+class SetStateNode(BaseNode[StateType], Generic[StateType]):
+    """
+    A node that sets multiple state values at once.
+
+    This node accepts a dictionary mapping state paths to values and sets them all.
+    Values can be actual values or descriptors.
+
+    Example:
+        operations = {
+            "chat_history": State.chat_history.concat(LazyReference("MyAgentNode.Outputs.chat_history")),
+            "counter": State.counter + 1,
+            "total_tokens": State.user_tokens.add(State.assistant_tokens)
+        }
+
+    Args:
+        operations: Dictionary mapping state attribute names to values (descriptors or actual values)
+    """
+
+    # Dictionary mapping state paths to values
+    operations: ClassVar[Dict[str, Any]] = {}
+
+    class Outputs(BaseOutputs):
+        """
+        The outputs of the SetStateNode.
+
+        result: Dict[str, Any] - Dictionary of all state updates
+        """
+
+        results: Dict[str, Any]
+
+    def run(self) -> Outputs:
+        """
+        Run the node and set all the state values.
+        Resolves descriptors to their actual values before setting state.
+        """
+        # First pass: validate and resolve all operations without mutating state
+        resolved_updates: Dict[str, Any] = {}
+        for path, value in self.operations.items():
+            # Validate the state attribute exists prior to any mutation
+            if not hasattr(self.state, path):
+                raise NodeException(
+                    f"State does not have attribute '{path}'. "
+                    f"Only existing state attributes can be set via SetStateNode.",
+                    code=WorkflowErrorCode.INVALID_STATE,
+                )
+
+            # Resolve the value if it's a descriptor against the current (unmodified) state
+            if isinstance(value, BaseDescriptor):
+                resolved_value = resolve_value(value, self.state)
+            else:
+                resolved_value = value
+
+            resolved_updates[path] = resolved_value
+
+        # Second pass: apply the resolved updates to the state atomically
+        with self.state.__atomic__():
+            for path, resolved_value in resolved_updates.items():
+                setattr(self.state, path, resolved_value)
+
+        return self.Outputs(results=resolved_updates)