vellum-ai 1.3.7__py3-none-any.whl → 1.3.9__py3-none-any.whl

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.7",
+            "User-Agent": "vellum-ai/1.3.9",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "1.3.7",
+            "X-Fern-SDK-Version": "1.3.9",
             **(self.get_custom_headers() or {}),
         }
         if self._api_version is not None:

vellum/client/reference.md

@@ -6426,6 +6426,77 @@ client.workflow_sandboxes.list_workflow_sandbox_examples()
 </details>
 
 ## Workflows
+<details><summary><code>client.workflows.<a href="src/vellum/resources/workflows/client.py">serialize_workflow_files</a>(...)</code></summary>
+<dl>
+<dd>
+
+#### 📝 Description
+
+<dl>
+<dd>
+
+<dl>
+<dd>
+
+Serialize files
+</dd>
+</dl>
+</dd>
+</dl>
+
+#### 🔌 Usage
+
+<dl>
+<dd>
+
+<dl>
+<dd>
+
+```python
+from vellum import Vellum
+
+client = Vellum(
+    api_version="YOUR_API_VERSION",
+    api_key="YOUR_API_KEY",
+)
+client.workflows.serialize_workflow_files(
+    files={"files": {"key": "value"}},
+)
+
+```
+</dd>
+</dl>
+</dd>
+</dl>
+
+#### ⚙️ Parameters
+
+<dl>
+<dd>
+
+<dl>
+<dd>
+
+**files:** `typing.Dict[str, typing.Optional[typing.Any]]` 
+    
+</dd>
+</dl>
+
+<dl>
+<dd>
+
+**request_options:** `typing.Optional[RequestOptions]` — Request-specific configuration.
+    
+</dd>
+</dl>
+</dd>
+</dl>
+
+
+</dd>
+</dl>
+</details>
+
 ## WorkspaceSecrets
 <details><summary><code>client.workspace_secrets.<a href="src/vellum/resources/workspace_secrets/client.py">retrieve</a>(...)</code></summary>
 <dl>

vellum/client/resources/workflows/client.py

@@ -136,6 +136,42 @@ class WorkflowsClient:
         )
         return _response.data
 
+    def serialize_workflow_files(
+        self,
+        *,
+        files: typing.Dict[str, typing.Optional[typing.Any]],
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> typing.Dict[str, typing.Optional[typing.Any]]:
+        """
+        Serialize files
+
+        Parameters
+        ----------
+        files : typing.Dict[str, typing.Optional[typing.Any]]
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        typing.Dict[str, typing.Optional[typing.Any]]
+
+
+        Examples
+        --------
+        from vellum import Vellum
+
+        client = Vellum(
+            api_version="YOUR_API_VERSION",
+            api_key="YOUR_API_KEY",
+        )
+        client.workflows.serialize_workflow_files(
+            files={"files": {"key": "value"}},
+        )
+        """
+        _response = self._raw_client.serialize_workflow_files(files=files, request_options=request_options)
+        return _response.data
+
 
 class AsyncWorkflowsClient:
     def __init__(self, *, client_wrapper: AsyncClientWrapper):
@@ -255,3 +291,47 @@ class AsyncWorkflowsClient:
             request_options=request_options,
         )
         return _response.data
+
+    async def serialize_workflow_files(
+        self,
+        *,
+        files: typing.Dict[str, typing.Optional[typing.Any]],
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> typing.Dict[str, typing.Optional[typing.Any]]:
+        """
+        Serialize files
+
+        Parameters
+        ----------
+        files : typing.Dict[str, typing.Optional[typing.Any]]
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        typing.Dict[str, typing.Optional[typing.Any]]
+
+
+        Examples
+        --------
+        import asyncio
+
+        from vellum import AsyncVellum
+
+        client = AsyncVellum(
+            api_version="YOUR_API_VERSION",
+            api_key="YOUR_API_KEY",
+        )
+
+
+        async def main() -> None:
+            await client.workflows.serialize_workflow_files(
+                files={"files": {"key": "value"}},
+            )
+
+
+        asyncio.run(main())
+        """
+        _response = await self._raw_client.serialize_workflow_files(files=files, request_options=request_options)
+        return _response.data

vellum/client/resources/workflows/raw_client.py

@@ -181,6 +181,55 @@ class RawWorkflowsClient:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
+    def serialize_workflow_files(
+        self,
+        *,
+        files: typing.Dict[str, typing.Optional[typing.Any]],
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> HttpResponse[typing.Dict[str, typing.Optional[typing.Any]]]:
+        """
+        Serialize files
+
+        Parameters
+        ----------
+        files : typing.Dict[str, typing.Optional[typing.Any]]
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        HttpResponse[typing.Dict[str, typing.Optional[typing.Any]]]
+
+        """
+        _response = self._client_wrapper.httpx_client.request(
+            "v1/workflows/serialize",
+            base_url=self._client_wrapper.get_environment().default,
+            method="POST",
+            json={
+                "files": files,
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    typing.Dict[str, typing.Optional[typing.Any]],
+                    parse_obj_as(
+                        type_=typing.Dict[str, typing.Optional[typing.Any]],  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return HttpResponse(response=_response, data=_data)
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
 
 class AsyncRawWorkflowsClient:
     def __init__(self, *, client_wrapper: AsyncClientWrapper):
@@ -343,3 +392,52 @@ class AsyncRawWorkflowsClient:
         except JSONDecodeError:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
+
+    async def serialize_workflow_files(
+        self,
+        *,
+        files: typing.Dict[str, typing.Optional[typing.Any]],
+        request_options: typing.Optional[RequestOptions] = None,
+    ) -> AsyncHttpResponse[typing.Dict[str, typing.Optional[typing.Any]]]:
+        """
+        Serialize files
+
+        Parameters
+        ----------
+        files : typing.Dict[str, typing.Optional[typing.Any]]
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[typing.Dict[str, typing.Optional[typing.Any]]]
+
+        """
+        _response = await self._client_wrapper.httpx_client.request(
+            "v1/workflows/serialize",
+            base_url=self._client_wrapper.get_environment().default,
+            method="POST",
+            json={
+                "files": files,
+            },
+            headers={
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    typing.Dict[str, typing.Optional[typing.Any]],
+                    parse_obj_as(
+                        type_=typing.Dict[str, typing.Optional[typing.Any]],  # type: ignore
+                        object_=_response.json(),
+                    ),
+                )
+                return AsyncHttpResponse(response=_response, data=_data)
+            _response_json = _response.json()
+        except JSONDecodeError:
+            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
+        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)

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/client/types/vellum_error.py

@@ -8,8 +8,9 @@ from .vellum_error_code_enum import VellumErrorCodeEnum
 
 
 class VellumError(UniversalBaseModel):
-    message: str
     code: VellumErrorCodeEnum
+    message: str
+    raw_data: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] = None
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2

vellum/client/types/vellum_error_request.py

@@ -8,8 +8,9 @@ from .vellum_error_code_enum import VellumErrorCodeEnum
 
 
 class VellumErrorRequest(UniversalBaseModel):
-    message: str
     code: VellumErrorCodeEnum
+    message: str
+    raw_data: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] = None
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2

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/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/workflows/descriptors/exceptions.py

@@ -1,2 +1,19 @@
+from vellum.workflows.errors import WorkflowError, WorkflowErrorCode
+
+
 class InvalidExpressionException(Exception):
-    pass
+    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/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/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/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/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)