vellum-ai 0.14.72__py3-none-any.whl → 0.14.73__py3-none-any.whl

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

@@ -21,6 +21,7 @@ from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.errors.types import workflow_event_error_to_workflow_error
 from vellum.workflows.events.types import default_serializer
 from vellum.workflows.exceptions import NodeException
+from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.outputs.base import BaseOutput
 from vellum.workflows.types.core import EntityInputsInterface, MergeBehavior
@@ -43,7 +44,7 @@ class SubworkflowDeploymentNode(BaseNode[StateType], Generic[StateType]):
 
     # Either the Workflow Deployment's UUID or its name.
     deployment: ClassVar[Union[UUID, str]]
-    subworkflow_inputs: ClassVar[EntityInputsInterface] = {}
+    subworkflow_inputs: ClassVar[Union[EntityInputsInterface, BaseInputs]] = {}
 
     release_tag: str = LATEST_RELEASE_TAG
     external_id: Optional[str] = OMIT
@@ -62,68 +63,77 @@ 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(
-                        name=input_name,
-                        value=input_value,
-                    )
+        if isinstance(self.subworkflow_inputs, BaseInputs):
+            for input_descriptor, input_value in self.subworkflow_inputs:
+                self._add_compiled_input(compiled_inputs, input_descriptor.name, input_value)
+        else:
+            for input_name, input_value in self.subworkflow_inputs.items():
+                self._add_compiled_input(compiled_inputs, input_name, input_value)
+
+        return compiled_inputs
+
+    def _add_compiled_input(
+        self, compiled_inputs: List[WorkflowRequestInputRequest], input_name: str, input_value: Any
+    ) -> None:
+        # 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:
+            return
+        if isinstance(input_value, str):
+            compiled_inputs.append(
+                WorkflowRequestStringInputRequest(
+                    name=input_name,
+                    value=input_value,
                 )
-            elif (
-                isinstance(input_value, list)
-                and len(input_value) > 0
-                and all(isinstance(message, (ChatMessage, ChatMessageRequest)) for message in input_value)
-            ):
-                chat_history = [
-                    (
-                        message
-                        if isinstance(message, ChatMessageRequest)
-                        else ChatMessageRequest.model_validate(message.model_dump())
-                    )
-                    for message in input_value
-                    if isinstance(message, (ChatMessage, ChatMessageRequest))
-                ]
-                compiled_inputs.append(
-                    WorkflowRequestChatHistoryInputRequest(
-                        name=input_name,
-                        value=chat_history,
-                    )
+            )
+        elif (
+            isinstance(input_value, list)
+            and len(input_value) > 0
+            and all(isinstance(message, (ChatMessage, ChatMessageRequest)) for message in input_value)
+        ):
+            chat_history = [
+                (
+                    message
+                    if isinstance(message, ChatMessageRequest)
+                    else ChatMessageRequest.model_validate(message.model_dump())
                 )
-            elif isinstance(input_value, dict):
-                compiled_inputs.append(
-                    WorkflowRequestJsonInputRequest(
-                        name=input_name,
-                        value=cast(Dict[str, Any], input_value),
-                    )
+                for message in input_value
+                if isinstance(message, (ChatMessage, ChatMessageRequest))
+            ]
+            compiled_inputs.append(
+                WorkflowRequestChatHistoryInputRequest(
+                    name=input_name,
+                    value=chat_history,
                 )
-            elif isinstance(input_value, (int, float)):
-                compiled_inputs.append(
-                    WorkflowRequestNumberInputRequest(
-                        name=input_name,
-                        value=input_value,
-                    )
+            )
+        elif isinstance(input_value, dict):
+            compiled_inputs.append(
+                WorkflowRequestJsonInputRequest(
+                    name=input_name,
+                    value=cast(Dict[str, Any], input_value),
                 )
-            else:
-                try:
-                    input_value = default_serializer(input_value)
-                except json.JSONDecodeError as e:
-                    raise NodeException(
-                        message=f"Failed to serialize input '{input_name}' of type '{input_value.__class__}': {e}",
-                        code=WorkflowErrorCode.INVALID_INPUTS,
-                    )
-                compiled_inputs.append(
-                    WorkflowRequestJsonInputRequest(
-                        name=input_name,
-                        value=input_value,
-                    )
+            )
+        elif isinstance(input_value, (int, float)):
+            compiled_inputs.append(
+                WorkflowRequestNumberInputRequest(
+                    name=input_name,
+                    value=input_value,
                 )
-
-        return compiled_inputs
+            )
+        else:
+            try:
+                input_value = default_serializer(input_value)
+            except json.JSONDecodeError as e:
+                raise NodeException(
+                    message=f"Failed to serialize input '{input_name}' of type '{input_value.__class__}': {e}",
+                    code=WorkflowErrorCode.INVALID_INPUTS,
+                )
+            compiled_inputs.append(
+                WorkflowRequestJsonInputRequest(
+                    name=input_name,
+                    value=input_value,
+                )
+            )
 
     def run(self) -> Iterator[BaseOutput]:
         execution_context = get_execution_context()

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

@@ -1,8 +1,6 @@
-from collections.abc import Callable, Sequence
+from collections.abc import 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
@@ -12,11 +10,15 @@ from vellum.workflows.exceptions import NodeException
 from vellum.workflows.graph.graph import Graph
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases import BaseNode
-from vellum.workflows.nodes.experimental.tool_calling_node.utils import create_function_node, create_tool_router_node
+from vellum.workflows.nodes.experimental.tool_calling_node.utils import (
+    create_function_node,
+    create_tool_router_node,
+    get_function_name,
+)
 from vellum.workflows.outputs.base import BaseOutputs
 from vellum.workflows.state.base import BaseState
 from vellum.workflows.state.context import WorkflowContext
-from vellum.workflows.types.core import EntityInputsInterface
+from vellum.workflows.types.core import EntityInputsInterface, Tool
 from vellum.workflows.workflows.base import BaseWorkflow
 
 
@@ -27,15 +29,14 @@ class ToolCallingNode(BaseNode):
     Attributes:
         ml_model: str - The model to use for tool calling (e.g., "gpt-4o-mini")
         blocks: List[PromptBlock] - The prompt blocks to use (same format as InlinePromptNode)
-        functions: List[FunctionDefinition] - The functions that can be called
-        function_callables: List[Callable] - The callables that can be called
+        functions: List[Tool] - The functions 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]]] = []
+    functions: ClassVar[List[Tool]] = []
     prompt_inputs: ClassVar[Optional[EntityInputsInterface]] = None
     function_configs: ClassVar[Optional[Dict[str, Dict[str, Any]]]] = None
 
@@ -106,8 +107,7 @@ class ToolCallingNode(BaseNode):
 
         self._function_nodes = {}
         for function in self.functions:
-            function_name = snake_case(function.__name__)
-
+            function_name = get_function_name(function)
             # Get configuration for this function
             config = {}
             if callable(function) and self.function_configs and function.__name__ in self.function_configs:

vellum/workflows/nodes/experimental/tool_calling_node/tests/test_utils.py

@@ -0,0 +1,49 @@
+from vellum.workflows import BaseWorkflow
+from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.nodes.bases import BaseNode
+from vellum.workflows.nodes.experimental.tool_calling_node.utils import get_function_name
+from vellum.workflows.outputs.base import BaseOutputs
+from vellum.workflows.state.base import BaseState
+from vellum.workflows.types.definition import DeploymentDefinition
+
+
+def test_get_function_name_callable():
+    """Test callable"""
+
+    def my_function() -> str:
+        return "test"
+
+    function = my_function
+
+    result = get_function_name(function)
+
+    assert result == "my_function"
+
+
+def test_get_function_name_workflow_class():
+    """Test workflow class."""
+
+    class MyWorkflow(BaseWorkflow[BaseInputs, BaseState]):
+        class MyNode(BaseNode):
+            class Outputs(BaseOutputs):
+                result: str
+
+            def run(self) -> Outputs:
+                return self.Outputs(result="test")
+
+        graph = MyNode
+
+    workflow_class = MyWorkflow
+
+    result = get_function_name(workflow_class)
+
+    assert result == "my_workflow"
+
+
+def test_get_function_name_subworkflow_deployment():
+    """Test subworkflow deployment."""
+    deployment_config = DeploymentDefinition(deployment="my-test-deployment", release_tag="v1.0.0")
+
+    result = get_function_name(deployment_config)
+
+    assert result == "my-test-deployment"

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

@@ -1,4 +1,4 @@
-from collections.abc import Callable, Sequence
+from collections.abc import Sequence
 import inspect
 import json
 import types
@@ -18,13 +18,15 @@ from vellum.workflows.exceptions import NodeException
 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.nodes.displayable.subworkflow_deployment_node.node import SubworkflowDeploymentNode
 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.context import WorkflowContext
 from vellum.workflows.state.encoder import DefaultStateEncoder
-from vellum.workflows.types.core import EntityInputsInterface, MergeBehavior
+from vellum.workflows.types.core import EntityInputsInterface, MergeBehavior, Tool
+from vellum.workflows.types.definition import DeploymentDefinition
 from vellum.workflows.types.generics import is_workflow_class
 
 
@@ -68,14 +70,14 @@ class ToolRouterNode(InlinePromptNode):
 def create_tool_router_node(
     ml_model: str,
     blocks: List[PromptBlock],
-    functions: List[Callable[..., Any]],
+    functions: List[Tool],
     prompt_inputs: Optional[EntityInputsInterface],
 ) -> Type[ToolRouterNode]:
     if functions and len(functions) > 0:
         # If we have functions, create dynamic ports for each function
         Ports = type("Ports", (), {})
         for function in functions:
-            function_name = snake_case(function.__name__)
+            function_name = get_function_name(function)
 
             # Avoid using lambda to capture function_name
             # lambda will capture the function_name by reference,
@@ -127,7 +129,7 @@ def create_tool_router_node(
 
 
 def create_function_node(
-    function: Callable[..., Any],
+    function: Tool,
     tool_router_node: Type[ToolRouterNode],
     packages: Optional[Sequence[CodeExecutionPackage]] = None,
     runtime: CodeExecutionRuntime = "PYTHON_3_11_6",
@@ -143,7 +145,59 @@ def create_function_node(
         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")
     """
-    if is_workflow_class(function):
+    if isinstance(function, DeploymentDefinition):
+        deployment = function.deployment
+        release_tag = function.release_tag
+
+        def execute_deployment_workflow_function(self) -> BaseNode.Outputs:
+            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 = {}
+
+            subworkflow_node = type(
+                f"DynamicSubworkflowNode_{deployment}",
+                (SubworkflowDeploymentNode,),
+                {
+                    "deployment": deployment,
+                    "release_tag": release_tag,
+                    "subworkflow_inputs": arguments,
+                    "__module__": __name__,
+                },
+            )
+
+            node_instance = subworkflow_node(
+                context=WorkflowContext.create_from(self._context),
+                state=self.state,
+            )
+
+            outputs = {}
+            for output in node_instance.run():
+                outputs[output.name] = output.value
+
+            self.state.chat_history.append(
+                ChatMessage(
+                    role="FUNCTION",
+                    content=StringChatMessageContent(value=json.dumps(outputs, cls=DefaultStateEncoder)),
+                )
+            )
+
+            return self.Outputs()
+
+        node = type(
+            f"DeploymentWorkflowNode_{deployment}",
+            (FunctionNode,),
+            {
+                "run": execute_deployment_workflow_function,
+                "__module__": __name__,
+            },
+        )
+
+        return node
+
+    elif is_workflow_class(function):
         # Create a class-level wrapper that calls the original function
         def execute_inline_workflow_function(self) -> BaseNode.Outputs:
             outputs = self.state.meta.node_outputs.get(tool_router_node.Outputs.text)
@@ -246,3 +300,10 @@ def main(arguments):
         )
 
     return node
+
+
+def get_function_name(function: Tool) -> str:
+    if isinstance(function, DeploymentDefinition):
+        return function.deployment
+    else:
+        return snake_case(function.__name__)

vellum/workflows/ports/utils.py

@@ -1,6 +1,8 @@
 from collections import Counter
 from typing import List
 
+from vellum.workflows.errors.types import WorkflowErrorCode
+from vellum.workflows.exceptions import NodeException
 from vellum.workflows.ports.port import Port
 from vellum.workflows.types.core import ConditionType
 
@@ -31,14 +33,20 @@ def get_port_groups(ports: List[Port]) -> List[List[ConditionType]]:
         else:
             # If we see an ELIF or ELSE without a preceding IF, that's an error
             if not current_port_group:
-                raise ValueError(f"Class {ports_class} must have ports in the following order: on_if, on_elif, on_else")
+                raise NodeException(
+                    message=f"Class {ports_class} must have ports in the following order: on_if, on_elif, on_else",
+                    code=WorkflowErrorCode.INVALID_INPUTS,
+                )
             current_port_group.append(port_type)
 
     if current_port_group and current_port_group[0] == ConditionType.IF:
         port_groups.append(current_port_group)
     elif current_port_group:
         # If the last group doesn't start with IF, that's an error
-        raise ValueError(f"Class {ports_class} must have ports in the following order: on_if, on_elif, on_else")
+        raise NodeException(
+            message=f"Class {ports_class} must have ports in the following order: on_if, on_elif, on_else",
+            code=WorkflowErrorCode.INVALID_INPUTS,
+        )
 
     return port_groups
 
@@ -51,7 +59,10 @@ def validate_ports(ports: List[Port]) -> bool:
         # Check that each port group is in the correct order
         sorted_group = sorted(group, key=lambda port_type: PORT_TYPE_PRIORITIES[port_type])
         if sorted_group != group:
-            raise ValueError(f"Class {ports_class} must have ports in the following order: on_if, on_elif, on_else")
+            raise NodeException(
+                message=f"Class {ports_class} must have ports in the following order: on_if, on_elif, on_else",
+                code=WorkflowErrorCode.INVALID_INPUTS,
+            )
 
         # Count the types in this port group
         counter = Counter(group)
@@ -61,13 +72,22 @@ def validate_ports(ports: List[Port]) -> bool:
 
         # Apply the rules to each port group
         if number_of_if_ports != 1:
-            raise ValueError(f"Class {ports_class} must have exactly one on_if condition")
+            raise NodeException(
+                message=f"Class {ports_class} must have exactly one on_if condition",
+                code=WorkflowErrorCode.INVALID_INPUTS,
+            )
 
         if number_of_elif_ports > 0 and number_of_if_ports != 1:
-            raise ValueError(f"Class {ports_class} containing on_elif ports must have exactly one on_if condition")
+            raise NodeException(
+                message=f"Class {ports_class} containing on_elif ports must have exactly one on_if condition",
+                code=WorkflowErrorCode.INVALID_INPUTS,
+            )
 
         if number_of_else_ports > 1:
-            raise ValueError(f"Class {ports_class} must have at most one on_else condition")
+            raise NodeException(
+                message=f"Class {ports_class} must have at most one on_else condition",
+                code=WorkflowErrorCode.INVALID_INPUTS,
+            )
 
     enforce_single_invoked_conditional_port = len(port_groups) <= 1
     return enforce_single_invoked_conditional_port

vellum/workflows/runner/runner.py

@@ -3,7 +3,9 @@ from copy import deepcopy
 from dataclasses import dataclass
 import logging
 from queue import Empty, Queue
+import sys
 from threading import Event as ThreadingEvent, Thread
+import traceback
 from uuid import UUID, uuid4
 from typing import (
     TYPE_CHECKING,
@@ -346,6 +348,7 @@ class WorkflowRunner(Generic[StateType]):
             )
         except NodeException as e:
             logger.info(e)
+
             self._workflow_event_inner_queue.put(
                 NodeExecutionRejectedEvent(
                     trace_id=execution.trace_id,
@@ -370,8 +373,15 @@ class WorkflowRunner(Generic[StateType]):
                     parent=execution.parent_context,
                 )
             )
+
         except Exception as e:
-            logger.exception(f"An unexpected error occurred while running node {node.__class__.__name__}")
+            error_message = self._parse_error_message(e)
+            if error_message is None:
+                logger.exception(f"An unexpected error occurred while running node {node.__class__.__name__}")
+                error_code = WorkflowErrorCode.INTERNAL_ERROR
+                error_message = "Internal error"
+            else:
+                error_code = WorkflowErrorCode.NODE_EXECUTION
 
             self._workflow_event_inner_queue.put(
                 NodeExecutionRejectedEvent(
@@ -380,8 +390,8 @@ class WorkflowRunner(Generic[StateType]):
                     body=NodeExecutionRejectedBody(
                         node_definition=node.__class__,
                         error=WorkflowError(
-                            message=str(e),
-                            code=WorkflowErrorCode.INTERNAL_ERROR,
+                            message=error_message,
+                            code=error_code,
                         ),
                     ),
                     parent=execution.parent_context,
@@ -390,6 +400,28 @@ class WorkflowRunner(Generic[StateType]):
 
         logger.debug(f"Finished running node: {node.__class__.__name__}")
 
+    def _parse_error_message(self, exception: Exception) -> Optional[str]:
+        try:
+            _, _, tb = sys.exc_info()
+            if tb:
+                tb_list = traceback.extract_tb(tb)
+                if tb_list:
+                    last_frame = tb_list[-1]
+                    exception_module = next(
+                        (
+                            mod.__name__
+                            for mod in sys.modules.values()
+                            if hasattr(mod, "__file__") and mod.__file__ == last_frame.filename
+                        ),
+                        None,
+                    )
+                    if exception_module and not exception_module.startswith("vellum."):
+                        return str(exception)
+        except Exception:
+            pass
+
+        return None
+
     def _context_run_work_item(
         self,
         node: BaseNode[StateType],

vellum/workflows/types/core.py

@@ -1,8 +1,11 @@
 from enum import Enum
 from typing import (  # type: ignore[attr-defined]
+    TYPE_CHECKING,
     Any,
+    Callable,
     Dict,
     List,
+    Type,
     Union,
     _GenericAlias,
     _SpecialGenericAlias,
@@ -10,6 +13,11 @@ from typing import (  # type: ignore[attr-defined]
 )
 
 from vellum.client.core.pydantic_utilities import UniversalBaseModel
+from vellum.workflows.types.definition import DeploymentDefinition
+
+if TYPE_CHECKING:
+    from vellum.workflows.workflows.base import BaseWorkflow
+
 
 JsonArray = List["Json"]
 JsonObject = Dict[str, "Json"]
@@ -39,3 +47,7 @@ class ConditionType(Enum):
     IF = "IF"
     ELIF = "ELIF"
     ELSE = "ELSE"
+
+
+# Type alias for functions that can be called in tool calling nodes
+Tool = Union[Callable[..., Any], DeploymentDefinition, Type["BaseWorkflow"]]

vellum/workflows/types/definition.py

@@ -6,6 +6,7 @@ from typing import Annotated, Any, Dict, Optional, Union
 
 from pydantic import BeforeValidator
 
+from vellum.client.core.pydantic_utilities import UniversalBaseModel
 from vellum.client.types.code_resource_definition import CodeResourceDefinition as ClientCodeResourceDefinition
 
 
@@ -69,3 +70,8 @@ VellumCodeResourceDefinition = Annotated[
     CodeResourceDefinition,
     BeforeValidator(lambda d: (d if type(d) is dict else serialize_type_encoder_with_id(d))),
 ]
+
+
+class DeploymentDefinition(UniversalBaseModel):
+    deployment: str
+    release_tag: Optional[str] = "LATEST"

vellum/workflows/utils/functions.py

@@ -26,27 +26,27 @@ type_map = {
 }
 
 
-def _compile_annotation(annotation: Optional[Any], defs: dict[str, Any]) -> dict:
+def compile_annotation(annotation: Optional[Any], defs: dict[str, Any]) -> dict:
     if annotation is None:
         return {"type": "null"}
 
     if get_origin(annotation) is Union:
-        return {"anyOf": [_compile_annotation(a, defs) for a in get_args(annotation)]}
+        return {"anyOf": [compile_annotation(a, defs) for a in get_args(annotation)]}
 
     if get_origin(annotation) is dict:
         _, value_type = get_args(annotation)
-        return {"type": "object", "additionalProperties": _compile_annotation(value_type, defs)}
+        return {"type": "object", "additionalProperties": compile_annotation(value_type, defs)}
 
     if get_origin(annotation) is list:
         item_type = get_args(annotation)[0]
-        return {"type": "array", "items": _compile_annotation(item_type, defs)}
+        return {"type": "array", "items": compile_annotation(item_type, defs)}
 
     if dataclasses.is_dataclass(annotation):
         if annotation.__name__ not in defs:
             properties = {}
             required = []
             for field in dataclasses.fields(annotation):
-                properties[field.name] = _compile_annotation(field.type, defs)
+                properties[field.name] = compile_annotation(field.type, defs)
                 if field.default is dataclasses.MISSING:
                     required.append(field.name)
                 else:
@@ -61,7 +61,7 @@ def _compile_annotation(annotation: Optional[Any], defs: dict[str, Any]) -> dict
             for field_name, field in annotation.model_fields.items():
                 # Mypy is incorrect here, the `annotation` attribute is defined on `FieldInfo`
                 field_annotation = field.annotation  # type: ignore[attr-defined]
-                properties[field_name] = _compile_annotation(field_annotation, defs)
+                properties[field_name] = compile_annotation(field_annotation, defs)
                 if field.default is PydanticUndefined:
                     required.append(field_name)
                 else:
@@ -115,7 +115,7 @@ def compile_function_definition(function: Callable) -> FunctionDefinition:
     required = []
     defs: dict[str, Any] = {}
     for param in signature.parameters.values():
-        properties[param.name] = _compile_annotation(param.annotation, defs)
+        properties[param.name] = compile_annotation(param.annotation, defs)
         if param.default is inspect.Parameter.empty:
             required.append(param.name)
         else:
@@ -132,7 +132,7 @@ def compile_function_definition(function: Callable) -> FunctionDefinition:
     )
 
 
-def compile_workflow_function_definition(workflow_class: Type["BaseWorkflow"]) -> FunctionDefinition:
+def compile_inline_workflow_function_definition(workflow_class: Type["BaseWorkflow"]) -> FunctionDefinition:
     """
     Converts a base workflow class into our Vellum-native FunctionDefinition type.
     """
@@ -148,7 +148,7 @@ def compile_workflow_function_definition(workflow_class: Type["BaseWorkflow"]) -
         if name.startswith("__"):
             continue
 
-        properties[name] = _compile_annotation(field_type, defs)
+        properties[name] = compile_annotation(field_type, defs)
 
         # Check if the field has a default value
         if name not in vars_inputs_class: