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

vellum/client/core/client_wrapper.py

@@ -18,7 +18,7 @@ class BaseClientWrapper:
         headers: typing.Dict[str, str] = {
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "0.14.61",
+            "X-Fern-SDK-Version": "0.14.63",
         }
         headers["X-API-KEY"] = self.api_key
         return headers

vellum/workflows/errors/types.py

@@ -1,5 +1,6 @@
 from dataclasses import dataclass
 from enum import Enum
+import logging
 from typing import Any, Dict
 
 from vellum.client.types.vellum_error import VellumError
@@ -7,6 +8,8 @@ from vellum.client.types.vellum_error_code_enum import VellumErrorCodeEnum
 from vellum.client.types.workflow_event_error import WorkflowEventError
 from vellum.client.types.workflow_execution_event_error_code import WorkflowExecutionEventErrorCode
 
+logger = logging.getLogger(__name__)
+
 
 class WorkflowErrorCode(Enum):
     INVALID_WORKFLOW = "INVALID_WORKFLOW"
@@ -43,9 +46,15 @@ _VELLUM_ERROR_CODE_TO_WORKFLOW_ERROR_CODE: Dict[VellumErrorCodeEnum, WorkflowErr
 
 
 def vellum_error_to_workflow_error(error: VellumError) -> WorkflowError:
+    workflow_error_code = _VELLUM_ERROR_CODE_TO_WORKFLOW_ERROR_CODE.get(error.code)
+
+    if workflow_error_code is None:
+        logger.warning(f"Unknown Vellum error code '{error.code}' encountered. Falling back to INTERNAL_ERROR.")
+        workflow_error_code = WorkflowErrorCode.INTERNAL_ERROR
+
     return WorkflowError(
         message=error.message,
-        code=_VELLUM_ERROR_CODE_TO_WORKFLOW_ERROR_CODE.get(error.code, WorkflowErrorCode.INTERNAL_ERROR),
+        code=workflow_error_code,
     )
 
 
@@ -57,6 +66,7 @@ _WORKFLOW_EVENT_ERROR_CODE_TO_WORKFLOW_ERROR_CODE: Dict[WorkflowExecutionEventEr
     "NODE_EXECUTION": WorkflowErrorCode.NODE_EXECUTION,
     "LLM_PROVIDER": WorkflowErrorCode.PROVIDER_ERROR,
     "INVALID_CODE": WorkflowErrorCode.INVALID_CODE,
+    "INVALID_INPUTS": WorkflowErrorCode.INVALID_INPUTS,
     "INVALID_TEMPLATE": WorkflowErrorCode.INVALID_TEMPLATE,
     "USER_DEFINED_ERROR": WorkflowErrorCode.USER_DEFINED_ERROR,
 }

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

@@ -193,6 +193,10 @@ class BaseInlinePromptNode(BasePromptNode[StateType], Generic[StateType]):
             return input_variables, input_values
 
         for input_name, input_value in self.prompt_inputs.items():
+            # Exclude inputs that resolved to be null. This ensure that we don't pass input values
+            # to optional prompt inputs whose values were unresolved.
+            if input_value is None:
+                continue
             if isinstance(input_value, str):
                 input_variables.append(
                     VellumVariable(

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

@@ -171,6 +171,10 @@ class BasePromptDeploymentNode(BasePromptNode, Generic[StateType]):
             return compiled_inputs
 
         for input_name, input_value in self.prompt_inputs.items():
+            # Exclude inputs that resolved to be null. This ensure that we don't pass input values
+            # to optional prompt inputs whose values were unresolved.
+            if input_value is None:
+                continue
             if isinstance(input_value, str):
                 compiled_inputs.append(
                     StringInputRequest(

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

@@ -27,6 +27,7 @@ from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.bases.base import BaseNodeMeta
+from vellum.workflows.nodes.displayable.bases.utils import primitive_to_vellum_value
 from vellum.workflows.nodes.displayable.code_execution_node.utils import read_file_from_path, run_code_inline
 from vellum.workflows.outputs.base import BaseOutputs
 from vellum.workflows.types.core import EntityInputsInterface, MergeBehavior, VellumSecret
@@ -169,10 +170,13 @@ class CodeExecutionNode(BaseNode[StateType], Generic[StateType, _OutputType], me
                         )
                     )
                 else:
+                    # Convert primitive values to VellumValue objects
+                    vellum_values: List[VellumValue] = [primitive_to_vellum_value(item) for item in input_value]
+
                     compiled_inputs.append(
                         ArrayInput(
                             name=input_name,
-                            value=cast(List[VellumValue], input_value),
+                            value=vellum_values,
                         )
                     )
             elif isinstance(input_value, dict):

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

@@ -5,7 +5,7 @@ from typing import Any, List, Union
 
 from pydantic import BaseModel
 
-from vellum import CodeExecutorResponse, NumberVellumValue, StringInput, StringVellumValue
+from vellum import ArrayInput, CodeExecutorResponse, NumberVellumValue, StringInput, StringVellumValue
 from vellum.client.errors.bad_request_error import BadRequestError
 from vellum.client.types.chat_message import ChatMessage
 from vellum.client.types.code_execution_package import CodeExecutionPackage
@@ -1099,7 +1099,7 @@ def test_run_node__iter_dict():
     class ExampleCodeExecutionNode(CodeExecutionNode[BaseState, list[str]]):
         code = """\
 def main(input_dict: dict) -> list[str]:
-    return [item.value for item in input_dict]
+    return [item.value for item in input_dict.values()]
 """
         runtime = "PYTHON_3_11_6"
         code_inputs = {
@@ -1167,3 +1167,69 @@ def main(input: str) -> str:
 
     # THEN the node should return default function call
     assert outputs == {"result": FunctionCall(name="", arguments={}), "log": ""}
+
+
+def test_run_node__array_input_with_primitive_values(vellum_client):
+    # GIVEN a node that subclasses CodeExecutionNode that processes an array of primitive values
+    class State(BaseState):
+        pass
+
+    class ExampleCodeExecutionNode(CodeExecutionNode[State, str]):
+        code = """\
+from typing import List
+def main(numbers: List[str]) -> str:
+    return " ".join(numbers)
+"""
+        runtime = "PYTHON_3_11_6"
+        packages = [
+            CodeExecutionPackage(
+                name="openai",
+                version="1.0.0",
+            )
+        ]
+
+        code_inputs = {
+            "numbers": ["6", "4", "2"],
+        }
+
+    # AND we know what the Code Execution Node will respond with
+    mock_code_execution = CodeExecutorResponse(
+        log="",
+        output=StringVellumValue(value="6 4 2"),
+    )
+    vellum_client.execute_code.return_value = mock_code_execution
+
+    # WHEN we run the node
+    node = ExampleCodeExecutionNode(state=State())
+    outputs = node.run()
+
+    # THEN the node should have produced the outputs we expect
+    assert outputs == {"result": "6 4 2", "log": ""}
+
+    # AND we should have invoked the Code with the expected inputs
+    vellum_client.execute_code.assert_called_once_with(
+        input_values=[
+            ArrayInput(
+                name="numbers",
+                value=[
+                    StringVellumValue(value="6"),
+                    StringVellumValue(value="4"),
+                    StringVellumValue(value="2"),
+                ],
+            )
+        ],
+        code="""\
+from typing import List
+def main(numbers: List[str]) -> str:
+    return " ".join(numbers)
+""",
+        runtime="PYTHON_3_11_6",
+        output_type="STRING",
+        packages=[
+            CodeExecutionPackage(
+                name="openai",
+                version="1.0.0",
+            )
+        ],
+        request_options=None,
+    )

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

@@ -468,3 +468,28 @@ def test_prompt_deployment_node__parent_context_serialization(mock_httpx_transpo
     request_execution_context = json.loads(call_request_args.read().decode("utf-8"))["execution_context"]
     assert request_execution_context["trace_id"] == str(trace_id)
     assert request_execution_context["parent_context"]
+
+
+def test_run_workflow__missing_required_input(vellum_client):
+    """Confirm that we get an error when a required input is not provided to a Subworkflow Deployment Node"""
+
+    # GIVEN a Subworkflow Deployment Node missing a required input
+    class ExampleSubworkflowDeploymentNode(SubworkflowDeploymentNode):
+        deployment = "example_subworkflow_deployment"
+        subworkflow_inputs = {}
+
+    # AND the Subworkflow Deployment API call fails due to missing required input
+    vellum_client.execute_workflow_stream.side_effect = ApiError(
+        status_code=400, body={"detail": "Missing required input for 'my_var_1'"}
+    )
+
+    # WHEN we run the node
+    node = ExampleSubworkflowDeploymentNode()
+
+    # THEN we should get a NodeException for invalid inputs
+    with pytest.raises(NodeException) as exc_info:
+        list(node.run())
+
+    # AND the error should indicate the missing required input
+    assert exc_info.value.code == WorkflowErrorCode.INVALID_INPUTS
+    assert exc_info.value.message == "Missing required input for 'my_var_1'"

vellum/workflows/nodes/experimental/tool_calling_node/node.py

@@ -1,9 +1,10 @@
 from collections.abc import Callable
-from typing import Any, ClassVar, List, Optional
+from typing import Any, ClassVar, Dict, List, Optional, cast
 
 from pydash import snake_case
 
 from vellum import ChatMessage, PromptBlock
+from vellum.client.types.code_execution_package import CodeExecutionPackage
 from vellum.workflows.context import execution_context, get_parent_context
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
@@ -28,14 +29,16 @@ class ToolCallingNode(BaseNode):
         functions: List[FunctionDefinition] - The functions that can be called
         function_callables: List[Callable] - The callables that can be called
         prompt_inputs: Optional[EntityInputsInterface] - Mapping of input variable names to values
+        function_packages: Optional[Dict[Callable, List[CodeExecutionPackage]]] - Mapping of functions to their packages
+        runtime: str - The runtime to use for code execution (default: "PYTHON_3_11_6")
     """
 
     ml_model: ClassVar[str] = "gpt-4o-mini"
     blocks: ClassVar[List[PromptBlock]] = []
     functions: ClassVar[List[Callable[..., Any]]] = []
     prompt_inputs: ClassVar[Optional[EntityInputsInterface]] = None
-    # TODO: https://linear.app/vellum/issue/APO-342/support-tool-call-max-retries
-    max_tool_calls: ClassVar[int] = 1
+    function_packages: ClassVar[Optional[Dict[Callable[..., Any], List[CodeExecutionPackage]]]] = None
+    runtime: ClassVar[str] = "PYTHON_3_11_6"
 
     class Outputs(BaseOutputs):
         """
@@ -102,13 +105,21 @@ class ToolCallingNode(BaseNode):
             prompt_inputs=self.prompt_inputs,
         )
 
-        self._function_nodes = {
-            snake_case(function.__name__): create_function_node(
+        self._function_nodes = {}
+        for function in self.functions:
+            function_name = snake_case(function.__name__)
+            # Get packages for this function if specified
+            packages = None
+            if self.function_packages and function in self.function_packages:
+                # Cast to tell mypy this is a plain list, not a descriptor
+                packages = cast(List[CodeExecutionPackage], self.function_packages[function])
+
+            self._function_nodes[function_name] = create_function_node(
                 function=function,
                 tool_router_node=self.tool_router_node,
+                packages=packages,
+                runtime=self.runtime,
             )
-            for function in self.functions
-        }
 
         graph_set = set()
 

vellum/workflows/nodes/experimental/tool_calling_node/utils.py

@@ -1,10 +1,13 @@
 from collections.abc import Callable
+import inspect
 import json
+import types
 from typing import Any, Iterator, List, Optional, Type, cast
 
 from pydash import snake_case
 
 from vellum import ChatMessage, PromptBlock
+from vellum.client.types.code_execution_package import CodeExecutionPackage
 from vellum.client.types.function_call_chat_message_content import FunctionCallChatMessageContent
 from vellum.client.types.function_call_chat_message_content_value import FunctionCallChatMessageContentValue
 from vellum.client.types.string_chat_message_content import StringChatMessageContent
@@ -13,10 +16,12 @@ from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases import BaseNode
+from vellum.workflows.nodes.displayable.code_execution_node.node import CodeExecutionNode
 from vellum.workflows.nodes.displayable.inline_prompt_node.node import InlinePromptNode
 from vellum.workflows.outputs.base import BaseOutput
 from vellum.workflows.ports.port import Port
 from vellum.workflows.references.lazy import LazyReference
+from vellum.workflows.state.base import BaseState
 from vellum.workflows.state.encoder import DefaultStateEncoder
 from vellum.workflows.types.core import EntityInputsInterface, MergeBehavior
 from vellum.workflows.types.generics import is_workflow_class
@@ -117,26 +122,35 @@ def create_tool_router_node(
             },
         ),
     )
-
     return node
 
 
-def create_function_node(function: Callable[..., Any], tool_router_node: Type[ToolRouterNode]) -> Type[FunctionNode]:
+def create_function_node(
+    function: Callable[..., Any],
+    tool_router_node: Type[ToolRouterNode],
+    packages: Optional[List[CodeExecutionPackage]] = None,
+    runtime: str = "PYTHON_3_11_6",
+) -> Type[FunctionNode]:
     """
     Create a FunctionNode class for a given function.
 
-    This ensures the callable is properly registered and can be called with the expected arguments.
+    For workflow functions: BaseNode
+    For regular functions: CodeExecutionNode with embedded function
+    Args:
+        function: The function to create a node for
+        tool_router_node: The tool router node class
+        packages: Optional list of packages to install for code execution (only used for regular functions)
+        runtime: The runtime to use for code execution (default: "PYTHON_3_11_6")
     """
 
-    # Create a class-level wrapper that calls the original function
-    def execute_function(self) -> BaseNode.Outputs:
-        outputs = self.state.meta.node_outputs.get(tool_router_node.Outputs.text)
-        # first parse into json
-        outputs = json.loads(outputs)
-        arguments = outputs["arguments"]
+    if is_workflow_class(function):
+
+        def execute_function(self) -> BaseNode.Outputs:
+            outputs = self.state.meta.node_outputs.get(tool_router_node.Outputs.text)
+            # first parse into json
+            outputs = json.loads(outputs)
+            arguments = outputs["arguments"]
 
-        # Call the function based on its type
-        if is_workflow_class(function):
             # Dynamically define an Inputs subclass of BaseInputs
             Inputs = type(
                 "Inputs",
@@ -160,26 +174,86 @@ def create_function_node(function: Callable[..., Any], tool_router_node: Type[To
                 result = terminal_event.outputs
             elif terminal_event.name == "workflow.execution.rejected":
                 raise Exception(f"Workflow execution rejected: {terminal_event.error}")
-        else:
-            # If it's a regular callable, call it directly
-            result = function(**arguments)
-
-        self.state.chat_history.append(
-            ChatMessage(
-                role="FUNCTION",
-                content=StringChatMessageContent(value=json.dumps(result, cls=DefaultStateEncoder)),
+
+            self.state.chat_history.append(
+                ChatMessage(
+                    role="FUNCTION",
+                    content=StringChatMessageContent(value=json.dumps(result, cls=DefaultStateEncoder)),
+                )
             )
+
+            return self.Outputs()
+
+        # Create BaseNode for workflow functions
+        node = type(
+            f"InlineWorkflowNode_{function.__name__}",
+            (FunctionNode,),
+            {
+                "run": execute_function,
+                "__module__": __name__,
+            },
         )
+    else:
+        # For regular functions, use CodeExecutionNode approach
+        function_source = inspect.getsource(function)
+        function_name = function.__name__
 
-        return self.Outputs()
+        _code = f'''
+{function_source}
 
-    node = type(
-        f"FunctionNode_{function.__name__}",
-        (FunctionNode,),
-        {
-            "run": execute_function,
-            "__module__": __name__,
-        },
-    )
+def main(arguments):
+    """Main function that calls the original function with the provided arguments."""
+    return {function_name}(**arguments)
+'''
+        _packages = packages
+        _tool_router_node = tool_router_node
+        _runtime = runtime
+
+        def execute_code_execution_function(self) -> BaseNode.Outputs:
+            # Get the function call from the tool router output
+            function_call_output = self.state.meta.node_outputs.get(_tool_router_node.Outputs.results)
+            if function_call_output and len(function_call_output) > 0:
+                function_call = function_call_output[0]
+                arguments = function_call.value.arguments
+            else:
+                arguments = {}
+
+            self.code_inputs = {"arguments": arguments}
+
+            outputs = base_class.run(self)
+
+            self.state.chat_history.append(
+                ChatMessage(
+                    role="FUNCTION",
+                    content=StringChatMessageContent(value=json.dumps(outputs.result, cls=DefaultStateEncoder)),
+                )
+            )
+
+            return self.Outputs()
+
+        # Create the properly typed base class with explicit type annotation
+        def get_function_output_type() -> Type:
+            return function.__annotations__.get("return", Any)
+
+        output_type = get_function_output_type()
+
+        base_class: Type[CodeExecutionNode] = CodeExecutionNode[BaseState, output_type]  # type: ignore[valid-type]
+
+        # Create the class with basic attributes
+        node = types.new_class(
+            f"CodeExecutionNode_{function.__name__}",
+            (base_class,),
+            {},
+            lambda ns: ns.update(
+                {
+                    "code": _code,
+                    "code_inputs": {},  # No inputs needed since we handle function call extraction in run()
+                    "run": execute_code_execution_function,
+                    "runtime": _runtime,
+                    "packages": _packages,
+                    "__module__": __name__,
+                }
+            ),
+        )
 
     return node

vellum/workflows/types/code_execution_node_wrappers.py

@@ -82,10 +82,6 @@ class DictWrapper(dict):
     def __setattr__(self, name, value):
         self[name] = value
 
-    def __iter__(self):
-        for key in super().keys():
-            yield self[key]
-
 
 def clean_for_dict_wrapper(obj):
     if isinstance(obj, dict):

{vellum_ai-0.14.61.dist-info → vellum_ai-0.14.63.dist-info}/METADATA

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

{vellum_ai-0.14.61.dist-info → vellum_ai-0.14.63.dist-info}/RECORD

@@ -45,7 +45,7 @@ vellum_ee/workflows/display/nodes/vellum/inline_subworkflow_node.py,sha256=fQV5o
 vellum_ee/workflows/display/nodes/vellum/map_node.py,sha256=CiklGf5_tDbqE1XQm2mnbtoL01_2JYjcnB4FDTpMImQ,3824
 vellum_ee/workflows/display/nodes/vellum/merge_node.py,sha256=yBWeN4T_lOsDVnNOKWRiT7JYKu0IR5Fx2z99iq6QKSA,3273
 vellum_ee/workflows/display/nodes/vellum/note_node.py,sha256=3E0UqmgVYdtbj4nyq8gKju8EpMsRHMCQ0KLrJhug3XU,1084
-vellum_ee/workflows/display/nodes/vellum/prompt_deployment_node.py,sha256=dVb3ONkuovK8xE5MdDLVSBCoZoKPrCnhdcWLYcl14mw,3307
+vellum_ee/workflows/display/nodes/vellum/prompt_deployment_node.py,sha256=1NxFddxWCFtMe_je1cutP7qnoASoG94LJqKhRkoQwvw,3535
 vellum_ee/workflows/display/nodes/vellum/retry_node.py,sha256=X3xnlAU5JisL0jRvaG_V9RvTF7ZlGufTO8tXLLVhGIg,3280
 vellum_ee/workflows/display/nodes/vellum/search_node.py,sha256=3n1qa-zWIk0p_H94u0hjfDtGkanldC6EXVhg0xgLmE4,9544
 vellum_ee/workflows/display/nodes/vellum/subworkflow_deployment_node.py,sha256=MWLZBXHsmj5vKgqOgI2HHcHAJzLS0sqybn6idhwug8Y,2669
@@ -59,7 +59,7 @@ vellum_ee/workflows/display/nodes/vellum/tests/test_prompt_node.py,sha256=TtzUj3
 vellum_ee/workflows/display/nodes/vellum/tests/test_retry_node.py,sha256=h93ysolmbo2viisyhRnXKHPxiDK0I_dSAbYoHFYIoO4,1953
 vellum_ee/workflows/display/nodes/vellum/tests/test_subworkflow_deployment_node.py,sha256=BUzHJgjdWnPeZxjFjHfDBKnbFjYjnbXPjc-1hne1B2Y,3965
 vellum_ee/workflows/display/nodes/vellum/tests/test_templating_node.py,sha256=LSk2gx9TpGXbAqKe8dggQW8yJZqj-Cf0EGJFeGGlEcw,3321
-vellum_ee/workflows/display/nodes/vellum/tests/test_tool_calling_node.py,sha256=NewHcTseNE2ogPzEDJ6KEDD9EYLn9RBZIClMwijIs0I,4581
+vellum_ee/workflows/display/nodes/vellum/tests/test_tool_calling_node.py,sha256=fvatG73wpHU4CN29YFchvir8K4uLEPMsVhvssehNJ7I,7651
 vellum_ee/workflows/display/nodes/vellum/tests/test_try_node.py,sha256=Khjsb53PKpZuyhKoRMgKAL45eGp5hZqXvHmVeQWRw4w,2289
 vellum_ee/workflows/display/nodes/vellum/tests/test_utils.py,sha256=3LS1O4DGPWit05oj_ubeW8AlHGnoBxdUMferGQuAiZs,4851
 vellum_ee/workflows/display/nodes/vellum/try_node.py,sha256=z9Omo676RRc7mQjLoL7hjiHhUj0OWVLhrrb97YTN4QA,4086
@@ -85,18 +85,18 @@ vellum_ee/workflows/display/tests/workflow_serialization/test_basic_inline_promp
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_inline_subworkflow_serialization.py,sha256=u2nquKoO3o2xIkU_uFPOb_s5YoLmULiq09vb6Ee0Cqw,21415
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_map_node_serialization.py,sha256=3gZuNM8sT6ovVaeoAvd2JoyKwuxokvowlhH8kwDUoZ8,16559
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_merge_node_serialization.py,sha256=IIJt7YZBzkhNtbmaMwCX4ENs58QtSIIoBHlMR6OwGU8,8342
-vellum_ee/workflows/display/tests/workflow_serialization/test_basic_prompt_deployment_serialization.py,sha256=mLr_1Ow5NZYSLzzEZPup14LckuT8ivOvq9Lz85pGj0c,8602
+vellum_ee/workflows/display/tests/workflow_serialization/test_basic_prompt_deployment_serialization.py,sha256=QXiRjwtiTPeMUl40Pvh_geeU99C3mv1aVS85oeIUwY4,21052
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_search_node_serialization.py,sha256=K0mECBUyTNX4I468goeaRf93N7Qfizoc1ctCH5_nNys,12936
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_subworkflow_deployment_serialization.py,sha256=KkYZc_bZuq1lmDcvUz3QxIqJLpQPCZioD1FHUNsMJY8,11211
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_templating_node_serialization.py,sha256=aZaqRDrkO3ytcmdM2eKJqHSt60MF070NMj6M2vgzOKc,7711
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_terminal_node_serialization.py,sha256=r748dpS13HtwY7t_KQFExFssxRy0xI2d-wxmhiUHRe0,3850
-vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_serialization.py,sha256=RPv0bJGwgzBDK_f16VrplPjSZbTisANSH08BGzaHwmk,8341
+vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_serialization.py,sha256=4h_rc28L_tzaTrFKXhuPptGDGNEIeD_OjhIJb3rHTIc,8577
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_try_node_serialization.py,sha256=EL5kfakuoEcwD85dGjhMta-J-PpCHRSDoc80SdbBrQk,2769
 vellum_ee/workflows/display/tests/workflow_serialization/test_complex_terminal_node_serialization.py,sha256=RmFUDx8dYdfsOE2CGLvdXqNNRtLLpVzXDN8dqZyMcZ8,5822
 vellum_ee/workflows/display/types.py,sha256=i4T7ElU5b5h-nA1i3scmEhO1BqmNDc4eJDHavATD88w,2821
 vellum_ee/workflows/display/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/display/utils/exceptions.py,sha256=LSwwxCYNxFkf5XMUcFkaZKpQ13OSrI7y_bpEUwbKVk0,169
-vellum_ee/workflows/display/utils/expressions.py,sha256=u-sIH_hDxJdSjq_0BTP3QmbIDvA-OI1GxyPtmNvxxKc,12595
+vellum_ee/workflows/display/utils/expressions.py,sha256=7gWOsow_fkayY7GnByv1cN_XhbI24dJT-VQ5-WP46FU,12894
 vellum_ee/workflows/display/utils/registry.py,sha256=fWIm5Jj-10gNFjgn34iBu4RWv3Vd15ijtSN0V97bpW8,1513
 vellum_ee/workflows/display/utils/vellum.py,sha256=mtoXmSYwR7rvrq-d6CzCW_auaJXTct0Mi1F0xpRCiNQ,5627
 vellum_ee/workflows/display/vellum.py,sha256=o7mq_vk2Yapu9DDKRz5l76h8EmCAypWGQYe6pryrbB8,3576
@@ -134,7 +134,7 @@ vellum/client/README.md,sha256=qmaVIP42MnxAu8jV7u-CsgVFfs3-pHQODrXdZdFxtaw,4749
 vellum/client/__init__.py,sha256=AYopGv2ZRVn3zsU8_km6KOvEHDbXiTPCVuYVI7bWvdA,120166
 vellum/client/core/__init__.py,sha256=SQ85PF84B9MuKnBwHNHWemSGuy-g_515gFYNFhvEE0I,1438
 vellum/client/core/api_error.py,sha256=RE8LELok2QCjABadECTvtDp7qejA1VmINCh6TbqPwSE,426
-vellum/client/core/client_wrapper.py,sha256=Y50hXu4pkEmrPDb1Vq6PeuiVG0NavAoEk1Dexp7lgSE,1869
+vellum/client/core/client_wrapper.py,sha256=ikQHyukVNBgDFhkMt29SwknlEfXdS0GnAPctHIOoSpc,1869
 vellum/client/core/datetime_utils.py,sha256=nBys2IsYrhPdszxGKCNRPSOCwa-5DWOHG95FB8G9PKo,1047
 vellum/client/core/file.py,sha256=d4NNbX8XvXP32z8KpK2Xovv33nFfruIrpz0QWxlgpZk,2663
 vellum/client/core/http_client.py,sha256=Z77OIxIbL4OAB2IDqjRq_sYa5yNYAWfmdhdCSSvh6Y4,19552
@@ -1496,7 +1496,7 @@ vellum/workflows/emitters/base.py,sha256=D5SADKIvnbgKwIBgYm77jaqvpo1o0rz4MmuX_mu
 vellum/workflows/environment/__init__.py,sha256=wGHslgSEZ7Octe4C-hNtl84EFelNimgmWQoi7px4-uw,71
 vellum/workflows/environment/environment.py,sha256=0XhJPBs8YASWmvPx8bkSdCvcbDmzpe9stfs2kgtNDRU,296
 vellum/workflows/errors/__init__.py,sha256=tWGPu5xyAU8gRb8_bl0fL7OfU3wxQ9UH6qVwy4X4P_Q,113
-vellum/workflows/errors/types.py,sha256=_A0J3ACjg5dAR2TLI1KHSNPI-oDGkt_9nDk5a0NAjTY,3714
+vellum/workflows/errors/types.py,sha256=nUWuniEfrhdtb-_2GzoDGlYnSJ_yuNUGjVkaKLNr-rM,4049
 vellum/workflows/events/__init__.py,sha256=6pxxceJo2dcaRkWtkDAYlUQZ-PHBQSZytIoyuUK48Qw,759
 vellum/workflows/events/node.py,sha256=TaawUxKaZG8cv_GkiKnJmjOmC4Ic0wMlsxUduF2Rbpw,5446
 vellum/workflows/events/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -1587,21 +1587,21 @@ vellum/workflows/nodes/displayable/bases/base_prompt_node/__init__.py,sha256=Org
 vellum/workflows/nodes/displayable/bases/base_prompt_node/node.py,sha256=amBXi7Tv50AbGLhfWbwX83PlOdV1XyYRyQmpa6_afE4,3511
 vellum/workflows/nodes/displayable/bases/inline_prompt_node/__init__.py,sha256=Hl35IAoepRpE-j4cALaXVJIYTYOF3qszyVbxTj4kS1s,82
 vellum/workflows/nodes/displayable/bases/inline_prompt_node/constants.py,sha256=fnjiRWLoRlC4Puo5oQcpZD5Hd-EesxsAo9l5tGAkpZQ,270
-vellum/workflows/nodes/displayable/bases/inline_prompt_node/node.py,sha256=K2jwAjgG2Qaq7tfDlCckojhAjir962fcIT3eKgjTAEM,11555
+vellum/workflows/nodes/displayable/bases/inline_prompt_node/node.py,sha256=cD2RzOX9WE6xTKgm09dsEw4xHATZbOjeGyYCSdl8fjU,11785
 vellum/workflows/nodes/displayable/bases/inline_prompt_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/displayable/bases/inline_prompt_node/tests/test_inline_prompt_node.py,sha256=5CNag1_aEFZbCL0nrOC5e1L-t90-4rp2xDwh0h52hVI,21407
-vellum/workflows/nodes/displayable/bases/prompt_deployment_node.py,sha256=T99UWACTD9ytVDVHa6W2go00V7HNwDxOyBFyMM2GnhQ,9567
+vellum/workflows/nodes/displayable/bases/prompt_deployment_node.py,sha256=0a40fkkZkFMmZN0CsWf6EP_y1H6x36EGa3WcfVNyOsM,9797
 vellum/workflows/nodes/displayable/bases/search_node.py,sha256=3UtbqY3QO4kzfJHbmUNZGnEEfJmaoiF892u8H6TGjp8,5381
 vellum/workflows/nodes/displayable/bases/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/displayable/bases/tests/test_utils.py,sha256=eqdqbKNRWVMDPevgwLg1i6YK0g4L4bCy-7xCBN5yYZI,3156
 vellum/workflows/nodes/displayable/bases/types.py,sha256=C37B2Qh2YP7s7pUjd-EYKc2Zl1TbnCgI_mENuUSb8bo,1706
 vellum/workflows/nodes/displayable/bases/utils.py,sha256=ckMUenSsNkiYmSw6FmjSMHYaCk8Y8_sUjL6lkFFEqts,5412
 vellum/workflows/nodes/displayable/code_execution_node/__init__.py,sha256=0FLWMMktpzSnmBMizQglBpcPrP80fzVsoJwJgf822Cg,76
-vellum/workflows/nodes/displayable/code_execution_node/node.py,sha256=U21jXW8XZoC51vP0pvbbUQzQidR6Ej2lMdGypIUyF3I,9708
+vellum/workflows/nodes/displayable/code_execution_node/node.py,sha256=o2hP4tWad3-qXY_QtodtGiOGrO8HjeQnqYrxxpxeJVo,9954
 vellum/workflows/nodes/displayable/code_execution_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/displayable/code_execution_node/tests/fixtures/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/displayable/code_execution_node/tests/fixtures/main.py,sha256=5QsbmkzSlSbcbWTG_JmIqcP-JNJzOPTKxGzdHos19W4,79
-vellum/workflows/nodes/displayable/code_execution_node/tests/test_node.py,sha256=mOVOD9UL2X0BpURn3vTI0ZPE7MGyVNo0XIwNKqxxbrM,34723
+vellum/workflows/nodes/displayable/code_execution_node/tests/test_node.py,sha256=DRd-nOC04RGjXz-ctxADVq7b-hgdiFN3ZfhK6Ld7J8I,36634
 vellum/workflows/nodes/displayable/code_execution_node/utils.py,sha256=VRTKms59vrSR9mDk99cojParZVAP4lzjEeDwDNXU1tk,3837
 vellum/workflows/nodes/displayable/conditional_node/__init__.py,sha256=AS_EIqFdU1F9t8aLmbZU-rLh9ry6LCJ0uj0D8F0L5Uw,72
 vellum/workflows/nodes/displayable/conditional_node/node.py,sha256=Qjfl33gZ3JEgxBA1EgzSUebboGvsARthIxxcQyvx5Gg,1152
@@ -1634,7 +1634,7 @@ vellum/workflows/nodes/displayable/search_node/tests/test_node.py,sha256=OserVd6
 vellum/workflows/nodes/displayable/subworkflow_deployment_node/__init__.py,sha256=9yYM6001YZeqI1VOk1QuEM_yrffk_EdsO7qaPzINKds,92
 vellum/workflows/nodes/displayable/subworkflow_deployment_node/node.py,sha256=biv1H4gIX4B4VMFJ3Rp82NjE65GhmzLq7pREL0ozB2E,9484
 vellum/workflows/nodes/displayable/subworkflow_deployment_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/nodes/displayable/subworkflow_deployment_node/tests/test_node.py,sha256=2KdPh1TeIeW_3xJq4QzAwfcuqL6PmMTLNPz4nSaDLmY,18030
+vellum/workflows/nodes/displayable/subworkflow_deployment_node/tests/test_node.py,sha256=c98nMPogZ6iN_pTvVUMTB3J72Hj--H-XVgvvRXhdSQE,19085
 vellum/workflows/nodes/displayable/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/displayable/tests/test_inline_text_prompt_node.py,sha256=MHuIolSsrY9ziwoXWsye3XOODncL9DLZOkNYzQMLhRw,4696
 vellum/workflows/nodes/displayable/tests/test_search_node_wth_text_output.py,sha256=VepO5z1277c1y5N6LLIC31nnWD1aak2m5oPFplfJHHs,6935
@@ -1644,9 +1644,9 @@ vellum/workflows/nodes/experimental/__init__.py,sha256=_tpZGWAZLydcKxfrj1-plrZeT
 vellum/workflows/nodes/experimental/openai_chat_completion_node/__init__.py,sha256=lsyD9laR9p7kx5-BXGH2gUTM242UhKy8SMV0SR6S2iE,90
 vellum/workflows/nodes/experimental/openai_chat_completion_node/node.py,sha256=cKI2Ls25L-JVt4z4a2ozQa-YBeVy21Z7BQ32Sj7iBPE,10460
 vellum/workflows/nodes/experimental/tool_calling_node/__init__.py,sha256=S7OzT3I4cyOU5Beoz87nPwCejCMP2FsHBFL8OcVmxJ4,118
-vellum/workflows/nodes/experimental/tool_calling_node/node.py,sha256=4MUlTTAJdFDYA5ybRGaqAQX9XTaOsH48Sr8rJ49oatw,4892
-vellum/workflows/nodes/experimental/tool_calling_node/tests/test_tool_calling_node.py,sha256=sxG26mOwt4N36RLoPJ-ngginPqC5qFzD_kGj9izdCFI,1833
-vellum/workflows/nodes/experimental/tool_calling_node/utils.py,sha256=Z9zCnvZBE7tT4iwsiG5YgPLFhAKeDJjPs-8JYAi3n8o,7203
+vellum/workflows/nodes/experimental/tool_calling_node/node.py,sha256=XPMVnjlsO_ueCygEsbw9UbP4H2ZX_SvJuZHqEb88jj4,5677
+vellum/workflows/nodes/experimental/tool_calling_node/tests/test_node.py,sha256=sxG26mOwt4N36RLoPJ-ngginPqC5qFzD_kGj9izdCFI,1833
+vellum/workflows/nodes/experimental/tool_calling_node/utils.py,sha256=lcjJU-tMCNo-qUjWI_twPqaf3tGjIVrf6NJQQffCF5E,10054
 vellum/workflows/nodes/mocks.py,sha256=a1FjWEIocseMfjzM-i8DNozpUsaW0IONRpZmXBoWlyc,10455
 vellum/workflows/nodes/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/tests/test_mocks.py,sha256=mfPvrs75PKcsNsbJLQAN6PDFoVqs9TmQxpdyFKDdO60,7837
@@ -1687,7 +1687,7 @@ vellum/workflows/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3
 vellum/workflows/tests/test_sandbox.py,sha256=JKwaluI-lODQo7Ek9sjDstjL_WTdSqUlVik6ZVTfVOA,1826
 vellum/workflows/tests/test_undefined.py,sha256=zMCVliCXVNLrlC6hEGyOWDnQADJ2g83yc5FIM33zuo8,353
 vellum/workflows/types/__init__.py,sha256=KxUTMBGzuRCfiMqzzsykOeVvrrkaZmTTo1a7SLu8gRM,68
-vellum/workflows/types/code_execution_node_wrappers.py,sha256=sPo7fLSyf92n6OFsrNLAsaNs0_I3AH-fXkEw3KrbWmc,3162
+vellum/workflows/types/code_execution_node_wrappers.py,sha256=3MNIoFZKzVzNS5qFLVuDwMV17QJw72zo7NRf52yMq5A,3074
 vellum/workflows/types/core.py,sha256=kMQremh_I8egXpiKmtMQbB6e3OczAWiRnnTq5V6xlD0,928
 vellum/workflows/types/definition.py,sha256=z81CL_u0FJol-9yUIqoXNTYAARtU8x__c6s-f4rb5c8,2335
 vellum/workflows/types/generics.py,sha256=tKXz0LwWJGKw1YGudyl9_yFDrRgU6yYV1yJV1Zv-LTw,1430
@@ -1712,8 +1712,8 @@ vellum/workflows/workflows/event_filters.py,sha256=GSxIgwrX26a1Smfd-6yss2abGCnad
 vellum/workflows/workflows/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/workflows/tests/test_base_workflow.py,sha256=fROqff6AZpCIzaSwOKSdtYy4XR0UZQ6ejxL3RJOSJVs,20447
 vellum/workflows/workflows/tests/test_context.py,sha256=VJBUcyWVtMa_lE5KxdhgMu0WYNYnUQUDvTF7qm89hJ0,2333
-vellum_ai-0.14.61.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
-vellum_ai-0.14.61.dist-info/METADATA,sha256=6rjJiOUgei1EVdl_iiBzai45u8cWbO3pjeKrt4RBB2E,5484
-vellum_ai-0.14.61.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-vellum_ai-0.14.61.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
-vellum_ai-0.14.61.dist-info/RECORD,,
+vellum_ai-0.14.63.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
+vellum_ai-0.14.63.dist-info/METADATA,sha256=QEDirKfQq3koN0R5mtzFvHqWaO09TC6VFQRFgwjDqdY,5484
+vellum_ai-0.14.63.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+vellum_ai-0.14.63.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
+vellum_ai-0.14.63.dist-info/RECORD,,

vellum_ee/workflows/display/nodes/vellum/prompt_deployment_node.py

@@ -1,8 +1,7 @@
 from uuid import UUID
-from typing import Generic, Optional, TypeVar, cast
+from typing import Generic, Optional, TypeVar
 
 from vellum.workflows.nodes.displayable.prompt_deployment_node import PromptDeploymentNode
-from vellum.workflows.references import OutputReference
 from vellum.workflows.types.core import JsonObject
 from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
 from vellum_ee.workflows.display.nodes.utils import raise_if_descriptor
@@ -40,8 +39,9 @@ class BasePromptDeploymentNodeDisplay(BaseNodeDisplay[_PromptDeploymentNodeType]
             else []
         )
 
-        _, output_display = display_context.global_node_output_displays[cast(OutputReference, node.Outputs.text)]
-        _, array_display = display_context.global_node_output_displays[cast(OutputReference, node.Outputs.results)]
+        output_display = self.output_display[node.Outputs.text]
+        array_display = self.output_display[node.Outputs.results]
+        json_display = self.output_display[node.Outputs.json]
 
         deployment = display_context.client.deployments.retrieve(
             id=str(raise_if_descriptor(node.deployment)),
@@ -68,4 +68,9 @@ class BasePromptDeploymentNodeDisplay(BaseNodeDisplay[_PromptDeploymentNodeType]
             "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
             "ports": self.serialize_ports(display_context),
+            "outputs": [
+                {"id": str(json_display.id), "name": "json", "type": "JSON", "value": None},
+                {"id": str(output_display.id), "name": "text", "type": "STRING", "value": None},
+                {"id": str(array_display.id), "name": "results", "type": "ARRAY", "value": None},
+            ],
         }

vellum_ee/workflows/display/nodes/vellum/tests/test_tool_calling_node.py

@@ -1,3 +1,4 @@
+from vellum.client.types.code_execution_package import CodeExecutionPackage
 from vellum.workflows import BaseWorkflow
 from vellum.workflows.inputs import BaseInputs
 from vellum.workflows.nodes.displayable.inline_prompt_node.node import InlinePromptNode
@@ -122,3 +123,95 @@ def test_serialize_node__prompt_inputs__mixed_values():
             ],
         },
     }
+
+
+def test_serialize_node__function_packages():
+    # GIVEN a tool calling node with function packages
+    def foo():
+        pass
+
+    def bar():
+        pass
+
+    class MyToolCallingNode(ToolCallingNode):
+        functions = [foo, bar]
+        function_packages = {
+            foo: [
+                CodeExecutionPackage(name="first_package", version="1.0.0"),
+                CodeExecutionPackage(name="second_package", version="2.0.0"),
+            ],
+            bar: [
+                CodeExecutionPackage(name="third_package", version="3.0.0"),
+            ],
+        }
+
+    # AND a workflow with the tool calling node
+    class Workflow(BaseWorkflow):
+        graph = MyToolCallingNode
+
+    # WHEN the workflow is serialized
+    workflow_display = get_workflow_display(workflow_class=Workflow)
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN the node should properly serialize the function packages
+    my_tool_calling_node = next(
+        node
+        for node in serialized_workflow["workflow_raw_data"]["nodes"]
+        if node["id"] == str(MyToolCallingNode.__id__)
+    )
+
+    function_packages_attribute = next(
+        attribute for attribute in my_tool_calling_node["attributes"] if attribute["name"] == "function_packages"
+    )
+
+    assert function_packages_attribute == {
+        "id": "c315228f-870a-4288-abf7-a217b5b8c253",
+        "name": "function_packages",
+        "value": {
+            "type": "CONSTANT_VALUE",
+            "value": {
+                "type": "JSON",
+                "value": {
+                    "foo": [
+                        {"version": "1.0.0", "name": "first_package"},
+                        {"version": "2.0.0", "name": "second_package"},
+                    ],
+                    "bar": [{"version": "3.0.0", "name": "third_package"}],
+                },
+            },
+        },
+    }
+
+
+def test_serialize_node__none_function_packages():
+    # GIVEN a tool calling node with no function packages
+    def foo():
+        pass
+
+    class MyToolCallingNode(ToolCallingNode):
+        functions = [foo]
+
+    # AND a workflow with the tool calling node
+    class Workflow(BaseWorkflow):
+        graph = MyToolCallingNode
+
+    # WHEN the workflow is serialized
+    workflow_display = get_workflow_display(workflow_class=Workflow)
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN the node should properly serialize the functions
+    my_tool_calling_node = next(
+        node
+        for node in serialized_workflow["workflow_raw_data"]["nodes"]
+        if node["id"] == str(MyToolCallingNode.__id__)
+    )
+
+    function_packages_attribute = next(
+        attribute for attribute in my_tool_calling_node["attributes"] if attribute["name"] == "function_packages"
+    )
+
+    assert function_packages_attribute == {
+        "id": "05c86dea-ea4b-46c4-883b-7912a6680491",
+        "name": "function_packages",
+        "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+    }

vellum_ee/workflows/display/tests/workflow_serialization/test_basic_prompt_deployment_serialization.py

@@ -7,6 +7,9 @@ from vellum import DeploymentRead
 from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
 
 from tests.workflows.basic_text_prompt_deployment.workflow import BasicTextPromptDeployment
+from tests.workflows.basic_text_prompt_deployment.workflow_with_prompt_deployment_json_reference import (
+    WorkflowWithPromptDeploymentJsonReferenceWorkflow,
+)
 
 
 def test_serialize_workflow(vellum_client):
@@ -103,30 +106,26 @@ def test_serialize_workflow(vellum_client):
                 "id": "947d7ead-0fad-4e5f-aa3a-d06029ac94bc",
                 "key": "city",
                 "value": {
-                    "combinator": "OR",
                     "rules": [
                         {
                             "type": "INPUT_VARIABLE",
-                            "data": {
-                                "input_variable_id": "52995b50-84c9-465f-8a4b-a4ee2a92e388",
-                            },
-                        },
+                            "data": {"input_variable_id": "52995b50-84c9-465f-8a4b-a4ee2a92e388"},
+                        }
                     ],
+                    "combinator": "OR",
                 },
             },
             {
                 "id": "3deebdd7-2900-4d8c-93f2-e5b90649ac42",
                 "key": "date",
                 "value": {
-                    "combinator": "OR",
                     "rules": [
                         {
                             "type": "INPUT_VARIABLE",
-                            "data": {
-                                "input_variable_id": "aa3ca842-250c-4a3f-853f-23928c28d0f8",
-                            },
-                        },
+                            "data": {"input_variable_id": "aa3ca842-250c-4a3f-853f-23928c28d0f8"},
+                        }
                     ],
+                    "combinator": "OR",
                 },
             },
         ],
@@ -142,21 +141,21 @@ def test_serialize_workflow(vellum_client):
             "release_tag": "LATEST",
             "ml_model_fallbacks": ["gpt-4o", "gemini-1.5-pro"],
         },
-        "display_data": {
-            "position": {
-                "x": 0.0,
-                "y": 0.0,
-            },
-        },
+        "display_data": {"position": {"x": 0.0, "y": 0.0}},
         "base": {
-            "module": ["vellum", "workflows", "nodes", "displayable", "prompt_deployment_node", "node"],
             "name": "PromptDeploymentNode",
+            "module": ["vellum", "workflows", "nodes", "displayable", "prompt_deployment_node", "node"],
         },
         "definition": {
-            "module": ["tests", "workflows", "basic_text_prompt_deployment", "workflow"],
             "name": "ExamplePromptDeploymentNode",
+            "module": ["tests", "workflows", "basic_text_prompt_deployment", "workflow"],
         },
         "ports": [{"id": "2f26c7e0-283d-4f04-b639-adebb56bc679", "name": "default", "type": "DEFAULT"}],
+        "outputs": [
+            {"id": "180355a8-e67c-4ce6-9ac3-e5dbb75a6629", "name": "json", "type": "JSON", "value": None},
+            {"id": "4d38b850-79e3-4b85-9158-a41d0c535410", "name": "text", "type": "STRING", "value": None},
+            {"id": "0cf47d33-6d5f-466f-b826-e814f1d0348b", "name": "results", "type": "ARRAY", "value": None},
+        ],
     }
 
     final_output_node = workflow_raw_data["nodes"][2]
@@ -251,3 +250,323 @@ def test_serialize_workflow(vellum_client):
             "workflow",
         ],
     }
