vellum-ai 1.3.6__tar.gz → 1.3.8__tar.gz

{vellum_ai-1.3.6 → vellum_ai-1.3.8}/PKG-INFO

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

{vellum_ai-1.3.6 → vellum_ai-1.3.8}/ee/vellum_ee/workflows/display/nodes/vellum/tests/test_prompt_deployment_node.py

@@ -3,6 +3,20 @@ from datetime import datetime
 from uuid import UUID, uuid4
 from typing import Type
 
+from vellum import (
+    AudioInputRequest,
+    DocumentInputRequest,
+    ImageInputRequest,
+    VellumAudio,
+    VellumAudioRequest,
+    VellumDocument,
+    VellumDocumentRequest,
+    VellumImage,
+    VellumImageRequest,
+    VellumVideo,
+    VellumVideoRequest,
+    VideoInputRequest,
+)
 from vellum.workflows import BaseWorkflow
 from vellum.workflows.nodes import PromptDeploymentNode
 from vellum_ee.workflows.display.nodes.vellum.prompt_deployment_node import BasePromptDeploymentNodeDisplay
@@ -105,3 +119,59 @@ def test_serialize_node__prompt_inputs(GetDisplayClass, expected_input_id, mock_
             },
         }
     ]
+
+
+@pytest.mark.parametrize(
+    [
+        "raw_input",
+        "expected_compiled_inputs",
+    ],
+    [
+        # Cast VellumX -> VellumXRequest
+        (
+            VellumAudio(src="data:audio/wav;base64,mockaudio"),
+            [AudioInputRequest(name="file_input", value=VellumAudioRequest(src="data:audio/wav;base64,mockaudio"))],
+        ),
+        (
+            VellumImage(src="data:image/png;base64,mockimage"),
+            [ImageInputRequest(name="file_input", value=VellumImageRequest(src="data:image/png;base64,mockimage"))],
+        ),
+        (
+            VellumVideo(src="data:video/mp4;base64,mockvideo"),
+            [VideoInputRequest(name="file_input", value=VellumVideoRequest(src="data:video/mp4;base64,mockvideo"))],
+        ),
+        (
+            VellumDocument(src="mockdocument"),
+            [DocumentInputRequest(name="file_input", value=VellumDocumentRequest(src="mockdocument"))],
+        ),
+        # No casting required
+        (
+            VellumAudioRequest(src="data:audio/wav;base64,mockaudio"),
+            [AudioInputRequest(name="file_input", value=VellumAudioRequest(src="data:audio/wav;base64,mockaudio"))],
+        ),
+        (
+            VellumImageRequest(src="data:image/png;base64,mockimage"),
+            [ImageInputRequest(name="file_input", value=VellumImageRequest(src="data:image/png;base64,mockimage"))],
+        ),
+        (
+            VellumVideoRequest(src="data:video/mp4;base64,mockvideo"),
+            [VideoInputRequest(name="file_input", value=VellumVideoRequest(src="data:video/mp4;base64,mockvideo"))],
+        ),
+        (
+            VellumDocumentRequest(src="mockdocument"),
+            [DocumentInputRequest(name="file_input", value=VellumDocumentRequest(src="mockdocument"))],
+        ),
+    ],
+)
+def test_file_input_compilation(raw_input, expected_compiled_inputs):
+    # GIVEN a prompt node with file input
+    class MyPromptDeploymentNode(PromptDeploymentNode):
+        deployment = "DEPLOYMENT"
+        prompt_inputs = {"file_input": raw_input}
+        ml_model_fallbacks = None
+
+    # WHEN we compile the inputs
+    compiled_inputs = MyPromptDeploymentNode()._compile_prompt_inputs()
+
+    # THEN we should get the correct input type
+    assert compiled_inputs == expected_compiled_inputs

{vellum_ai-1.3.6 → vellum_ai-1.3.8}/pyproject.toml

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

{vellum_ai-1.3.6 → vellum_ai-1.3.8}/src/vellum/client/core/client_wrapper.py

@@ -27,10 +27,10 @@ class BaseClientWrapper:
 
     def get_headers(self) -> typing.Dict[str, str]:
         headers: typing.Dict[str, str] = {
-            "User-Agent": "vellum-ai/1.3.6",
+            "User-Agent": "vellum-ai/1.3.8",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "1.3.6",
+            "X-Fern-SDK-Version": "1.3.8",
             **(self.get_custom_headers() or {}),
         }
         if self._api_version is not None:

{vellum_ai-1.3.6 → vellum_ai-1.3.8}/src/vellum/client/types/node_execution_rejected_body.py

@@ -11,6 +11,7 @@ from .vellum_sdk_error import VellumSdkError
 class NodeExecutionRejectedBody(UniversalBaseModel):
     node_definition: VellumCodeResourceDefinition
     error: VellumSdkError
