vellum-ai 0.13.22__py3-none-any.whl → 0.13.24__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.22",
+            "X-Fern-SDK-Version": "0.13.24",
         }
         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/api_node/node.py

@@ -33,6 +33,7 @@ class APINode(BaseAPINode):
     def run(self) -> BaseAPINode.Outputs:
         headers = self.headers or {}
         header_overrides = {}
+        bearer_token = None
 
         if (
             self.authorization_type == AuthorizationType.API_KEY
@@ -40,9 +41,17 @@ class APINode(BaseAPINode):
             and self.api_key_header_value
         ):
             header_overrides[self.api_key_header_key] = self.api_key_header_value
-        elif self.authorization_type == AuthorizationType.BEARER_TOKEN:
+        elif self.authorization_type == AuthorizationType.BEARER_TOKEN and isinstance(self.bearer_token_value, str):
             header_overrides["Authorization"] = f"Bearer {self.bearer_token_value}"
-
+        elif self.authorization_type == AuthorizationType.BEARER_TOKEN and isinstance(
+            self.bearer_token_value, VellumSecret
+        ):
+            bearer_token = self.bearer_token_value
         return self._run(
-            method=self.method, url=self.url, data=self.data, json=self.json, headers={**headers, **header_overrides}
+            method=self.method,
+            url=self.url,
+            data=self.data or self.json,
+            json=self.json,
+            headers={**headers, **header_overrides},
+            bearer_token=bearer_token,
         )

vellum/workflows/nodes/displayable/api_node/tests/test_api_node.py

@@ -0,0 +1,34 @@
+from vellum import ExecuteApiResponse, VellumSecret as ClientVellumSecret
+from vellum.workflows.constants import APIRequestMethod, AuthorizationType
+from vellum.workflows.nodes import APINode
+from vellum.workflows.state import BaseState
+from vellum.workflows.types.core import VellumSecret
+
+
+def test_run_workflow__secrets(vellum_client):
+    vellum_client.execute_api.return_value = ExecuteApiResponse(
+        status_code=200,
+        text='{"status": 200, "data": [1, 2, 3]}',
+        json_={"data": [1, 2, 3]},
+        headers={"X-Response-Header": "bar"},
+    )
+
+    class SimpleBaseAPINode(APINode):
+        method = APIRequestMethod.POST
+        authorization_type = AuthorizationType.BEARER_TOKEN
+        url = "https://api.vellum.ai"
+        body = {
+            "key": "value",
+        }
+        headers = {
+            "X-Test-Header": "foo",
+        }
+        bearer_token_value = VellumSecret(name="secret")
+
+    node = SimpleBaseAPINode(state=BaseState())
+    terminal = node.run()
+
+    assert vellum_client.execute_api.call_count == 1
+    bearer_token = vellum_client.execute_api.call_args.kwargs["bearer_token"]
+    assert bearer_token == ClientVellumSecret(name="secret")
+    assert terminal.headers == {"X-Response-Header": "bar"}

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

@@ -3,6 +3,7 @@ from typing import Any, Dict, Generic, Optional, Union
 from requests import Request, RequestException, Session
 from requests.exceptions import JSONDecodeError
 
+from vellum.client.types.vellum_secret import VellumSecret as ClientVellumSecret
 from vellum.workflows.constants import APIRequestMethod
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
@@ -45,29 +46,49 @@ class BaseAPINode(BaseNode, Generic[StateType]):
         self,
         method: APIRequestMethod,
         url: str,
-        data: Optional[str] = None,
+        data: Optional[Union[str, Any]] = None,
         json: Any = None,
         headers: Any = None,
+        bearer_token: Optional[VellumSecret] = None,
     ) -> Outputs:
+        vellum_instance = False
+        for header in headers or {}:
+            if isinstance(headers[header], VellumSecret):
+                vellum_instance = True
+        if vellum_instance or bearer_token:
+            return self._vellum_execute_api(bearer_token, data, headers, method, url)
+        else:
+            return self._local_execute_api(data, headers, json, method, url)
+
+    def _local_execute_api(self, data, headers, json, method, url):
         try:
             prepped = Request(method=method.value, url=url, data=data, json=json, headers=headers).prepare()
         except Exception as e:
             raise NodeException(f"Failed to prepare HTTP request: {e}", code=WorkflowErrorCode.PROVIDER_ERROR)
