vellum-ai 0.14.62__py3-none-any.whl → 0.14.64__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.62",
+            "X-Fern-SDK-Version": "0.14.64",
         }
         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/bases/base.py

@@ -1,3 +1,4 @@
+from abc import ABC, ABCMeta
 from dataclasses import field
 from functools import cached_property, reduce
 import inspect
@@ -50,7 +51,7 @@ def _is_annotated(cls: Type, name: str) -> bool:
     return False
 
 
-class BaseNodeMeta(type):
+class BaseNodeMeta(ABCMeta):
     def __new__(mcs, name: str, bases: Tuple[Type, ...], dct: Dict[str, Any]) -> Any:
         if "Outputs" in dct:
             outputs_class = dct["Outputs"]
@@ -258,7 +259,7 @@ class _BaseNodeExecutionMeta(type):
 NodeRunResponse = Union[BaseOutputs, Iterator[BaseOutput]]
 
 
-class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
+class BaseNode(Generic[StateType], ABC, metaclass=BaseNodeMeta):
     __id__: UUID = uuid4_from_hash(__qualname__)
     __output_ids__: Dict[str, UUID] = {}
     state: StateType
@@ -490,7 +491,6 @@ class BaseNode(Generic[StateType], metaclass=BaseNodeMeta):
                         node_output_descriptor.name,
                         node_output_descriptor.instance.resolve(self.state),
                     )
-            delattr(self.Outputs, "_outputs_post_init")
 
         setattr(self.Outputs, "_outputs_post_init", _outputs_post_init)
 

vellum/workflows/nodes/bases/base_adornment_node.py

@@ -1,3 +1,4 @@
+from abc import ABC
 from typing import TYPE_CHECKING, Any, Dict, Generic, Optional, Tuple, Type
 
 from vellum.workflows.inputs.base import BaseInputs