+    stacktrace: typing.Optional[str] = None
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2

{vellum_ai-1.3.6 → vellum_ai-1.3.8}/src/vellum/client/types/workflow_event_error.py

@@ -10,6 +10,7 @@ from .workflow_execution_event_error_code import WorkflowExecutionEventErrorCode
 class WorkflowEventError(UniversalBaseModel):
     message: str
     code: WorkflowExecutionEventErrorCode
+    stacktrace: typing.Optional[str] = None
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2

{vellum_ai-1.3.6 → vellum_ai-1.3.8}/src/vellum/client/types/workflow_execution_rejected_body.py

@@ -11,6 +11,7 @@ from .vellum_sdk_error import VellumSdkError
 class WorkflowExecutionRejectedBody(UniversalBaseModel):
     workflow_definition: VellumCodeResourceDefinition
     error: VellumSdkError
+    stacktrace: typing.Optional[str] = None
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2

vellum_ai-1.3.8/src/vellum/workflows/descriptors/exceptions.py

@@ -0,0 +1,19 @@
+from vellum.workflows.errors import WorkflowError, WorkflowErrorCode
+
+
+class InvalidExpressionException(Exception):
+    def __init__(self, message: str, code: WorkflowErrorCode = WorkflowErrorCode.NODE_EXECUTION):
+        self.message = message
+        self.code = code
+        super().__init__(message)
+
+    @property
+    def error(self) -> WorkflowError:
+        return WorkflowError(
+            message=self.message,
+            code=self.code,
+        )
+
+    @staticmethod
+    def of(workflow_error: WorkflowError) -> "InvalidExpressionException":
+        return InvalidExpressionException(message=workflow_error.message, code=workflow_error.code)

{vellum_ai-1.3.6 → vellum_ai-1.3.8}/src/vellum/workflows/nodes/displayable/bases/inline_prompt_node/node.py

@@ -17,6 +17,20 @@ from vellum import (
     VellumVariable,
 )
 from vellum.client import ApiError, RequestOptions
+from vellum.client.types import (
+    PromptRequestAudioInput,
+    PromptRequestDocumentInput,
+    PromptRequestImageInput,
+    PromptRequestVideoInput,
+    VellumAudio,
+    VellumAudioRequest,
+    VellumDocument,
+    VellumDocumentRequest,
+    VellumImage,
+    VellumImageRequest,
+    VellumVideo,
+    VellumVideoRequest,
+)
 from vellum.client.types.chat_message_request import ChatMessageRequest
 from vellum.client.types.prompt_exec_config import PromptExecConfig
 from vellum.client.types.prompt_settings import PromptSettings
@@ -273,6 +287,78 @@ class BaseInlinePromptNode(BasePromptNode[StateType], Generic[StateType]):
                         value=chat_history,
                     )
                 )
+            elif isinstance(input_value, (VellumAudio, VellumAudioRequest)):
+                input_variables.append(
+                    VellumVariable(
+                        id=str(uuid4()),
+                        key=input_name,
+                        type="AUDIO",
+                    )
+                )
+                input_values.append(
+                    PromptRequestAudioInput(
+                        key=input_name,
+                        value=(
+                            input_value
+                            if isinstance(input_value, VellumAudio)
+                            else VellumAudio.model_validate(input_value.model_dump())
+                        ),
+                    )
+                )
+            elif isinstance(input_value, (VellumVideo, VellumVideoRequest)):
+                input_variables.append(
+                    VellumVariable(
+                        id=str(uuid4()),
+                        key=input_name,
+                        type="VIDEO",
+                    )
+                )
+                input_values.append(
+                    PromptRequestVideoInput(
+                        key=input_name,
+                        value=(
+                            input_value
+                            if isinstance(input_value, VellumVideo)
+                            else VellumVideo.model_validate(input_value.model_dump())
+                        ),
+                    )
+                )
+            elif isinstance(input_value, (VellumImage, VellumImageRequest)):
+                input_variables.append(
+                    VellumVariable(
+                        id=str(uuid4()),
+                        key=input_name,
+                        type="IMAGE",
+                    )
+                )
+                input_values.append(
+                    PromptRequestImageInput(
+                        key=input_name,
+                        value=(
+                            input_value
+                            if isinstance(input_value, VellumImage)
+                            else VellumImage.model_validate(input_value.model_dump())
+                        ),
+                    )
+                )
+            elif isinstance(input_value, (VellumDocument, VellumDocumentRequest)):
+                input_variables.append(
+                    VellumVariable(
+                        id=str(uuid4()),
+                        key=input_name,
+                        type="DOCUMENT",
+                    )
+                )
+                input_values.append(
+                    PromptRequestDocumentInput(
+                        key=input_name,
+                        value=(
+                            input_value
+                            if isinstance(input_value, VellumDocument)
+                            else VellumDocument.model_validate(input_value.model_dump())
+                        ),
+                    )
+                )
             else:
                 try:
                     input_value = default_serializer(input_value)

