vellum-ai 1.3.8__py3-none-any.whl → 1.3.10__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.8",
+            "User-Agent": "vellum-ai/1.3.10",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "1.3.8",
+            "X-Fern-SDK-Version": "1.3.10",
             **(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/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/workflows/errors/types.py

@@ -1,7 +1,7 @@
 from dataclasses import dataclass
 from enum import Enum
 import logging
-from typing import Any, Dict
+from typing import Any, Dict, Optional
 
 from vellum.client.types.vellum_error import VellumError
 from vellum.client.types.vellum_error_code_enum import VellumErrorCodeEnum
@@ -30,6 +30,7 @@ class WorkflowErrorCode(Enum):
 class WorkflowError:
     message: str
     code: WorkflowErrorCode
+    raw_data: Optional[Dict[str, Any]] = None
 
     def __contains__(self, item: Any) -> bool:
         return item in self.message
@@ -55,6 +56,7 @@ def vellum_error_to_workflow_error(error: VellumError) -> WorkflowError:
     return WorkflowError(
         message=error.message,
         code=workflow_error_code,
+        raw_data=error.raw_data or {},
     )
 
 

vellum/workflows/events/tests/test_event.py

@@ -260,6 +260,7 @@ mock_node_uuid = str(uuid4_from_hash(MockNode.__qualname__))
                     "error": {
                         "message": "Workflow failed",
                         "code": "USER_DEFINED_ERROR",
+                        "raw_data": None,
                     },
                     "stacktrace": None,
                 },

vellum/workflows/exceptions.py

@@ -1,10 +1,18 @@
+from typing import Any, Dict, Optional
+
 from vellum.workflows.errors import WorkflowError, WorkflowErrorCode
 
 
 class NodeException(Exception):
-    def __init__(self, message: str, code: WorkflowErrorCode = WorkflowErrorCode.INTERNAL_ERROR):
+    def __init__(
+        self,
+        message: str,
+        code: WorkflowErrorCode = WorkflowErrorCode.INTERNAL_ERROR,
+        raw_data: Optional[Dict[str, Any]] = None,
+    ):
         self.message = message
         self.code = code
+        self.raw_data = raw_data
         super().__init__(message)
 
     @property
@@ -12,11 +20,12 @@ class NodeException(Exception):
         return WorkflowError(
             message=self.message,
             code=self.code,
+            raw_data=self.raw_data,
         )
 
     @staticmethod
     def of(workflow_error: WorkflowError) -> "NodeException":
-        return NodeException(message=workflow_error.message, code=workflow_error.code)
+        return NodeException(message=workflow_error.message, code=workflow_error.code, raw_data=workflow_error.raw_data)
 
 
 class WorkflowInitializationException(Exception):

vellum/workflows/nodes/displayable/tests/test_inline_text_prompt_node.py

