vellum-ai 0.13.23__py3-none-any.whl → 0.13.25__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.13.23",
+            "X-Fern-SDK-Version": "0.13.25",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

vellum/client/types/execute_api_response.py

@@ -11,7 +11,9 @@ import pydantic
 class ExecuteApiResponse(UniversalBaseModel):
     status_code: int
     text: str
-    json_: typing_extensions.Annotated[typing.Dict[str, typing.Optional[typing.Any]], FieldMetadata(alias="json")]
+    json_: typing_extensions.Annotated[
+        typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]], FieldMetadata(alias="json")
+    ] = None
     headers: typing.Dict[str, str]
 
     if IS_PYDANTIC_V2:

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

@@ -170,11 +170,11 @@ class CodeExecutionNode(BaseNode[StateType], Generic[StateType, _OutputType], me
                         value=cast(Dict[str, Any], input_value),
                     )
                 )
-            elif isinstance(input_value, float):
+            elif isinstance(input_value, (float, int)):
                 compiled_inputs.append(
                     NumberInput(
                         name=input_name,
-                        value=input_value,
+                        value=float(input_value),
                     )
                 )
             elif isinstance(input_value, FunctionCall):

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

@@ -6,6 +6,7 @@ from vellum import CodeExecutorResponse, NumberVellumValue, StringInput
 from vellum.client.types.code_execution_package import CodeExecutionPackage
 from vellum.client.types.code_executor_secret_input import CodeExecutorSecretInput
 from vellum.client.types.function_call import FunctionCall
+from vellum.client.types.number_input import NumberInput
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.displayable.code_execution_node import CodeExecutionNode
@@ -13,7 +14,7 @@ from vellum.workflows.references.vellum_secret import VellumSecretReference
 from vellum.workflows.state.base import BaseState, StateMeta
 
 
-def test_run_workflow__happy_path(vellum_client):
+def test_run_node__happy_path(vellum_client):
     """Confirm that CodeExecutionNodes output the expected text and results when run."""
 
     # GIVEN a node that subclasses CodeExecutionNode
@@ -79,7 +80,7 @@ def main(word: str) -> int:
     )
 
 
-def test_run_workflow__code_attribute(vellum_client):
+def test_run_node__code_attribute(vellum_client):
     """Confirm that CodeExecutionNodes can use the `code` attribute to specify the code to execute."""
 
     # GIVEN a node that subclasses CodeExecutionNode
@@ -147,7 +148,7 @@ def main(word: str) -> int:
     )
 
 
-def test_run_workflow__code_and_filepath_defined(vellum_client):
+def test_run_node__code_and_filepath_defined(vellum_client):
     """Confirm that CodeExecutionNodes raise an error if both `code` and `filepath` are defined."""
 
     # GIVEN a node that subclasses CodeExecutionNode
@@ -198,7 +199,7 @@ def main(word: str) -> int:
     assert exc_info.value.message == "Cannot specify both `code` and `filepath` for a CodeExecutionNode"
 
 
-def test_run_workflow__code_and_filepath_not_defined(vellum_client):
+def test_run_node__code_and_filepath_not_defined(vellum_client):
     """Confirm that CodeExecutionNodes raise an error if neither `code` nor `filepath` are defined."""
 
     # GIVEN a node that subclasses CodeExecutionNode
@@ -241,7 +242,7 @@ def test_run_workflow__code_and_filepath_not_defined(vellum_client):
     assert exc_info.value.message == "Must specify either `code` or `filepath` for a CodeExecutionNode"
 
 
-def test_run_workflow__vellum_secret(vellum_client):
+def test_run_node__vellum_secret(vellum_client):
     """Confirm that CodeExecutionNodes can use Vellum Secrets"""
 
     # GIVEN a node that subclasses CodeExecutionNode that references a Vellum Secret
@@ -303,7 +304,53 @@ def main(word: str) -> int:
     )
 
 
-def test_run_workflow__run_inline(vellum_client):
+def test_run_node__int_input(vellum_client):
+    """Confirm that CodeExecutionNodes can use int's as inputs"""
+
+    # GIVEN a node that subclasses CodeExecutionNode that references an int
+    class State(BaseState):
+        pass
+
+    fixture = os.path.abspath(os.path.join(__file__, "../fixtures/main.py"))
+
+    class ExampleCodeExecutionNode(CodeExecutionNode[State, int]):
+        filepath = fixture
+        runtime = "PYTHON_3_11_6"
+        packages = [
+            CodeExecutionPackage(
+                name="openai",
+                version="1.0.0",
+            )
+        ]
+
+        code_inputs = {
+            "counter": 1,
+        }
+
+    # AND we know what the Code Execution Node will respond with
+    mock_code_execution = CodeExecutorResponse(
+        log="",
+        output=NumberVellumValue(value=0),
+    )
+    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": 0, "log": ""}
+
+    # AND we should have invoked the Code with the correct inputs
+    assert vellum_client.execute_code.call_args_list[0].kwargs["input_values"] == [
+        NumberInput(
+            name="counter",
+            value=1.0,
+        )
+    ]
+
+
+def test_run_node__run_inline(vellum_client):
     """Confirm that CodeExecutionNodes run the code inline instead of through Vellum under certain conditions."""
 
     # GIVEN a node that subclasses CodeExecutionNode
@@ -330,7 +377,7 @@ def main(word: str) -> int:
     vellum_client.execute_code.assert_not_called()
 
 
-def test_run_workflow__run_inline__incorrect_output_type():
+def test_run_node__run_inline__incorrect_output_type():
     """Confirm that CodeExecutionNodes raise an error if the output type is incorrect during inline execution."""
 
     # GIVEN a node that subclasses CodeExecutionNode that returns a string but is defined to return an int
@@ -354,7 +401,7 @@ def main(word: str) -> int:
     assert exc_info.value.message == "Expected an output of type 'int', but received 'str'"
 
 
-def test_run_workflow__run_inline__valid_dict_to_pydantic():
+def test_run_node__run_inline__valid_dict_to_pydantic():
     """Confirm that CodeExecutionNodes can convert a dict to a Pydantic model during inline execution."""
 
     # GIVEN a node that subclasses CodeExecutionNode that returns a dict matching a Pydantic model
@@ -380,7 +427,7 @@ def main(word: str) -> int:
     assert outputs == {"result": FunctionCall(name="hello", arguments={}), "log": ""}
 
 
-def test_run_workflow__run_inline__invalid_dict_to_pydantic():
+def test_run_node__run_inline__invalid_dict_to_pydantic():
     """Confirm that CodeExecutionNodes raise an error if the Pydantic validation fails during inline execution."""
 
     # GIVEN a node that subclasses CodeExecutionNode that returns a dict not matching a Pydantic model
@@ -416,7 +463,7 @@ name
     )
 
 
-def test_run_workflow__run_inline__valid_dict_to_pydantic_any_type():
+def test_run_node__run_inline__valid_dict_to_pydantic_any_type():
     """Confirm that CodeExecutionNodes can convert a dict to a Pydantic model during inline execution."""
 
     # GIVEN a node that subclasses CodeExecutionNode that returns a dict matching Any

vellum/workflows/references/lazy.py

@@ -1,7 +1,8 @@
 import ast
 import inspect
-from typing import TYPE_CHECKING, Callable, Generic, TypeVar, get_args
+from typing import TYPE_CHECKING, Callable, Generic, TypeVar, Union, get_args
 
+from vellum.workflows.constants import UNDEF
 from vellum.workflows.descriptors.base import BaseDescriptor
 
 if TYPE_CHECKING:
@@ -13,7 +14,7 @@ _T = TypeVar("_T")
 class LazyReference(BaseDescriptor[_T], Generic[_T]):
     def __init__(
         self,
-        get: Callable[[], BaseDescriptor[_T]],
+        get: Union[Callable[[], BaseDescriptor[_T]], str],
     ) -> None:
         self._get = get
         # TODO: figure out this some times returns empty
@@ -25,6 +26,19 @@ class LazyReference(BaseDescriptor[_T], Generic[_T]):
     def resolve(self, state: "BaseState") -> _T:
         from vellum.workflows.descriptors.utils import resolve_value
 