{vellum_ai-1.3.6 → vellum_ai-1.3.8}/src/vellum/workflows/nodes/displayable/bases/inline_prompt_node/tests/test_inline_prompt_node.py

@@ -9,22 +9,34 @@ from pydantic import BaseModel
 from vellum import (
     AdHocExecutePromptEvent,
     ChatMessagePromptBlock,
+    ExecutePromptEvent,
     FulfilledAdHocExecutePromptEvent,
+    FulfilledExecutePromptEvent,
+    FulfilledPromptExecutionMeta,
+    InitiatedExecutePromptEvent,
     JinjaPromptBlock,
     PlainTextPromptBlock,
     PromptBlock,
+    PromptOutput,
     PromptParameters,
+    PromptRequestAudioInput,
+    PromptRequestDocumentInput,
+    PromptRequestImageInput,
+    PromptRequestStringInput,
+    PromptRequestVideoInput,
     PromptSettings,
     RichTextPromptBlock,
+    StringVellumValue,
     VariablePromptBlock,
+    VellumAudio,
+    VellumAudioRequest,
+    VellumDocument,
+    VellumDocumentRequest,
+    VellumImage,
+    VellumImageRequest,
+    VellumVideo,
+    VellumVideoRequest,
 )
-from vellum.client.types.execute_prompt_event import ExecutePromptEvent
-from vellum.client.types.fulfilled_execute_prompt_event import FulfilledExecutePromptEvent
-from vellum.client.types.fulfilled_prompt_execution_meta import FulfilledPromptExecutionMeta
-from vellum.client.types.initiated_execute_prompt_event import InitiatedExecutePromptEvent
-from vellum.client.types.prompt_output import PromptOutput
-from vellum.client.types.prompt_request_string_input import PromptRequestStringInput
-from vellum.client.types.string_vellum_value import StringVellumValue
 from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.inputs import BaseInputs
@@ -725,3 +737,71 @@ def test_inline_prompt_node__empty_string_output_with_length_finish_reason(vellu
 
     # AND the exception should have the correct error code
     assert excinfo.value.code == WorkflowErrorCode.INVALID_OUTPUTS
+
+
+@pytest.mark.parametrize(
+    [
+        "raw_input",
+        "expected_vellum_variable_type",
+        "expected_compiled_inputs",
+    ],
+    [
+        # Cast VellumX -> VellumXRequest
+        (
+            VellumAudio(src="data:audio/wav;base64,mockaudio"),
+            "AUDIO",
+            [PromptRequestAudioInput(key="file_input", value=VellumAudio(src="data:audio/wav;base64,mockaudio"))],
+        ),
+        (
+            VellumImage(src="data:image/png;base64,mockimage"),
+            "IMAGE",
+            [PromptRequestImageInput(key="file_input", value=VellumImage(src="data:image/png;base64,mockimage"))],
+        ),
+        (
+            VellumVideo(src="data:video/mp4;base64,mockvideo"),
+            "VIDEO",
+            [PromptRequestVideoInput(key="file_input", value=VellumVideo(src="data:video/mp4;base64,mockvideo"))],
+        ),
+        (
+            VellumDocument(src="mockdocument"),
+            "DOCUMENT",
+            [PromptRequestDocumentInput(key="file_input", value=VellumDocument(src="mockdocument"))],
+        ),
+        # No casting required
+        (
+            VellumAudioRequest(src="data:audio/wav;base64,mockaudio"),
+            "AUDIO",
+            [PromptRequestAudioInput(key="file_input", value=VellumAudio(src="data:audio/wav;base64,mockaudio"))],
+        ),
+        (
+            VellumImageRequest(src="data:image/png;base64,mockimage"),
+            "IMAGE",
+            [PromptRequestImageInput(key="file_input", value=VellumImage(src="data:image/png;base64,mockimage"))],
+        ),
+        (
+            VellumVideoRequest(src="data:video/mp4;base64,mockvideo"),
+            "VIDEO",
+            [PromptRequestVideoInput(key="file_input", value=VellumVideo(src="data:video/mp4;base64,mockvideo"))],
+        ),
+        (
+            VellumDocumentRequest(src="mockdocument"),
+            "DOCUMENT",
+            [PromptRequestDocumentInput(key="file_input", value=VellumDocument(src="mockdocument"))],
+        ),
+    ],
+)
+def test_file_input_compilation(raw_input, expected_vellum_variable_type, expected_compiled_inputs):
+    # GIVEN a prompt node with file input
+    class MyPromptDeploymentNode(InlinePromptNode):
+        ml_model = "test-model"
+        ml_model_fallbacks = None
+
+        prompt_inputs = {"file_input": raw_input}
+
+    # WHEN we compile the inputs
+    vellum_variables, compiled_inputs = MyPromptDeploymentNode()._compile_prompt_inputs()
+
+    # THEN we should get the correct input type
+    assert len(vellum_variables) == 1
+    assert vellum_variables[0].type == expected_vellum_variable_type
+    assert compiled_inputs == expected_compiled_inputs

{vellum_ai-1.3.6 → vellum_ai-1.3.8}/src/vellum/workflows/nodes/displayable/bases/prompt_deployment_node.py

@@ -3,15 +3,27 @@ from uuid import UUID
 from typing import Any, ClassVar, Dict, Generator, Generic, Iterator, List, Optional, Sequence, Set, Union
 
 from vellum import (
+    AudioInputRequest,
     ChatHistoryInputRequest,
     ChatMessage,
+    DocumentInputRequest,
     ExecutePromptEvent,
+    ImageInputRequest,
     JsonInputRequest,
     PromptDeploymentExpandMetaRequest,
     PromptDeploymentInputRequest,
     PromptOutput,
     RawPromptExecutionOverridesRequest,
     StringInputRequest,
+    VellumAudio,
+    VellumAudioRequest,
+    VellumDocument,
+    VellumDocumentRequest,
+    VellumImage,
+    VellumImageRequest,
+    VellumVideo,
+    VellumVideoRequest,
+    VideoInputRequest,
 )
 from vellum.client import ApiError, RequestOptions
 from vellum.client.types.chat_message_request import ChatMessageRequest
@@ -202,6 +214,54 @@ class BasePromptDeploymentNode(BasePromptNode, Generic[StateType]):
                         value=chat_history,
                     )
                 )