-
         try:
             with Session() as session:
                 response = session.send(prepped)
         except RequestException as e:
             raise NodeException(f"HTTP request failed: {e}", code=WorkflowErrorCode.PROVIDER_ERROR)
-
         try:
             json = response.json()
         except JSONDecodeError:
             json = None
-
         return self.Outputs(
             json=json,
             headers={header: value for header, value in response.headers.items()},
             status_code=response.status_code,
             text=response.text,
         )
+
+    def _vellum_execute_api(self, bearer_token, data, headers, method, url):
+        client_vellum_secret = ClientVellumSecret(name=bearer_token.name) if bearer_token else None
+        vellum_response = self._context.vellum_client.execute_api(
+            url=url, method=method.value, body=data, headers=headers, bearer_token=client_vellum_secret
+        )
+        return self.Outputs(
+            json=vellum_response.json_,
+            headers={header: value for header, value in vellum_response.headers.items()},
+            status_code=vellum_response.status_code,
+            text=vellum_response.text,
+        )

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

@@ -1,6 +1,6 @@
 import json
 from uuid import UUID
-from typing import Any, ClassVar, Dict, Generic, Iterator, List, Optional, Sequence, Union, cast
+from typing import Any, ClassVar, Dict, Generic, Iterator, List, Optional, Sequence, Union
 
 from vellum import (
     ChatHistoryInputRequest,
@@ -95,10 +95,19 @@ class BasePromptDeploymentNode(BasePromptNode, Generic[StateType]):
             elif isinstance(input_value, list) 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(
                     ChatHistoryInputRequest(
                         name=input_name,
-                        value=cast(List[ChatMessage], input_value),
+                        value=chat_history,
                     )
                 )
             else:

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

@@ -1,10 +1,12 @@
 import pytest
 import os
+from typing import Any
 
 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
@@ -12,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
@@ -78,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
@@ -146,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
@@ -197,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
@@ -240,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
@@ -302,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
@@ -329,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
@@ -353,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
@@ -379,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
@@ -413,3 +461,35 @@ name
   Field required [type=missing, input_value={'n': 'hello', 'a': {}}, input_type=dict]\
 """
     )
+
+
+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
+    class ExampleCodeExecutionNode(CodeExecutionNode[BaseState, Any]):
+        code = """\
+def main(word: str) -> dict:
+    return {
+        "name": "word",
+        "arguments": {},
+    }
+    """
+        runtime = "PYTHON_3_11_6"
+
+        code_inputs = {
+            "word": "hello",
+        }
+
+    # WHEN we run the node
+    node = ExampleCodeExecutionNode()
+    outputs = node.run()
+
+    # THEN the node should have produced the outputs we expect
+    assert outputs == {
+        "result": {
+            "name": "word",
+            "arguments": {},
+        },
+        "log": "",
+    }

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

@@ -91,19 +91,21 @@ __arg__out = main({", ".join(run_args)})
     logs = log_buffer.getvalue()
     result = exec_globals["__arg__out"]
 
-    if issubclass(output_type, BaseModel) and not isinstance(result, output_type):
-        try:
-            result = output_type.model_validate(result)
-        except ValidationError as e:
+    if output_type != Any:
+        if issubclass(output_type, BaseModel) and not isinstance(result, output_type):
+            try:
+                result = output_type.model_validate(result)
+            except ValidationError as e:
+                raise NodeException(
+                    code=WorkflowErrorCode.INVALID_OUTPUTS,
+                    message=re.sub(r"\s+For further information visit [^\s]+", "", str(e)),
+                ) from e
+
+        if not isinstance(result, output_type):
             raise NodeException(
                 code=WorkflowErrorCode.INVALID_OUTPUTS,
-                message=re.sub(r"\s+For further information visit [^\s]+", "", str(e)),
-            ) from e
-
-    if not isinstance(result, output_type):
-        raise NodeException(
-            code=WorkflowErrorCode.INVALID_OUTPUTS,
-            message=f"Expected an output of type '{output_type.__name__}', but received '{result.__class__.__name__}'",
-        )
+                message=f"Expected an output of type '{output_type.__name__}',"
+                f" but received '{result.__class__.__name__}'",
+            )
 
     return logs, result

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

@@ -1,7 +1,9 @@
+import pytest
 from uuid import uuid4
 from typing import Any, Iterator, List
 
 from vellum.client.types.chat_history_input_request import ChatHistoryInputRequest
+from vellum.client.types.chat_message import ChatMessage
 from vellum.client.types.chat_message_request import ChatMessageRequest
 from vellum.client.types.execute_prompt_event import ExecutePromptEvent
 from vellum.client.types.fulfilled_execute_prompt_event import FulfilledExecutePromptEvent
@@ -11,14 +13,15 @@ from vellum.client.types.string_vellum_value import StringVellumValue
 from vellum.workflows.nodes.displayable.prompt_deployment_node.node import PromptDeploymentNode
 
 
-def test_run_node__chat_history_input(vellum_client):
+@pytest.mark.parametrize("ChatMessageClass", [ChatMessageRequest, ChatMessage])
+def test_run_node__chat_history_input(vellum_client, ChatMessageClass):
     """Confirm that we can successfully invoke a Prompt Deployment Node that uses Chat History Inputs"""
 
     # GIVEN a Prompt Deployment Node
     class ExamplePromptDeploymentNode(PromptDeploymentNode):
         deployment = "example_prompt_deployment"
         prompt_inputs = {
-            "chat_history": [ChatMessageRequest(role="USER", text="Hello, how are you?")],
+            "chat_history": [ChatMessageClass(role="USER", text="Hello, how are you?")],
         }
 
     # AND we know what the Prompt Deployment will respond with

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

@@ -72,10 +72,19 @@ class SubworkflowDeploymentNode(BaseNode[StateType], Generic[StateType]):
             elif isinstance(input_value, list) 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=cast(List[ChatMessage], input_value),
+                        value=chat_history,
                     )
                 )
             elif isinstance(input_value, dict):

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

@@ -1,7 +1,9 @@
+import pytest
 from datetime import datetime
 from uuid import uuid4
 from typing import Any, Iterator, List
 
+from vellum.client.types.chat_message import ChatMessage
 from vellum.client.types.chat_message_request import ChatMessageRequest
 from vellum.client.types.workflow_execution_workflow_result_event import WorkflowExecutionWorkflowResultEvent
 from vellum.client.types.workflow_output_string import WorkflowOutputString
@@ -12,14 +14,15 @@ from vellum.client.types.workflow_stream_event import WorkflowStreamEvent
 from vellum.workflows.nodes.displayable.subworkflow_deployment_node.node import SubworkflowDeploymentNode
 
 
-def test_run_workflow__chat_history_input(vellum_client):
+@pytest.mark.parametrize("ChatMessageClass", [ChatMessageRequest, ChatMessage])
+def test_run_workflow__chat_history_input(vellum_client, ChatMessageClass):
     """Confirm that we can successfully invoke a Subworkflow Deployment Node that uses Chat History Inputs"""
 
     # GIVEN a Subworkflow Deployment Node
     class ExampleSubworkflowDeploymentNode(SubworkflowDeploymentNode):
         deployment = "example_subworkflow_deployment"
         subworkflow_inputs = {
-            "chat_history": [ChatMessageRequest(role="USER", text="Hello, how are you?")],
+            "chat_history": [ChatMessageClass(role="USER", text="Hello, how are you?")],
         }
 
     # AND we know what the Subworkflow Deployment will respond with

{vellum_ai-0.13.22.dist-info → vellum_ai-0.13.24.dist-info}/METADATA

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

{vellum_ai-0.13.22.dist-info → vellum_ai-0.13.24.dist-info}/RECORD

@@ -80,7 +80,7 @@ vellum_ee/workflows/display/tests/workflow_serialization/test_complex_terminal_n
 vellum_ee/workflows/display/types.py,sha256=s1w2KELKI2kde4G2M3iniOEdPObNKYgYtr31sAgZqRI,2644
 vellum_ee/workflows/display/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum_ee/workflows/display/utils/vellum.py,sha256=IGHobHz0QG8TWdJNxlQ81khCmJv7piLjE64l4zc33kI,7743
-vellum_ee/workflows/display/vellum.py,sha256=-95xvit30nyP6Md29nHkfIrnFButZyCg8wz76oUHD0M,8105
+vellum_ee/workflows/display/vellum.py,sha256=1mcZQQ4gd5GYrVKgIQ3ejy8SqRss2CWUL0KMf44zgUc,8122
 vellum_ee/workflows/display/workflows/__init__.py,sha256=kapXsC67VJcgSuiBMa86FdePG5A9kMB5Pi4Uy1O2ob4,207
 vellum_ee/workflows/display/workflows/base_workflow_display.py,sha256=8inuxnxeJbysEhJIGdxLZTvQ2aPJj-OSGmSeotwe7fo,15782
 vellum_ee/workflows/display/workflows/get_vellum_workflow_display_class.py,sha256=kp0u8LN_2IwshLrhMImhpZx1hRyAcD5gXY-kDuuaGMQ,1269
@@ -115,7 +115,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=UHqsduK36o9isKel9Qci9hZN43L7ZADRoyzO7Xlx5Ws,1869
+vellum/client/core/client_wrapper.py,sha256=CHUMF1rAO0mKKIpxyLeUmpjLICY4ZwyiCpiYCjAnHwE,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 +270,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
@@ -1351,28 +1351,30 @@ vellum/workflows/nodes/core/try_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW
 vellum/workflows/nodes/core/try_node/tests/test_node.py,sha256=Wc2kLl-MkffsBxl3IiFaqLd16e2Iosxhk7qBnojPvQg,4092
 vellum/workflows/nodes/displayable/__init__.py,sha256=6F_4DlSwvHuilWnIalp8iDjjDXl0Nmz4QzJV2PYe5RI,1023
 vellum/workflows/nodes/displayable/api_node/__init__.py,sha256=MoxdQSnidIj1Nf_d-hTxlOxcZXaZnsWFDbE-PkTK24o,56
-vellum/workflows/nodes/displayable/api_node/node.py,sha256=KHuDTzOeXO3lCQm3lQqusAEhj84dhvszVpO1Xsx4qPM,2175
+vellum/workflows/nodes/displayable/api_node/node.py,sha256=QdpsyGVxo5PcN8nwGZpcpW_YMKHr3_VvmbK1BlrdOFk,2547
+vellum/workflows/nodes/displayable/api_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vellum/workflows/nodes/displayable/api_node/tests/test_api_node.py,sha256=yo3zTMRxgpSdWmJ68X610A5rrtCchyfqhcDd2X-GJiU,1249
 vellum/workflows/nodes/displayable/bases/__init__.py,sha256=0mWIx3qUrzllV7jqt7wN03vWGMuI1WrrLZeMLT2Cl2c,304
 vellum/workflows/nodes/displayable/bases/api_node/__init__.py,sha256=1jwx4WC358CLA1jgzl_UD-rZmdMm2v9Mps39ndwCD7U,64
-vellum/workflows/nodes/displayable/bases/api_node/node.py,sha256=kKiwrz8XGJkvFjipBthxs9h1e2ndWPgmpEzZiYs0I5I,2579
+vellum/workflows/nodes/displayable/bases/api_node/node.py,sha256=nIFkP7eeXXSzOVUoQgjPPCzy3_P083X_F5fCm2OAjdU,3798
 vellum/workflows/nodes/displayable/bases/base_prompt_node/__init__.py,sha256=Org3xTvgp1pA0uUXFfnJr29D3HzCey2lEdYF4zbIUgo,70
 vellum/workflows/nodes/displayable/bases/base_prompt_node/node.py,sha256=r_gOmeGFQQfzhAc1_bmzcwUvH-Xllc93gE7miTV4rQE,2824
 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=UrmI8NkNJFGq9f59gD12S1e8D_R3ROHc934JmtfQk9I,6841
-vellum/workflows/nodes/displayable/bases/prompt_deployment_node.py,sha256=tOhBHKBdGAIfZWr5HcQdA3JE7GXvYZ7-YyX2x0ptwJc,5339
+vellum/workflows/nodes/displayable/bases/prompt_deployment_node.py,sha256=NbwLOoWG5VVcnwL63WmaYck87y2QW36-JQWerOlKyx4,5713
 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=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=ueVDw0GTSGzBZMFLs0NTir_0AE-pUrAYvpgg3Stex7Q,12350
-vellum/workflows/nodes/displayable/code_execution_node/utils.py,sha256=zRYM7B2t7355LzaAn6LkIn4tM5K7eQ0Kvje4NO6Kq30,3443
+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
 vellum/workflows/nodes/displayable/final_output_node/__init__.py,sha256=G7VXM4OWpubvSJtVkGmMNeqgb9GkM7qZT838eL18XU4,72
@@ -1390,15 +1392,15 @@ vellum/workflows/nodes/displayable/note_node/node.py,sha256=sIN1VBQ7zeT3GhN0kupX
 vellum/workflows/nodes/displayable/prompt_deployment_node/__init__.py,sha256=krX1Hds-TSVYZsx0wJFX4wsAKkEFYOX1ifwRGiIM-EA,82
 vellum/workflows/nodes/displayable/prompt_deployment_node/node.py,sha256=ruOgvpg_9KV_HkovPQeu6TKpur9DT_J4CYQo50tULCY,2680
 vellum/workflows/nodes/displayable/prompt_deployment_node/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vellum/workflows/nodes/displayable/prompt_deployment_node/tests/test_node.py,sha256=TO4wHNH1FASQxcM5-S8gMeC1k5HEISYcpzKy3cA0a6E,3772
+vellum/workflows/nodes/displayable/prompt_deployment_node/tests/test_node.py,sha256=ymEwMwrwRuQGyvkTnqeRZvfK7dhnf-kmRJTuwlycNjI,3939
 vellum/workflows/nodes/displayable/search_node/__init__.py,sha256=hpBpvbrDYf43DElRZFLzieSn8weXiwNiiNOJurERQbs,62
 vellum/workflows/nodes/displayable/search_node/node.py,sha256=_VHHuTNN4icZBgc7O5U9SVKrv1zgKipU72fOtxTyrQU,1453
 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=2-QCV7Vk_-YMls33p0GOUtCv3f2uPNZCjkB2CRjek7o,6562
 vellum/workflows/nodes/displayable/subworkflow_deployment_node/__init__.py,sha256=9yYM6001YZeqI1VOk1QuEM_yrffk_EdsO7qaPzINKds,92
-vellum/workflows/nodes/displayable/subworkflow_deployment_node/node.py,sha256=DAbSMN4GHBe-uTzJV-EcRfaRue113VrKl5m2SmA6Emc,7927
+vellum/workflows/nodes/displayable/subworkflow_deployment_node/node.py,sha256=sSRo_zX5QVI7V0qmReWMBkEa78HfQfjNIKwvKh7-Om8,8307
 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=U5Y0WbceRbCtfgX759gIsbK2htg3eVdSe1mOiwdUbjw,5278
+vellum/workflows/nodes/displayable/subworkflow_deployment_node/tests/test_node.py,sha256=c8RP-QnsERzIinVytAc0jVZ9nd7Jl3hbc9-_yG91Ros,5445
 vellum/workflows/nodes/displayable/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vellum/workflows/nodes/displayable/tests/test_inline_text_prompt_node.py,sha256=CI7iMyyIlnds1rkVSjICOFg2UY0yV51NTKtKpfeEME4,4677
 vellum/workflows/nodes/displayable/tests/test_search_node_wth_text_output.py,sha256=VepO5z1277c1y5N6LLIC31nnWD1aak2m5oPFplfJHHs,6935
@@ -1462,8 +1464,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.22.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
-vellum_ai-0.13.22.dist-info/METADATA,sha256=FKumzqZLqMjy0V1ohc4uZKBhxHBqQnoPPMXOR261yho,5335
-vellum_ai-0.13.22.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-vellum_ai-0.13.22.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
-vellum_ai-0.13.22.dist-info/RECORD,,
+vellum_ai-0.13.24.dist-info/LICENSE,sha256=hOypcdt481qGNISA784bnAGWAE6tyIf9gc2E78mYC3E,1574
+vellum_ai-0.13.24.dist-info/METADATA,sha256=6i1_pGA_JzLwbgGSvPKSioG96wTBmf5XnTrvtVKPcZM,5335
+vellum_ai-0.13.24.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+vellum_ai-0.13.24.dist-info/entry_points.txt,sha256=HCH4yc_V3J_nDv3qJzZ_nYS8llCHZViCDP1ejgCc5Ak,42
+vellum_ai-0.13.24.dist-info/RECORD,,

vellum_ee/workflows/display/vellum.py

@@ -113,8 +113,8 @@ class WorkflowOutputVellumDisplayOverrides(WorkflowOutputDisplay, WorkflowOutput
     name: str
     label: str
     node_id: UUID
-    target_handle_id: UUID
     display_data: NodeDisplayData
+    target_handle_id: Optional[UUID] = None
 
 
 @dataclass