vellum-ai 0.13.22__tar.gz → 0.13.24__tar.gz

{vellum_ai-0.13.22 → vellum_ai-0.13.24}/PKG-INFO

@@ -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 → vellum_ai-0.13.24}/ee/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

{vellum_ai-0.13.22 → vellum_ai-0.13.24}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "vellum-ai"
-version = "0.13.22"
+version = "0.13.24"
 description = ""
 readme = "README.md"
 authors = []

{vellum_ai-0.13.22 → vellum_ai-0.13.24}/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.13.22",
+            "X-Fern-SDK-Version": "0.13.24",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

{vellum_ai-0.13.22 → vellum_ai-0.13.24}/src/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_ai-0.13.22 → vellum_ai-0.13.24}/src/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_ai-0.13.24/src/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_ai-0.13.22 → vellum_ai-0.13.24}/src/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_ai-0.13.22 → vellum_ai-0.13.24}/src/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_ai-0.13.22 → vellum_ai-0.13.24}/src/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_ai-0.13.22 → vellum_ai-0.13.24}/src/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_ai-0.13.22 → vellum_ai-0.13.24}/src/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_ai-0.13.22 → vellum_ai-0.13.24}/src/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_ai-0.13.22 → vellum_ai-0.13.24}/src/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_ai-0.13.22 → vellum_ai-0.13.24}/src/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