+        if isinstance(self._get, str):
+            # The full solution will involve creating a nodes registry on `WorkflowContext`. I want to update
+            # how WorkflowContext works so that we could just access it directly instead of it needing to be
+            # passed in, similar to get_workflow_context(). Because we don't want this to slow down p1 issues
+            # that we are debugging with existing workflows, using the following workaround for now.
+            for output_reference, value in state.meta.node_outputs.items():
+                if str(output_reference) == self._get:
+                    return value
+
+            # Fix typing surrounding the return value of node outputs/output descriptors
+            # https://app.shortcut.com/vellum/story/4783
+            return UNDEF  # type: ignore[return-value]
+
         return resolve_value(self._get(), state)
 
     def _get_name(self) -> str:
@@ -33,6 +47,9 @@ class LazyReference(BaseDescriptor[_T], Generic[_T]):
         setting that as the descriptor's name. Names are only used for debugging, so
         we could flesh out edge cases over time.
         """
+        if isinstance(self._get, str):
+            return self._get
+
         source = inspect.getsource(self._get).strip()
         try:
             parsed = ast.parse(source)

{vellum_ai-0.13.23.dist-info → vellum_ai-0.13.25.dist-info}/METADATA

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

{vellum_ai-0.13.23.dist-info → vellum_ai-0.13.25.dist-info}/RECORD

@@ -21,7 +21,7 @@ vellum_ee/workflows/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSu
 vellum_ee/workflows/display/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/display/base.py,sha256=3ZFUYRNKL24fBqXhKpa_Dq2W1a-a86J20dmJYA3H2eY,1755
 vellum_ee/workflows/display/nodes/__init__.py,sha256=5XOcZJXYUgaLS55QgRJzyQ_W1tpeprjnYAeYVezqoGw,160
-vellum_ee/workflows/display/nodes/base_node_display.py,sha256=ErIK_1DYax0LlFX4AvV1oua8I7JlpXNncjGNadVe-bo,15801
+vellum_ee/workflows/display/nodes/base_node_display.py,sha256=7RuZkNJxbyOD2w3qPr-5S11mc-iN-NydyUT4FppS62o,16849
 vellum_ee/workflows/display/nodes/base_node_vellum_display.py,sha256=pLO0dORfRu--Ne9NgoyFT_CNjfpr5fGCsgbsMkUF5GM,2845
 vellum_ee/workflows/display/nodes/get_node_display_class.py,sha256=0S6ksPp53WXWh1RQVH71nj2bkCWBj4ZaFYhTxW3N2F4,1230
 vellum_ee/workflows/display/nodes/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -35,7 +35,7 @@ vellum_ee/workflows/display/nodes/vellum/conditional_node.py,sha256=ybLIa4uclqVI
 vellum_ee/workflows/display/nodes/vellum/error_node.py,sha256=I1Jkp2htRINJATtv1e-zs9BrReFX842djpiVgBPHDYg,2186
 vellum_ee/workflows/display/nodes/vellum/final_output_node.py,sha256=p-PvlnxpBQ7IKskZi2A19jKAtKnSxJ8LPbGMA83VkFk,2805
 vellum_ee/workflows/display/nodes/vellum/guardrail_node.py,sha256=aYZSJTxknU4LMiQdWk9LcK6CkhdozeDEMiRxfAyUNEc,2202
-vellum_ee/workflows/display/nodes/vellum/inline_prompt_node.py,sha256=h8K183cZsU2b86WYQlqFtwMkwIHydnNr4ZaaQcWnFWo,7316
+vellum_ee/workflows/display/nodes/vellum/inline_prompt_node.py,sha256=7wVzx-NxWI9TnFDSgiBsaVj0l7G2v37NP4jxlTEsX_w,8375
 vellum_ee/workflows/display/nodes/vellum/inline_subworkflow_node.py,sha256=9858pFzuhkAAmLcw4gkt5mPvsqWk5vqcX_vwHOg2xZw,5610
 vellum_ee/workflows/display/nodes/vellum/map_node.py,sha256=VlO3UwkspCOdDQ-h3v8k16-7JZwWNSLpOLT4p-eirIs,3740
 vellum_ee/workflows/display/nodes/vellum/merge_node.py,sha256=HkNMgdQELiON42jdO-xDLmqrEKdGx1RVqrz2DXNTLS8,3239
@@ -57,7 +57,7 @@ vellum_ee/workflows/display/tests/workflow_serialization/__init__.py,sha256=47DE
 vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/conftest.py,sha256=EenmEdBtHUFQ0OS-kE7Vboax3JnDdj-K4Qixt5oR0Po,2253
 vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_adornments_serialization.py,sha256=KYdohS5pRgHM0DcUaK0tHa40f0gSvDKi2K5On0zNEU8,8305
-vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_attributes_serialization.py,sha256=yPXhdZxEDunNl5LL5Obb0jeO34djt7F-GiaTJhp_fmo,16742
+vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_attributes_serialization.py,sha256=1cszL6N6FNGVm61MOa7AEiHnF0QjZWqDQuPOp4yiG94,18277
 vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_outputs_serialization.py,sha256=-12ZkZb3f5gyoNASV2yeQtMo5HmNsVEo8nXwL6IC-I8,6261
 vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_ports_serialization.py,sha256=6th6kCwzql6lddjkTQx4Jbvvs4ChqtJwctW-B4QuBhI,37352
 vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_trigger_serialization.py,sha256=EbVgg_3_ipTt3MOop4RARX0fmNjwqZtkhIXzx9nGw7Y,4487
@@ -67,6 +67,7 @@ vellum_ee/workflows/display/tests/workflow_serialization/test_basic_conditional_
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_error_node_serialization.py,sha256=02gG5C0wHbjzuTgVYCsNrtW1kEOeaM_5zXmznaUKzgk,6079
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_generic_node_serialization.py,sha256=Ah8CxAxAQYnxsNasLB8esN_c9eRDQnmV_aDWC9Kp98s,5746
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_guardrail_node_serialization.py,sha256=0xK9TFqPD5Hy65T-iacZ8pjYHD8XkzZXS35rLwof7uc,7427
+vellum_ee/workflows/display/tests/workflow_serialization/test_basic_inline_prompt_node_serialization.py,sha256=XRtXTWtNXHe1g8E_mNcAhYZVjc0UcGlJRjq34_sd0jo,787
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_inline_subworkflow_serialization.py,sha256=HEfRYBVwZ6fy0hHhgsgTBEQJJAp_0wsaCJ_OtpZGdqE,20578
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_map_node_serialization.py,sha256=L1SrD5KfZjlAVh2BkOe3pCQOstVf_SiqD0KGoZlknU8,16145
 vellum_ee/workflows/display/tests/workflow_serialization/test_basic_merge_node_serialization.py,sha256=ojzdgGb2zGYloOX57V_FyXxjUqOnWMN6z8GUlF8yDMA,8422
@@ -115,7 +116,7 @@ vellum/client/README.md,sha256=JkCJjmMZl4jrPj46pkmL9dpK4gSzQQmP5I7z4aME4LY,4749
 vellum/client/__init__.py,sha256=j6zi0NZ4BMC6JrwckvzMWuG5x8KoOvO4KqsLhvVCa68,117624
 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=u1VLrEPJQZ055tQYEFf0-nEI5ccFS1CB6MysOmwok5g,1869
+vellum/client/core/client_wrapper.py,sha256=cnaRo0Of2VpkokWHVOmmYEpIO-5Jt52DALDty9NxcPs,1869
 vellum/client/core/datetime_utils.py,sha256=nBys2IsYrhPdszxGKCNRPSOCwa-5DWOHG95FB8G9PKo,1047
 vellum/client/core/file.py,sha256=X9IbmkZmB2bB_DpmZAO3crWdXagOakAyn6UCOCImCPg,2322
 vellum/client/core/http_client.py,sha256=R0pQpCppnEtxccGvXl4uJ76s7ro_65Fo_erlNNLp_AI,19228
@@ -270,7 +271,7 @@ vellum/client/types/error_vellum_value_request.py,sha256=o0aSn34dRcpnAwAfwW_sgwP
 vellum/client/types/execute_api_request_bearer_token.py,sha256=agAhp9lzfzZcYGZdzg2jHAEHCaHlqzbgp6qeeNebcto,183
 vellum/client/types/execute_api_request_body.py,sha256=MArsO_-H41lU8Lz0dB78MVcFupjWtRV7UBEljY3Dnwk,169
 vellum/client/types/execute_api_request_headers_value.py,sha256=bHtGwOpknQDcQo6qtMKqJxaYpvbinDfwx2uaPzyuZ9s,184
-vellum/client/types/execute_api_response.py,sha256=QpUDx-A2tBELMLjxhcHwJyoNm-I0d8QfdCb5f1TAOEE,804
+vellum/client/types/execute_api_response.py,sha256=1_wGY1eIF6Drwx5FEwnwBRLUxonXX7dOjhkvQakE-bw,842
 vellum/client/types/execute_prompt_event.py,sha256=wq_TZBDJcmXQhSj25jR9nMTnN-mP8Ku5Vq3rLqmwE5Q,521
 vellum/client/types/execute_prompt_response.py,sha256=n6ODveXcO8uWG-kr_B9wXziHH8JUaVTUcUAZKifClEo,334
 vellum/client/types/execute_workflow_response.py,sha256=0Q-NGPv5jpxjq6xNlHa3qUNK7yOmkU8h6Z2vQb6bHsU,1022
@@ -1369,11 +1370,11 @@ vellum/workflows/nodes/displayable/bases/tests/test_utils.py,sha256=eqdqbKNRWVMD
 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=KZ5d3_mdpsrPF_ScmEqSfBhfup421RscO9hNiGa52T4,9068
+vellum/workflows/nodes/displayable/code_execution_node/node.py,sha256=wgtqPljUqan9SILMysPCdSmZ0HoCpTTTNNaW0y9nQQI,9082
 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_code_execution_node.py,sha256=zrSgkUGaaTy-cv9h5kLBnao1Aobcn02w39wmcUx7X3I,13224
+vellum/workflows/nodes/displayable/code_execution_node/tests/test_code_execution_node.py,sha256=y_j4PieOpRYFmTqIEg1IPg-x-y_ezOcjcWCWPXYp1hI,14582
 vellum/workflows/nodes/displayable/code_execution_node/utils.py,sha256=hF9tdCpta7WN1ANz467Q9LNlISOSmp79jDIkR5d2iQM,3542
 vellum/workflows/nodes/displayable/conditional_node/__init__.py,sha256=AS_EIqFdU1F9t8aLmbZU-rLh9ry6LCJ0uj0D8F0L5Uw,72
 vellum/workflows/nodes/displayable/conditional_node/node.py,sha256=Qjfl33gZ3JEgxBA1EgzSUebboGvsARthIxxcQyvx5Gg,1152
@@ -1423,7 +1424,7 @@ vellum/workflows/references/environment_variable.py,sha256=-gfOcdYwVp9ztSUYz6h2W
 vellum/workflows/references/execution_count.py,sha256=JILHqt8ELdc9ct-WsVCA5X-rKiP1rmJODw-XTf4kpHI,722
 vellum/workflows/references/external_input.py,sha256=WyBC6uMDu77431YVSU_WvTt-nGLC_bW65tIsplUJXa4,2056
 vellum/workflows/references/input.py,sha256=3INu-TLTi4dziWmva6LO3WvgDlPzsjayUx61cVvqLJA,325
-vellum/workflows/references/lazy.py,sha256=SXwZUCTzUR-R2-uK0XHALtvp1x84l-QkNY-Ds6KynYA,1932
+vellum/workflows/references/lazy.py,sha256=HUQRXQMsCwu0JPVPCDUvQm28q8VlJQ-N8SfFyx2Tap8,2901
 vellum/workflows/references/node.py,sha256=LP854wDVs-9I_aZ7-nkbwXqL2H7W2_3LED2e9FixNS8,1418
 vellum/workflows/references/output.py,sha256=6F4zIrGykDxBsR6qEXxEKncQV5zV4yHafnHRNkxvklc,2780
 vellum/workflows/references/state_value.py,sha256=bInUF0A3Pt4-zhA0f6LdSuyv8tz7n5QRkHAEn4gsmqI,711
@@ -1464,8 +1465,8 @@ vellum/workflows/vellum_client.py,sha256=ODrq_TSl-drX2aezXegf7pizpWDVJuTXH-j6528
 vellum/workflows/workflows/__init__.py,sha256=KY45TqvavCCvXIkyCFMEc0dc6jTMOUci93U2DUrlZYc,66
 vellum/workflows/workflows/base.py,sha256=uYT0TQnEDtVaH3pErq785FhxxEEmk7C5ZGfuSO3QK8c,18537
 vellum/workflows/workflows/event_filters.py,sha256=GSxIgwrX26a1Smfd-6yss2abGCnadGsrSZGa7t7LpJA,2008
-vellum_ai-0.13.23.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
-vellum_ai-0.13.23.dist-info/METADATA,sha256=xeS3VmSv44WirfJlZ93OLirCl4GNlureoXjhZfDymC4,5335
-vellum_ai-0.13.23.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-vellum_ai-0.13.23.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
-vellum_ai-0.13.23.dist-info/RECORD,,
+vellum_ai-0.13.25.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
+vellum_ai-0.13.25.dist-info/METADATA,sha256=bJbUYjtYgNLNc58zFuoxnvydRfk7utCgEQLmbpbIhJw,5335
+vellum_ai-0.13.25.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+vellum_ai-0.13.25.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
+vellum_ai-0.13.25.dist-info/RECORD,,

vellum_ee/workflows/display/nodes/base_node_display.py

@@ -343,6 +343,27 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
             return self.serialize_value(display_context, value._value)
 
         if isinstance(value, LazyReference):
+            if isinstance(value._get, str):
+                reference_parts = value._get.split(".")
+                if len(reference_parts) < 3:
+                    raise Exception(
+                        f"Failed to parse lazy reference: {value._get}. Only Node Output references are supported."
+                    )
+
+                output_name = reference_parts[-1]
+                nested_class_name = reference_parts[-2]
+                if nested_class_name != "Outputs":
+                    raise Exception(
+                        f"Failed to parse lazy reference: {value._get}. Outputs are the only node reference supported."
+                    )
+
+                node_class_name = ".".join(reference_parts[:-2])
+                for node in display_context.node_displays.keys():
+                    if node.__name__ == node_class_name:
+                        return self.serialize_value(display_context, getattr(node.Outputs, output_name))
+
+                raise NotImplementedError(f"Failed to find a LazyReference for: {value._get}")
+
             return self.serialize_value(display_context, value._get())
 
         if isinstance(value, WorkflowInputReference):

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

@@ -1,9 +1,10 @@
 from uuid import UUID
-from typing import ClassVar, Dict, Generic, List, Optional, Tuple, Type, TypeVar, Union
+from typing import Callable, ClassVar, Dict, Generic, List, Optional, Tuple, Type, TypeVar, Union
 
-from vellum import PromptBlock, RichTextChildBlock, VellumVariable
+from vellum import FunctionDefinition, PromptBlock, RichTextChildBlock, VellumVariable
 from vellum.workflows.nodes import InlinePromptNode
 from vellum.workflows.types.core import JsonObject
+from vellum.workflows.utils.functions import compile_function_definition
 from vellum.workflows.utils.uuids import uuid4_from_hash
 from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
 from vellum_ee.workflows.display.nodes.utils import raise_if_descriptor
@@ -32,6 +33,17 @@ class BaseInlinePromptNodeDisplay(BaseNodeVellumDisplay[_InlinePromptNodeType],
         _, output_display = display_context.global_node_output_displays[node.Outputs.text]
         _, array_display = display_context.global_node_output_displays[node.Outputs.results]
         node_blocks = raise_if_descriptor(node.blocks)
+        function_definitions = raise_if_descriptor(node.functions)
+
+        blocks: list = [
+            self._generate_prompt_block(block, input_variable_id_by_name, [i]) for i, block in enumerate(node_blocks)
+        ]
+        functions = (
+            [self._generate_function_tools(function) for function in function_definitions]
+            if function_definitions
+            else []
+        )
+        blocks.extend(functions)
 
         return {
             "id": str(node_id),
@@ -50,10 +62,7 @@ class BaseInlinePromptNodeDisplay(BaseNodeVellumDisplay[_InlinePromptNodeType],
                     "input_variables": [prompt_input.dict() for prompt_input in prompt_inputs],
                     "prompt_template_block_data": {
                         "version": 1,
-                        "blocks": [
-                            self._generate_prompt_block(block, input_variable_id_by_name, [i])
-                            for i, block in enumerate(node_blocks)
-                        ],
+                        "blocks": blocks,
                     },
                 },
                 "ml_model_name": raise_if_descriptor(node.ml_model),
@@ -91,6 +100,21 @@ class BaseInlinePromptNodeDisplay(BaseNodeVellumDisplay[_InlinePromptNodeType],
 
         return node_inputs, prompt_inputs
 
+    def _generate_function_tools(self, function: Union[FunctionDefinition, Callable]) -> JsonObject:
+        normalized_functions = (
+            function if isinstance(function, FunctionDefinition) else compile_function_definition(function)
+        )
+        return {
+            "block_type": "FUNCTION_DEFINITION",
+            "properties": {
+                "function_name": normalized_functions.name,
+                "function_description": normalized_functions.description,
+                "function_parameters": normalized_functions.parameters,
+                "function_forced": normalized_functions.forced,
+                "function_strict": normalized_functions.strict,
+            },
+        }
+
     def _generate_prompt_block(
         self,
         prompt_block: Union[PromptBlock, RichTextChildBlock],

vellum_ee/workflows/display/tests/workflow_serialization/generic_nodes/test_attributes_serialization.py

@@ -7,9 +7,12 @@ from vellum.workflows.nodes.bases.base import BaseNode
 from vellum.workflows.references.constant import ConstantValueReference
 from vellum.workflows.references.lazy import LazyReference
 from vellum.workflows.references.vellum_secret import VellumSecretReference
+from vellum.workflows.workflows.base import BaseWorkflow
 from vellum_ee.workflows.display.base import WorkflowInputsDisplay
 from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
 from vellum_ee.workflows.display.nodes.types import NodeOutputDisplay
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+from vellum_ee.workflows.display.workflows.vellum_workflow_display import VellumWorkflowDisplay
 
 
 class Inputs(BaseInputs):
@@ -151,6 +154,43 @@ def test_serialize_node__lazy_reference(serialize_node):
     )
 
 
+def test_serialize_node__lazy_reference_with_string():
+    # GIVEN two nodes with one lazily referencing the other
+    class LazyReferenceGenericNode(BaseNode):
+        attr = LazyReference[str]("OtherNode.Outputs.result")
+
+    class OtherNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            result: str
+
+    # AND a workflow with both nodes
+    class Workflow(BaseWorkflow):
+        graph = LazyReferenceGenericNode >> OtherNode
+
+    # WHEN the workflow is serialized
+    workflow_display = get_workflow_display(base_display_class=VellumWorkflowDisplay, workflow_class=Workflow)
+    serialized_workflow: dict = workflow_display.serialize()
+
+    # THEN the node should properly serialize the attribute reference
+    lazy_reference_node = next(
+        node
+        for node in serialized_workflow["workflow_raw_data"]["nodes"]
+        if node["id"] == str(LazyReferenceGenericNode.__id__)
+    )
+
+    assert lazy_reference_node["attributes"] == [
+        {
+            "id": "98833d71-42a8-47e9-81c4-6a35646e3d3c",
+            "name": "attr",
+            "value": {
+                "type": "NODE_OUTPUT",
+                "node_id": str(OtherNode.__id__),
+                "node_output_id": "7a3406a1-6f11-4568-8aa0-e5dba6534dc2",
+            },
+        }
+    ]
+
+
 class WorkflowInputGenericNode(BaseNode):
     attr: str = Inputs.input
 

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

@@ -0,0 +1,18 @@
+from vellum_ee.workflows.display.workflows import VellumWorkflowDisplay
+from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
+
+from tests.workflows.basic_inline_prompt_node_with_functions.workflow import BasicInlinePromptWithFunctionsWorkflow
+
+
+def test_serialize_workflow():
+    # WHEN we serialize it
+    workflow_display = get_workflow_display(
+        base_display_class=VellumWorkflowDisplay, workflow_class=BasicInlinePromptWithFunctionsWorkflow
+    )
+    serialized_workflow: dict = workflow_display.serialize()
+    assert (
+        serialized_workflow["workflow_raw_data"]["nodes"][-2]["data"]["exec_config"]["prompt_template_block_data"][
+            "blocks"
+        ][-1]["block_type"]
+        == "FUNCTION_DEFINITION"
+    )