+            elif isinstance(input_value, (VellumAudio, VellumAudioRequest)):
+                audio_value = (
+                    input_value
+                    if isinstance(input_value, VellumAudioRequest)
+                    else VellumAudioRequest.model_validate(input_value.model_dump())
+                )
+                compiled_inputs.append(
+                    AudioInputRequest(
+                        name=input_name,
+                        value=audio_value,
+                    )
+                )
+            elif isinstance(input_value, (VellumImage, VellumImageRequest)):
+                image_value = (
+                    input_value
+                    if isinstance(input_value, VellumImageRequest)
+                    else VellumImageRequest.model_validate(input_value.model_dump())
+                )
+                compiled_inputs.append(
+                    ImageInputRequest(
+                        name=input_name,
+                        value=image_value,
+                    )
+                )
+            elif isinstance(input_value, (VellumDocument, VellumDocumentRequest)):
+                document_value = (
+                    input_value
+                    if isinstance(input_value, VellumDocumentRequest)
+                    else VellumDocumentRequest.model_validate(input_value.model_dump())
+                )
+                compiled_inputs.append(
+                    DocumentInputRequest(
+                        name=input_name,
+                        value=document_value,
+                    )
+                )
+            elif isinstance(input_value, (VellumVideo, VellumVideoRequest)):
+                video_value = (
+                    input_value
+                    if isinstance(input_value, VellumVideoRequest)
+                    else VellumVideoRequest.model_validate(input_value.model_dump())
+                )
+                compiled_inputs.append(
+                    VideoInputRequest(
+                        name=input_name,
+                        value=video_value,
+                    )
+                )
             else:
                 try:
                     input_value = default_serializer(input_value)

{vellum_ai-1.3.6 → vellum_ai-1.3.8}/src/vellum/workflows/runner/runner.py

@@ -27,6 +27,7 @@ from typing import (
 from vellum.workflows.constants import undefined
 from vellum.workflows.context import ExecutionContext, execution_context, get_execution_context
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.errors import WorkflowError, WorkflowErrorCode
 from vellum.workflows.events import (
     NodeExecutionFulfilledEvent,
@@ -433,6 +434,21 @@ class WorkflowRunner(Generic[StateType]):
                     parent=execution.parent_context,
                 )
             )
+        except InvalidExpressionException as e:
+            logger.info(e)
+            captured_stacktrace = traceback.format_exc()
+            self._workflow_event_inner_queue.put(
+                NodeExecutionRejectedEvent(
+                    trace_id=execution.trace_id,
+                    span_id=span_id,
+                    body=NodeExecutionRejectedBody(
+                        node_definition=node.__class__,
+                        error=e.error,
+                        stacktrace=captured_stacktrace,
+                    ),
+                    parent=execution.parent_context,
+                )
+            )
 
         except Exception as e:
             error_message = self._parse_error_message(e)

vellum_ai-1.3.6/src/vellum/workflows/descriptors/exceptions.py

@@ -1,2 +0,0 @@
-class InvalidExpressionException(Exception):
-    pass