+
+
+def test_serialize_workflow_with_prompt_and_templating(vellum_client):
+    # GIVEN a Workflow with stubbed out API calls
+    deployment = DeploymentRead(
+        id=str(uuid4()),
+        created=datetime.now(),
+        label="JSON Prompt Deployment",
+        name="json_prompt_deployment",
+        last_deployed_on=datetime.now(),
+        input_variables=[],
+        active_model_version_ids=[],
+        last_deployed_history_item_id=str(uuid4()),
+    )
+    vellum_client.deployments.retrieve.return_value = deployment
+
+    # WHEN we serialize it
+    workflow_display = get_workflow_display(workflow_class=WorkflowWithPromptDeploymentJsonReferenceWorkflow)
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN we should get a serialized representation of the Workflow
+    assert serialized_workflow.keys() == {
+        "workflow_raw_data",
+        "input_variables",
+        "state_variables",
+        "output_variables",
+    }
+
+    # AND its input variables should be what we expect
+    input_variables = serialized_workflow["input_variables"]
+    assert len(input_variables) == 2
+    assert not DeepDiff(
+        [
+            {
+                "id": "ad577aca-0797-4deb-a484-574ef1a1f0c7",
+                "key": "city",
+                "type": "STRING",
+                "default": None,
+                "required": True,
+                "extensions": {"color": None},
+            },
+            {
+                "id": "066124c4-42bd-4764-aa75-6f230dbbed4a",
+                "key": "date",
+                "type": "STRING",
+                "default": None,
+                "required": True,
+                "extensions": {"color": None},
+            },
+        ],
+        input_variables,
+        ignore_order=True,
+    )
+
+    # AND its output variables should be what we expect
+    output_variables = serialized_workflow["output_variables"]
+    assert len(output_variables) == 1
+    assert output_variables == [{"id": "a7e4b449-5879-4d0c-8f00-d5d4985eb65c", "key": "text", "type": "STRING"}]
+
+    # AND its raw data should be what we expect
+    workflow_raw_data = serialized_workflow["workflow_raw_data"]
+    assert len(workflow_raw_data["edges"]) == 3
+    assert len(workflow_raw_data["nodes"]) == 4
+
+    # AND each node should be serialized correctly
+    entrypoint_node = workflow_raw_data["nodes"][0]
+    assert entrypoint_node == {
+        "id": "32c7f398-277c-456b-9279-aa1f867fb637",
+        "type": "ENTRYPOINT",
+        "inputs": [],
+        "data": {"label": "Entrypoint Node", "source_handle_id": "cc0f4028-1039-4063-971d-7dacbb01b379"},
+        "display_data": {"position": {"x": 0.0, "y": 0.0}},
+        "base": None,
+        "definition": None,
+    }
+
+    prompt_node = workflow_raw_data["nodes"][1]
+    assert prompt_node == {
+        "id": "56c74024-19a3-4c0d-a5f5-23e1e9f11b21",
+        "type": "PROMPT",
+        "inputs": [
+            {
+                "id": "947d7ead-0fad-4e5f-aa3a-d06029ac94bc",
+                "key": "city",
+                "value": {
+                    "rules": [
+                        {
+                            "type": "INPUT_VARIABLE",
+                            "data": {"input_variable_id": "ad577aca-0797-4deb-a484-574ef1a1f0c7"},
+                        }
+                    ],
+                    "combinator": "OR",
+                },
+            },
+            {
+                "id": "3deebdd7-2900-4d8c-93f2-e5b90649ac42",
+                "key": "date",
+                "value": {
+                    "rules": [
+                        {
+                            "type": "INPUT_VARIABLE",
+                            "data": {"input_variable_id": "066124c4-42bd-4764-aa75-6f230dbbed4a"},
+                        }
+                    ],
+                    "combinator": "OR",
+                },
+            },
+        ],
+        "data": {
+            "label": "Example Prompt Deployment Node",
+            "output_id": "4d38b850-79e3-4b85-9158-a41d0c535410",
+            "error_output_id": None,
+            "array_output_id": "0cf47d33-6d5f-466f-b826-e814f1d0348b",
+            "source_handle_id": "2f26c7e0-283d-4f04-b639-adebb56bc679",
+            "target_handle_id": "b7605c48-0937-4ecc-914e-0d1058130e65",
+            "variant": "DEPLOYMENT",
+            "prompt_deployment_id": deployment.id,
+            "release_tag": "LATEST",
+            "ml_model_fallbacks": None,
+        },
+        "display_data": {"position": {"x": 0.0, "y": 0.0}},
+        "base": {
+            "name": "PromptDeploymentNode",
+            "module": ["vellum", "workflows", "nodes", "displayable", "prompt_deployment_node", "node"],
+        },
+        "definition": {
+            "name": "ExamplePromptDeploymentNode",
+            "module": [
+                "tests",
+                "workflows",
+                "basic_text_prompt_deployment",
+                "workflow_with_prompt_deployment_json_reference",
+            ],
+        },
+        "ports": [{"id": "2f26c7e0-283d-4f04-b639-adebb56bc679", "name": "default", "type": "DEFAULT"}],
+        "outputs": [
+            {"id": "180355a8-e67c-4ce6-9ac3-e5dbb75a6629", "name": "json", "type": "JSON", "value": None},
+            {"id": "4d38b850-79e3-4b85-9158-a41d0c535410", "name": "text", "type": "STRING", "value": None},
+            {"id": "0cf47d33-6d5f-466f-b826-e814f1d0348b", "name": "results", "type": "ARRAY", "value": None},
+        ],
+    }
+
+    templating_node = workflow_raw_data["nodes"][2]
+    assert templating_node == {
+        "id": "51cbe21d-0232-4362-bc54-5bc283297aa6",
+        "type": "TEMPLATING",
+        "inputs": [
+            {
+                "id": "7c775379-d589-4d79-b876-dcd224d72966",
+                "key": "template",
+                "value": {
+                    "rules": [
+                        {
+                            "type": "CONSTANT_VALUE",
+                            "data": {
+                                "type": "STRING",
+                                "value": "The weather in {{ city }} on {{ date }} is {{ weather }}.",
+                            },
+                        }
+                    ],
+                    "combinator": "OR",
+                },
+            },
+            {
+                "id": "dec1317a-6900-4858-a5fb-c849254b2c91",
+                "key": "city",
+                "value": {
+                    "rules": [
+                        {
+                            "type": "INPUT_VARIABLE",
+                            "data": {"input_variable_id": "ad577aca-0797-4deb-a484-574ef1a1f0c7"},
+                        }
+                    ],
+                    "combinator": "OR",
+                },
+            },
+            {
+                "id": "4cc5b9f1-075d-45fd-a978-f530c29c5682",
+                "key": "date",
+                "value": {
+                    "rules": [
+                        {
+                            "type": "INPUT_VARIABLE",
+                            "data": {"input_variable_id": "066124c4-42bd-4764-aa75-6f230dbbed4a"},
+                        }
+                    ],
+                    "combinator": "OR",
+                },
+            },
+            {
+                "id": "77b352e0-1b77-4d48-9f6f-04ce17fe7286",
+                "key": "weather",
+                "value": {
+                    "rules": [
+                        {
+                            "type": "NODE_OUTPUT",
+                            "data": {
+                                "node_id": "56c74024-19a3-4c0d-a5f5-23e1e9f11b21",
+                                "output_id": "180355a8-e67c-4ce6-9ac3-e5dbb75a6629",
+                            },
+                        }
+                    ],
+                    "combinator": "OR",
+                },
+            },
+        ],
+        "data": {
+            "label": "Example Templating Node",
+            "output_id": "6834cae4-8173-4fa6-88f7-bc09d335bdd1",
+            "error_output_id": None,
+            "source_handle_id": "39317827-df43-4f5a-bfbc-20bffc839748",
+            "target_handle_id": "58427684-3848-498a-8299-c6b0fc70265d",
+            "template_node_input_id": "7c775379-d589-4d79-b876-dcd224d72966",
+            "output_type": "STRING",
+        },
+        "display_data": {"position": {"x": 0.0, "y": 0.0}},
+        "base": {
+            "name": "TemplatingNode",
+            "module": ["vellum", "workflows", "nodes", "core", "templating_node", "node"],
+        },
+        "definition": {
+            "name": "ExampleTemplatingNode",
+            "module": [
+                "tests",
+                "workflows",
+                "basic_text_prompt_deployment",
+                "workflow_with_prompt_deployment_json_reference",
+            ],
+        },
+        "ports": [{"id": "39317827-df43-4f5a-bfbc-20bffc839748", "name": "default", "type": "DEFAULT"}],
+    }
+
+    final_output_node = workflow_raw_data["nodes"][3]
+    assert final_output_node == {
+        "id": "53de824d-a41d-4294-b511-c969932b05af",
+        "type": "TERMINAL",
+        "data": {
+            "label": "Final Output",
+            "name": "text",
+            "target_handle_id": "fee3d395-38c3-485f-ab61-1a0fdf71c4ce",
+            "output_id": "a7e4b449-5879-4d0c-8f00-d5d4985eb65c",
+            "output_type": "STRING",
+            "node_input_id": "cf380f81-c5ee-4bc9-8e26-ecf1307733a9",
+        },
+        "inputs": [
+            {
+                "id": "cf380f81-c5ee-4bc9-8e26-ecf1307733a9",
+                "key": "node_input",
+                "value": {
+                    "rules": [
+                        {
+                            "type": "NODE_OUTPUT",
+                            "data": {
+                                "node_id": "51cbe21d-0232-4362-bc54-5bc283297aa6",
+                                "output_id": "6834cae4-8173-4fa6-88f7-bc09d335bdd1",
+                            },
+                        }
+                    ],
+                    "combinator": "OR",
+                },
+            }
+        ],
+        "display_data": {"position": {"x": 0.0, "y": 0.0}},
+        "base": {
+            "name": "FinalOutputNode",
+            "module": ["vellum", "workflows", "nodes", "displayable", "final_output_node", "node"],
+        },
+        "definition": None,
+    }
+
+    # AND each edge should be serialized correctly
+    serialized_edges = workflow_raw_data["edges"]
+    assert serialized_edges == [
+        {
+            "id": "2c49ffa6-7b9a-49a0-a932-009534556480",
+            "source_node_id": "32c7f398-277c-456b-9279-aa1f867fb637",
+            "source_handle_id": "cc0f4028-1039-4063-971d-7dacbb01b379",
+            "target_node_id": "56c74024-19a3-4c0d-a5f5-23e1e9f11b21",
+            "target_handle_id": "b7605c48-0937-4ecc-914e-0d1058130e65",
+            "type": "DEFAULT",
+        },
+        {
+            "id": "a46909ec-9572-43c6-a134-0bd7e2c09f99",
+            "source_node_id": "56c74024-19a3-4c0d-a5f5-23e1e9f11b21",
+            "source_handle_id": "2f26c7e0-283d-4f04-b639-adebb56bc679",
+            "target_node_id": "51cbe21d-0232-4362-bc54-5bc283297aa6",
+            "target_handle_id": "58427684-3848-498a-8299-c6b0fc70265d",
+            "type": "DEFAULT",
+        },
+        {
+            "id": "1f720900-e5e1-49b7-9910-6ede79f6afd2",
+            "source_node_id": "51cbe21d-0232-4362-bc54-5bc283297aa6",
+            "source_handle_id": "39317827-df43-4f5a-bfbc-20bffc839748",
+            "target_node_id": "53de824d-a41d-4294-b511-c969932b05af",
+            "target_handle_id": "fee3d395-38c3-485f-ab61-1a0fdf71c4ce",
+            "type": "DEFAULT",
+        },
+    ]
+
+    # AND the display data should be what we expect
+    display_data = workflow_raw_data["display_data"]
+    assert display_data == {
+        "viewport": {
+            "x": 0.0,
+            "y": 0.0,
+            "zoom": 1.0,
+        }
+    }
+
+    # AND the definition should be what we expect
+    definition = workflow_raw_data["definition"]
+    assert definition == {
+        "name": "WorkflowWithPromptDeploymentJsonReferenceWorkflow",
+        "module": [
+            "tests",
+            "workflows",
+            "basic_text_prompt_deployment",
+            "workflow_with_prompt_deployment_json_reference",
+        ],
+    }

vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_serialization.py

@@ -168,9 +168,14 @@ def test_serialize_workflow():
                 },
             },
             {
-                "id": "5c041b7d-732c-4773-a93a-32211f2af0b3",
-                "name": "max_tool_calls",
-                "value": {"type": "CONSTANT_VALUE", "value": {"type": "NUMBER", "value": 1.0}},
+                "id": "b31575f0-633b-4bd0-ba6a-960532f3887a",
+                "name": "function_packages",
+                "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+            },
+            {
+                "id": "d316c45c-97ea-4f39-9a2d-5c43e2d355de",
+                "name": "runtime",
+                "value": {"type": "CONSTANT_VALUE", "value": {"type": "STRING", "value": "PYTHON_3_11_6"}},
             },
         ],
         "outputs": [

vellum_ee/workflows/display/utils/expressions.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Any, Dict, cast
+from typing import TYPE_CHECKING, Any, Dict, List, cast
 
 from vellum.client.types.logical_operator import LogicalOperator
 from vellum.workflows.descriptors.base import BaseDescriptor
@@ -190,6 +190,16 @@ def _serialize_condition(display_context: "WorkflowDisplayContext", condition: B
     raise UnsupportedSerializationException(f"Unsupported condition type: {condition.__class__.__name__}")
 
 
+def serialize_key(key: Any) -> str:
+    """Serialize dictionary keys to strings, handling function objects properly."""
+    if callable(key):
+        return key.__name__
+    elif isinstance(key, str):
+        return key
+    else:
+        return str(key)
+
+
 def serialize_value(display_context: "WorkflowDisplayContext", value: Any) -> JsonObject:
     if isinstance(value, ConstantValueReference):
         return serialize_value(display_context, value._value)
@@ -264,10 +274,10 @@ def serialize_value(display_context: "WorkflowDisplayContext", value: Any) -> Js
             }
 
     if isinstance(value, dict):
-        serialized_entries = [
+        serialized_entries: List[Dict[str, Any]] = [
             {
                 "id": str(uuid4_from_hash(f"{key}|{val}")),
-                "key": key,
+                "key": serialize_key(key),
                 "value": serialize_value(display_context, val),
             }
             for key, val in value.items()