@@ -67,6 +68,7 @@ class _BaseAdornmentNodeMeta(BaseNodeMeta):
 class BaseAdornmentNode(
     BaseNode[StateType],
     Generic[StateType],
+    ABC,
     metaclass=_BaseAdornmentNodeMeta,
 ):
     """

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/node.py

@@ -63,6 +63,10 @@ class SubworkflowDeploymentNode(BaseNode[StateType], Generic[StateType]):
         compiled_inputs: List[WorkflowRequestInputRequest] = []
 
         for input_name, input_value in self.subworkflow_inputs.items():
+            # Exclude inputs that resolved to be null. This ensure that we don't pass input values
+            # to optional subworkflow inputs whose values were unresolved.
+            if input_value is None:
+                continue
             if isinstance(input_value, str):
                 compiled_inputs.append(
                     WorkflowRequestStringInputRequest(

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,11 @@
-from collections.abc import Callable
-from typing import Any, ClassVar, List, Optional
+from collections.abc import Callable, Sequence
+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.client.types.code_execution_runtime import CodeExecutionRuntime
 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 +30,14 @@ 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_configs: Optional[Dict[str, Dict[str, Any]]] - Mapping of function names to their configuration
     """
 
     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_configs: ClassVar[Optional[Dict[str, Dict[str, Any]]]] = None
 
     class Outputs(BaseOutputs):
         """
@@ -102,13 +104,28 @@ 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 configuration for this function
+            config = {}
+            if self.function_configs and function.__name__ in self.function_configs:
+                config = self.function_configs[function.__name__]
+
+            packages = config.get("packages", None)
+            if packages is not None:
+                packages = cast(Sequence[CodeExecutionPackage], packages)
+
+            runtime_raw = config.get("runtime", "PYTHON_3_11_6")
+            runtime = cast(CodeExecutionRuntime, runtime_raw)
+
+            self._function_nodes[function_name] = create_function_node(
                 function=function,
                 tool_router_node=self.tool_router_node,
+                packages=packages,
+                runtime=runtime,
             )
-            for function in self.functions
-        }
 
         graph_set = set()
 

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

@@ -1,10 +1,14 @@
-from collections.abc import Callable
+from collections.abc import Callable, Sequence
+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.code_execution_runtime import CodeExecutionRuntime
 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 +17,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 +123,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[Sequence[CodeExecutionPackage]] = None,
+    runtime: CodeExecutionRuntime = "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 +175,83 @@ 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)
+'''
+
+        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.62.dist-info → vellum_ai-0.14.64.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vellum-ai
-Version: 0.14.62
+Version: 0.14.64
 Summary: 
 License: MIT
 Requires-Python: >=3.9,<4.0
@@ -20,22 +20,21 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
-Requires-Dist: Jinja2 (>=3.1.2,<4.0.0)
-Requires-Dist: cdktf (>=0.20.5,<0.21.0)
-Requires-Dist: click (==8.1.7)
-Requires-Dist: docker (==7.1.0)
+Requires-Dist: Jinja2 (>=3.1.0,<4.0.0)
+Requires-Dist: click (>=8.1.0,<9.0.0)
+Requires-Dist: docker (>=7.1.0,<8.0.0)
 Requires-Dist: httpx (>=0.21.2)
-Requires-Dist: openai (>=1.0.0)
+Requires-Dist: openai (>=1.0.0,<2.0.0)
 Requires-Dist: orderly-set (>=5.2.2,<6.0.0)
 Requires-Dist: publication (==0.0.3)
 Requires-Dist: pydantic (>=1.9.2)
 Requires-Dist: pydantic-core (>=2.18.2,<3.0.0)
-Requires-Dist: pydash (==7.0.6)
-Requires-Dist: python-dotenv (==1.0.1)
-Requires-Dist: pytz (==2025.1)
-Requires-Dist: pyyaml (==6.0.2)
-Requires-Dist: requests (==2.32.3)
-Requires-Dist: tomli (==2.0.2)
+Requires-Dist: pydash (>=7.0.0,<8.0.0)
+Requires-Dist: python-dotenv (>=1.0.0,<2.0.0)
+Requires-Dist: pytz (>=2022.0,<2026.0)
+Requires-Dist: pyyaml (>=6.0.0,<7.0.0)
+Requires-Dist: requests (>=2.31.0,<3.0.0)
+Requires-Dist: tomli (>=2.0.0,<3.0.0)
 Requires-Dist: typing_extensions (>=4.0.0)
 Project-URL: Repository, https://github.com/vellum-ai/vellum-python-sdks
 Description-Content-Type: text/markdown

{vellum_ai-0.14.62.dist-info → vellum_ai-0.14.64.dist-info}/RECORD

@@ -42,7 +42,7 @@ vellum_ee/workflows/display/nodes/vellum/final_output_node.py,sha256=jUDI2FwVaw0
 vellum_ee/workflows/display/nodes/vellum/guardrail_node.py,sha256=5_5D5PMzBOeUdVtRlANbfEsu7Gv3r37dLvpfjGAqYac,2330
 vellum_ee/workflows/display/nodes/vellum/inline_prompt_node.py,sha256=-6Ru9W_vfNdLKLStB40qicMx6WvdejPM3PE54Onqk5w,10943
 vellum_ee/workflows/display/nodes/vellum/inline_subworkflow_node.py,sha256=fQV5o83BPTwGX6o-ThN4r7BcIhySyqwpW1JGYWpvSJI,5625
-vellum_ee/workflows/display/nodes/vellum/map_node.py,sha256=CiklGf5_tDbqE1XQm2mnbtoL01_2JYjcnB4FDTpMImQ,3824
+vellum_ee/workflows/display/nodes/vellum/map_node.py,sha256=2teCYQSX8g-b8aaC_MY4XSC4GRMTJigPFWNTQEkC_gk,3907
 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=1NxFddxWCFtMe_je1cutP7qnoASoG94LJqKhRkoQwvw,3535
@@ -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=ZsLIGnJ9QKrXjYeDW8LEN8M9FnWRQ9TohHFyB6144HY,7970
 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
@@ -90,13 +90,13 @@ vellum_ee/workflows/display/tests/workflow_serialization/test_basic_search_node_
 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=Cx3oY6vPVap0xm_mChqfQw4zzR4pqV36o_SyD8g6jPY,8727
 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=6Ws3Z7WyEV9P2j-NicrbyppAaPyLzK4wAJ5mxUvUdJ4,1869
+vellum/client/core/client_wrapper.py,sha256=EBMKy4AU89W_wlhww7wsWGLScDvYus97WUeayU5Ejd0,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
@@ -1548,8 +1548,8 @@ vellum/workflows/inputs/tests/test_inputs.py,sha256=lioA8917mFLYq7Ml69UNkqUjcWbb
 vellum/workflows/logging.py,sha256=_a217XogktV4Ncz6xKFz7WfYmZAzkfVRVuC0rWob8ls,437
 vellum/workflows/nodes/__init__.py,sha256=aVdQVv7Y3Ro3JlqXGpxwaU2zrI06plDHD2aumH5WUIs,1157
 vellum/workflows/nodes/bases/__init__.py,sha256=cniHuz_RXdJ4TQgD8CBzoiKDiPxg62ErdVpCbWICX64,58
-vellum/workflows/nodes/bases/base.py,sha256=WTkFbOynv07TplP5xVvJ5M_IVm1LdosQnT1HKsSwhDM,21942
-vellum/workflows/nodes/bases/base_adornment_node.py,sha256=Ao2opOW4kgNoYXFF9Pk7IMpVZdy6luwrjcqEwU5Q9V0,3404
+vellum/workflows/nodes/bases/base.py,sha256=TtvfbGnAB8fYfQlhBM-sF3fwZLYn_Nq-dqU9m1fAbBU,21923
+vellum/workflows/nodes/bases/base_adornment_node.py,sha256=hrgzuTetM4ynPd9YGHoK8Vwwn4XITi3aZZ_OCnQrq4Y,3433
 vellum/workflows/nodes/bases/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/bases/tests/test_base_adornment_node.py,sha256=fXZI9KqpS4XMBrBnIEkK3foHaBVvyHwYcQWWDKay7ic,1148
 vellum/workflows/nodes/bases/tests/test_base_node.py,sha256=KRrgjXfzxf1ecE55-jwbQqPnOlNii-i2iaHJUW6oWcI,9358
@@ -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
@@ -1632,9 +1632,9 @@ vellum/workflows/nodes/displayable/search_node/node.py,sha256=vUTDyurYKw6KLABuVm
 vellum/workflows/nodes/displayable/search_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/displayable/search_node/tests/test_node.py,sha256=OserVd6jPe6t49MQF0cxphI2irBLaC_GceMr0acFqoY,8075
 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/node.py,sha256=lq8_USZkNiYktH0oJSW2jOuXyRtVwVoq1CKFdCek5-M,9719
 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=FkhaJccpCbx2be_IZ5V2v6Lo-jPJ0WgSC5tveLvAW4A,5774
+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=DjFn33XuomM-EiojCFzTlOsWMdF_uYyHzNayBok6X-k,10055
 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.62.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
-vellum_ai-0.14.62.dist-info/METADATA,sha256=Bzub_INWkihzZyUxbedAO9QOhQmT-Ci17-6k_8JW5zE,5484
-vellum_ai-0.14.62.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-vellum_ai-0.14.62.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
-vellum_ai-0.14.62.dist-info/RECORD,,
+vellum_ai-0.14.64.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
+vellum_ai-0.14.64.dist-info/METADATA,sha256=tewaEjPiWmDj6JmUJmAXJPiXr51sX5Yvpc3rHxjJw0w,5508
+vellum_ai-0.14.64.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+vellum_ai-0.14.64.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
+vellum_ai-0.14.64.dist-info/RECORD,,

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

@@ -3,6 +3,7 @@ from typing import Generic, Optional, TypeVar, cast
 
 from vellum.workflows.nodes import MapNode
 from vellum.workflows.types.core import JsonObject
+from vellum.workflows.workflows.base import BaseWorkflow
 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
@@ -21,7 +22,7 @@ class BaseMapNodeDisplay(BaseAdornmentNodeDisplay[_MapNodeType], Generic[_MapNod
         node = self._node
         node_id = self.node_id
 
-        subworkflow = raise_if_descriptor(node.subworkflow)
+        subworkflow = cast(type[BaseWorkflow], raise_if_descriptor(node.subworkflow))
 
         items_node_input = create_node_input(
             node_id=node_id,

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,102 @@ def test_serialize_node__prompt_inputs__mixed_values():
             ],
         },
     }
+
+
+def test_serialize_node__function_configs():
+    # GIVEN a tool calling node with function packages
+    def foo():
+        pass
+
+    def bar():
+        pass
+
+    class MyToolCallingNode(ToolCallingNode):
+        functions = [foo, bar]
+        function_configs = {
+            "foo": {
+                "runtime": "PYTHON_3_11_6",
+                "packages": [
+                    CodeExecutionPackage(name="first_package", version="1.0.0"),
+                    CodeExecutionPackage(name="second_package", version="2.0.0"),
+                ],
+            },
+            "bar": {
+                "runtime": "PYTHON_3_11_6",
+                "packages": [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_configs_attribute = next(
+        attribute for attribute in my_tool_calling_node["attributes"] if attribute["name"] == "function_configs"
+    )
+
+    assert function_configs_attribute == {
+        "id": "90cc5fc7-9fb3-450f-be5a-e90e7412a601",
+        "name": "function_configs",
+        "value": {
+            "type": "CONSTANT_VALUE",
+            "value": {
+                "type": "JSON",
+                "value": {
+                    "foo": {
+                        "runtime": "PYTHON_3_11_6",
+                        "packages": [
+                            {"version": "1.0.0", "name": "first_package"},
+                            {"version": "2.0.0", "name": "second_package"},
+                        ],
+                    },
+                    "bar": {"runtime": "PYTHON_3_11_6", "packages": [{"version": "3.0.0", "name": "third_package"}]},
+                },
+            },
+        },
+    }
+
+
+def test_serialize_node__function_configs__none():
+    # GIVEN a tool calling node with no function configs
+    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_configs_attribute = next(
+        attribute for attribute in my_tool_calling_node["attributes"] if attribute["name"] == "function_configs"
+    )
+
+    assert function_configs_attribute == {
+        "id": "5f63f2aa-72d7-47ad-a552-630753418b7d",
+        "name": "function_configs",
+        "value": {"type": "CONSTANT_VALUE", "value": {"type": "JSON", "value": None}},
+    }

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

@@ -150,6 +150,22 @@ def test_serialize_workflow():
                     },
                 },
             },
+            {
+                "id": "a4e3bc9f-7112-4d2f-94fb-7362a85db27a",
+                "name": "function_configs",
+                "value": {
+                    "type": "CONSTANT_VALUE",
+                    "value": {
+                        "type": "JSON",
+                        "value": {
+                            "get_current_weather": {
+                                "runtime": "PYTHON_3_11_6",
+                                "packages": [{"version": "2.26.0", "name": "requests"}],
+                            }
+                        },
+                    },
+                },
+            },
             {
                 "id": "0f6dc102-3460-4963-91fa-7ba85d65ef7a",
                 "name": "prompt_inputs",
@@ -167,11 +183,6 @@ def test_serialize_workflow():
                     ],
                 },
             },
-            {
-                "id": "5c041b7d-732c-4773-a93a-32211f2af0b3",
-                "name": "max_tool_calls",
-                "value": {"type": "CONSTANT_VALUE", "value": {"type": "NUMBER", "value": 1.0}},
-            },
         ],
         "outputs": [
             {"id": "e62bc785-a914-4066-b79e-8c89a5d0ec6c", "name": "text", "type": "STRING", "value": None},

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()