@@ -114,6 +114,7 @@ def test_inline_text_prompt_node__catch_provider_error(vellum_adhoc_prompt_clien
     expected_error = VellumError(
         message="OpenAI failed",
         code="PROVIDER_ERROR",
+        raw_data={"type": "ERROR", "error": {"message": "Something went wrong"}},
     )
 
     def generate_prompt_events(*args: Any, **kwargs: Any) -> Iterator[ExecutePromptEvent]:
@@ -144,6 +145,7 @@ def test_inline_text_prompt_node__catch_provider_error(vellum_adhoc_prompt_clien
             value=SdkVellumError(
                 message="OpenAI failed",
                 code=WorkflowErrorCode.PROVIDER_ERROR,
+                raw_data={"type": "ERROR", "error": {"message": "Something went wrong"}},
             ),
         )
         in outputs

vellum/workflows/types/definition.py

@@ -4,8 +4,9 @@ from types import FrameType
 from uuid import UUID
 from typing import Annotated, Any, Dict, Literal, Optional, Union
 
-from pydantic import BeforeValidator
+from pydantic import BeforeValidator, SerializationInfo, model_serializer
 
+from vellum import Vellum
 from vellum.client.core.pydantic_utilities import UniversalBaseModel
 from vellum.client.types.code_resource_definition import CodeResourceDefinition as ClientCodeResourceDefinition
 from vellum.workflows.constants import AuthorizationType
@@ -78,6 +79,10 @@ class DeploymentDefinition(UniversalBaseModel):
     deployment: str
     release_tag: str = "LATEST"
 
+    # hydrated fields
+    name: Optional[str] = None
+    description: Optional[str] = None
+
     def _is_uuid(self) -> bool:
         """Check if the deployment field is a valid UUID."""
         try:
@@ -100,6 +105,32 @@ class DeploymentDefinition(UniversalBaseModel):
             return self.deployment
         return None
 
+    @model_serializer(mode="wrap")
+    def _serialize(self, handler, info: SerializationInfo):
+        """Allow Pydantic to serialize directly given a `client` in context.
+
+        Falls back to the default serialization when client is not provided.
+        """
+        context = info.context if info and hasattr(info, "context") else {}
+        client: Optional[Vellum] = context.get("client") if context else None
+
+        if client:
+            release = client.workflow_deployments.retrieve_workflow_deployment_release(
+                self.deployment, self.release_tag
+            )
+            self.name = release.deployment.name or self.deployment
+            self.description = release.description or f"Workflow Deployment for {self.deployment}"
+
+            return {
+                "type": "WORKFLOW_DEPLOYMENT",
+                "name": self.name,
+                "description": self.description,
+                "deployment": self.deployment,
+                "release_tag": self.release_tag,
+            }
+
+        return handler(self)
+
 
 class ComposioToolDefinition(UniversalBaseModel):
     """Represents a specific Composio action that can be used in Tool Calling Node"""

vellum/workflows/utils/tests/test_vellum_variables.py

@@ -1,7 +1,7 @@
 import pytest
 from typing import List, Optional
 
-from vellum import ChatMessage, SearchResult, VellumAudio, VellumDocument, VellumImage
+from vellum import ChatMessage, SearchResult, VellumAudio, VellumDocument, VellumImage, VellumValue
 from vellum.workflows.types.core import Json
 from vellum.workflows.utils.vellum_variables import (
     primitive_type_to_vellum_variable_type,
@@ -30,6 +30,12 @@ from vellum.workflows.utils.vellum_variables import (
         (Optional[VellumAudio], "AUDIO"),
         (VellumImage, "IMAGE"),
         (Optional[VellumImage], "IMAGE"),
+        (list[ChatMessage], "CHAT_HISTORY"),
+        (Optional[list[ChatMessage]], "CHAT_HISTORY"),
+        (list[SearchResult], "SEARCH_RESULTS"),
+        (Optional[list[SearchResult]], "SEARCH_RESULTS"),
+        (list[VellumValue], "ARRAY"),
+        (Optional[list[VellumValue]], "ARRAY"),
     ],
 )
 def test_primitive_type_to_vellum_variable_type(type_, expected):

vellum/workflows/utils/vellum_variables.py

@@ -1,5 +1,5 @@
 import typing
-from typing import List, Tuple, Type, Union, get_args, get_origin
+from typing import Any, List, Tuple, Type, Union, get_args, get_origin
 
 from vellum import (
     ChatMessage,
@@ -86,6 +86,11 @@ def primitive_type_to_vellum_variable_type(type_: Union[Type, BaseDescriptor]) -
         return "DOCUMENT"
     elif _is_type_optionally_in(type_, (VellumError, VellumErrorRequest)):
         return "ERROR"
+
+    builtin_list_type = _builtin_list_to_vellum_type(type_)
+    if builtin_list_type:
+        return builtin_list_type
+
     elif _is_type_optionally_in(type_, (List[ChatMessage], List[ChatMessageRequest])):
         return "CHAT_HISTORY"
     elif _is_type_optionally_in(type_, (List[SearchResult], List[SearchResultRequest])):
@@ -128,7 +133,7 @@ def vellum_variable_type_to_openapi_type(vellum_type: VellumVariableType) -> str
         return "object"
 
 
-def _is_type_optionally_equal(type_: Type, target_type: Type) -> bool:
+def _is_type_optionally_equal(type_: Type, target_type: Any) -> bool:
     if type_ == target_type:
         return True
 
@@ -147,7 +152,7 @@ def _is_type_optionally_equal(type_: Type, target_type: Type) -> bool:
     return _is_type_optionally_equal(source_type, target_type)
 
 
-def _is_type_optionally_in(type_: Type, target_types: Tuple[Type, ...]) -> bool:
+def _is_type_optionally_in(type_: Type, target_types: Tuple[Any, ...]) -> bool:
     return any(_is_type_optionally_equal(type_, target_type) for target_type in target_types)
 
 
@@ -181,3 +186,37 @@ def _is_subtype(source_type: Type, target_type: Type) -> bool:
         return True
 
     return False
+
+
+def _unwrap_optional(type_: Type) -> Type:
+    origin = get_origin(type_)
+    if origin is typing.Union:
+        args = get_args(type_)
+        if len(args) == 2:
+            if args[1] is type(None):
+                return args[0]
+            if args[0] is type(None):
+                return args[1]
+    return type_
+
+
+def _builtin_list_to_vellum_type(type_: Type) -> Union[str, None]:
+    candidate = _unwrap_optional(type_)
+    origin = get_origin(candidate)
+    if origin in (list, typing.List):
+        args = get_args(candidate)
+        if len(args) == 1:
+            item_type = args[0]
+            if _is_type_optionally_equal(item_type, ChatMessage) or _is_type_optionally_equal(
+                item_type, ChatMessageRequest
+            ):
+                return "CHAT_HISTORY"
+            if _is_type_optionally_equal(item_type, SearchResult) or _is_type_optionally_equal(
+                item_type, SearchResultRequest
+            ):
+                return "SEARCH_RESULTS"
+            if _is_type_optionally_equal(item_type, VellumValue) or _is_type_optionally_equal(
+                item_type, VellumValueRequest
+            ):
+                return "ARRAY"
+    return None

{vellum_ai-1.3.8.dist-info → vellum_ai-1.3.10.dist-info}/METADATA

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