vellum-ai 0.14.62__tar.gz → 0.14.63__tar.gz

{vellum_ai-0.14.62 → vellum_ai-0.14.63}/PKG-INFO

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

{vellum_ai-0.14.62 → vellum_ai-0.14.63}/ee/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_ai-0.14.62 → vellum_ai-0.14.63}/ee/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_ai-0.14.62 → vellum_ai-0.14.63}/ee/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()

{vellum_ai-0.14.62 → vellum_ai-0.14.63}/pyproject.toml

@@ -3,7 +3,7 @@ name = "vellum-ai"
 
 [tool.poetry]
 name = "vellum-ai"
-version = "0.14.62"
+version = "0.14.63"
 description = ""
 readme = "README.md"
 authors = []

{vellum_ai-0.14.62 → vellum_ai-0.14.63}/src/vellum/client/core/client_wrapper.py

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

{vellum_ai-0.14.62 → vellum_ai-0.14.63}/src/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_ai-0.14.62 → vellum_ai-0.14.63}/src/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_ai-0.14.62 → vellum_ai-0.14.63}/src/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_ai-0.14.62 → vellum_ai-0.14.63}/src/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_ai-0.14.62 → vellum_ai-0.14.63}/src/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_ai-0.14.62 → vellum_ai-0.14.63}/src/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_ai-0.14.62 → vellum_ai-0.14.63}/src/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_ai-0.14.62 → vellum_ai-0.14.63}/src/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_ai-0.14.62 → vellum_ai-0.14.63}/src/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):