vellum-ai 1.3.10__tar.gz → 1.4.0__tar.gz

{vellum_ai-1.3.10 → vellum_ai-1.4.0}/PKG-INFO

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

{vellum_ai-1.3.10 → vellum_ai-1.4.0}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_inline_workflow_serialization.py

@@ -114,7 +114,7 @@ def test_serialize_workflow():
                                                 "block_type": "VARIABLE",
                                                 "state": None,
                                                 "cache_config": None,
-                                                "input_variable": "question",
+                                                "input_variable": "8eb8b551-9b48-43b3-861f-52adb5c585a8",
                                             }
                                         ],
                                     }

{vellum_ai-1.3.10 → vellum_ai-1.4.0}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_serialization.py

@@ -115,7 +115,7 @@ def test_serialize_workflow():
                                                 "block_type": "VARIABLE",
                                                 "state": None,
                                                 "cache_config": None,
-                                                "input_variable": "question",
+                                                "input_variable": "8eb8b551-9b48-43b3-861f-52adb5c585a8",
                                             }
                                         ],
                                     }

{vellum_ai-1.3.10 → vellum_ai-1.4.0}/ee/vellum_ee/workflows/display/workflows/base_workflow_display.py

@@ -17,6 +17,7 @@ from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.edges import Edge
 from vellum.workflows.events.workflow import NodeEventDisplayContext, WorkflowEventDisplayContext
 from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.inputs.dataset_row import DatasetRow
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.displayable.bases.utils import primitive_to_vellum_value
 from vellum.workflows.nodes.displayable.final_output_node.node import FinalOutputNode
@@ -913,7 +914,10 @@ class BaseWorkflowDisplay(Generic[WorkflowType]):
                 if dataset_attr and isinstance(dataset_attr, list):
                     dataset = []
                     for i, inputs_obj in enumerate(dataset_attr):
-                        if isinstance(inputs_obj, BaseInputs):
+                        if isinstance(inputs_obj, DatasetRow):
+                            serialized_inputs = json.loads(json.dumps(inputs_obj.inputs, cls=DefaultStateEncoder))
+                            dataset.append({"label": inputs_obj.label, "inputs": serialized_inputs})
+                        elif isinstance(inputs_obj, BaseInputs):
                             serialized_inputs = json.loads(json.dumps(inputs_obj, cls=DefaultStateEncoder))
                             dataset.append({"label": f"Scenario {i + 1}", "inputs": serialized_inputs})
         except (ImportError, AttributeError):

{vellum_ai-1.3.10 → vellum_ai-1.4.0}/ee/vellum_ee/workflows/tests/test_serialize_module.py

@@ -24,12 +24,11 @@ def test_serialize_module_with_actual_dataset():
     assert isinstance(result.dataset, list)
     assert len(result.dataset) == 2
 
-    for i, item in enumerate(result.dataset):
-        assert "label" in item
-        assert "inputs" in item
-        assert item["label"] == f"Scenario {i + 1}"
-        assert isinstance(item["inputs"], dict)
-        assert "message" in item["inputs"]
+    assert result.dataset[0]["label"] == "Scenario 1"
+    assert result.dataset[0]["inputs"]["message"] == "World"
+
+    assert result.dataset[1]["label"] == "Custom Test"
+    assert result.dataset[1]["inputs"]["message"] == "DatasetRow Test"
 
 
 def test_serialize_module_happy_path():

{vellum_ai-1.3.10 → vellum_ai-1.4.0}/pyproject.toml

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

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

vellum_ai-1.4.0/src/vellum/client/tests/test_utils.py

@@ -0,0 +1,34 @@
+import uuid
+from unittest.mock import Mock
+from vellum.client.utils import convert_input_variable_to_uuid
+
+
+def test_convert_input_variable_to_uuid_with_valid_uuid():
+    """Test convert_input_variable_to_uuid with valid UUID passes through unchanged."""
+    uuid_value = "123e4567-e89b-12d3-a456-426614174000"
+
+    # GIVEN a valid UUID
+    # WHEN the function is called
+    result = convert_input_variable_to_uuid(uuid_value)
+
+    # THEN the result should be the original UUID unchanged
+    assert result == uuid_value
+
+
+def test_convert_input_variable_to_uuid_with_invalid_uuid_converts():
+    """Test convert_input_variable_to_uuid with invalid UUID gets converted to UUID."""
+    non_uuid_value = "some_variable_name"
+    executable_id = "test_executable_123"
+
+    # GIVEN an invalid UUID with context
+    mock_info = Mock()
+    mock_info.context = {"executable_id": executable_id}
+
+    # WHEN the function is called
+    result = convert_input_variable_to_uuid(non_uuid_value, mock_info)
+
+    # THEN it should return a different value
+    assert result != non_uuid_value
+
+    # AND it's a valid UUID
+    uuid.UUID(result)  # This will raise ValueError if not a valid UUID

{vellum_ai-1.3.10 → vellum_ai-1.4.0}/src/vellum/client/types/variable_prompt_block.py

@@ -3,6 +3,7 @@
 import typing
 
 import pydantic
+from vellum.client.utils import convert_input_variable_to_uuid
 from ..core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
 from .ephemeral_prompt_cache_config import EphemeralPromptCacheConfig
 from .prompt_block_state import PromptBlockState
@@ -26,3 +27,9 @@ class VariablePromptBlock(UniversalBaseModel):
             frozen = True
             smart_union = True
             extra = pydantic.Extra.allow
+
+
+    @pydantic.field_serializer("input_variable")
+    def serialize_input_variable(self, value: str, info: pydantic.SerializationInfo) -> str:
+        """Convert input_variable to UUID using executable_id from context."""
+        return convert_input_variable_to_uuid(value, info)

vellum_ai-1.4.0/src/vellum/client/utils.py

@@ -0,0 +1,24 @@
+# Custom client utilities
+# This file is not generated by Fern and can be freely edited
+
+from uuid import UUID
+from typing import Optional
+from pydantic import SerializationInfo
+
+
+def convert_input_variable_to_uuid(value: str, info: Optional[SerializationInfo] = None) -> str:
+    """Convert input_variable to UUID using executable_id from context."""
+    # Check if value is already a valid UUID
+    try:
+        UUID(value)
+        return value  # Already a UUID, return as-is
+    except ValueError:
+        pass  # Not a UUID, continue with conversion logic
+
+    if info and hasattr(info, "context") and info.context:
+        executable_id = info.context.get("executable_id")
+        if executable_id:
+            from vellum.workflows.utils.uuids import uuid4_from_hash  # avoid circular import
+
+            return str(uuid4_from_hash(f"{executable_id}|{value}"))
+    return value

{vellum_ai-1.3.10 → vellum_ai-1.4.0}/src/vellum/workflows/__init__.py

@@ -1,5 +1,7 @@
+from .inputs.dataset_row import DatasetRow
 from .workflows import BaseWorkflow
 
 __all__ = [
     "BaseWorkflow",
+    "DatasetRow",
 ]

{vellum_ai-1.3.10 → vellum_ai-1.4.0}/src/vellum/workflows/errors/types.py

@@ -40,6 +40,7 @@ _VELLUM_ERROR_CODE_TO_WORKFLOW_ERROR_CODE: Dict[VellumErrorCodeEnum, WorkflowErr
     "INVALID_REQUEST": WorkflowErrorCode.INVALID_INPUTS,
     "INVALID_INPUTS": WorkflowErrorCode.INVALID_INPUTS,
     "PROVIDER_ERROR": WorkflowErrorCode.PROVIDER_ERROR,
+    "PROVIDER_CREDENTIALS_UNAVAILABLE": WorkflowErrorCode.PROVIDER_CREDENTIALS_UNAVAILABLE,
     "REQUEST_TIMEOUT": WorkflowErrorCode.PROVIDER_ERROR,
     "INTERNAL_SERVER_ERROR": WorkflowErrorCode.INTERNAL_ERROR,
     "USER_DEFINED_ERROR": WorkflowErrorCode.USER_DEFINED_ERROR,

{vellum_ai-1.3.10 → vellum_ai-1.4.0}/src/vellum/workflows/inputs/__init__.py

@@ -1,5 +1,7 @@
 from .base import BaseInputs
+from .dataset_row import DatasetRow
 
 __all__ = [
     "BaseInputs",
+    "DatasetRow",
 ]

vellum_ai-1.4.0/src/vellum/workflows/inputs/dataset_row.py

@@ -0,0 +1,38 @@
+from typing import Any, Dict
+
+from pydantic import field_serializer
+
+from vellum.client.core.pydantic_utilities import UniversalBaseModel
+from vellum.workflows.inputs.base import BaseInputs
+
+
+class DatasetRow(UniversalBaseModel):
+    """
+    Universal base model representing a dataset row with a label and inputs.
+
+    Attributes:
+        label: String label for the dataset row
+        inputs: BaseInputs instance containing the input data
+    """
+
+    label: str
+    inputs: BaseInputs
+
+    @field_serializer("inputs")
+    def serialize_inputs(self, inputs: BaseInputs) -> Dict[str, Any]:
+        """
+        Custom serializer for BaseInputs that converts it to a dictionary.
+
+        Args:
+            inputs: BaseInputs instance to serialize
+
+        Returns:
+            Dictionary representation of the inputs
+        """
+        result = {}
+
+        for input_descriptor, value in inputs:
+            if not input_descriptor.name.startswith("__"):
+                result[input_descriptor.name] = value
+
+        return result

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

@@ -45,12 +45,14 @@ from vellum.workflows.nodes.displayable.bases.base_prompt_node import BasePrompt
 from vellum.workflows.nodes.displayable.bases.utils import process_additional_prompt_outputs
 from vellum.workflows.outputs import BaseOutput
 from vellum.workflows.types import MergeBehavior
-from vellum.workflows.types.definition import DeploymentDefinition
+from vellum.workflows.types.definition import DeploymentDefinition, MCPServer
 from vellum.workflows.types.generics import StateType, is_workflow_class
 from vellum.workflows.utils.functions import (
     compile_function_definition,
     compile_inline_workflow_function_definition,
+    compile_mcp_tool_definition,
     compile_workflow_deployment_function_definition,
+    get_mcp_tool_name,
 )
 from vellum.workflows.utils.pydantic_schema import normalize_json
 
@@ -140,6 +142,16 @@ class BaseInlinePromptNode(BasePromptNode[StateType], Generic[StateType]):
                     normalized_functions.append(compile_inline_workflow_function_definition(function))
                 elif callable(function):
                     normalized_functions.append(compile_function_definition(function))
+                elif isinstance(function, MCPServer):
+                    tool_definitions = compile_mcp_tool_definition(function)
+                    for tool_def in tool_definitions:
+                        normalized_functions.append(
+                            FunctionDefinition(
+                                name=get_mcp_tool_name(tool_def),
+                                description=tool_def.description,
+                                parameters=tool_def.parameters,
+                            )
+                        )
                 else:
                     raise NodeException(
                         message=f"`{function}` is not a valid function definition",

{vellum_ai-1.3.10 → vellum_ai-1.4.0}/src/vellum/workflows/nodes/displayable/tool_calling_node/node.py

@@ -18,14 +18,13 @@ from vellum.workflows.nodes.displayable.tool_calling_node.utils import (
     create_router_node,
     create_tool_prompt_node,
     get_function_name,
-    get_mcp_tool_name,
-    hydrate_mcp_tool_definitions,
 )
 from vellum.workflows.outputs.base import BaseOutput, BaseOutputs
 from vellum.workflows.state.context import WorkflowContext
 from vellum.workflows.types.core import EntityInputsInterface, Tool
 from vellum.workflows.types.definition import MCPServer
 from vellum.workflows.types.generics import StateType
+from vellum.workflows.utils.functions import compile_mcp_tool_definition, get_mcp_tool_name
 from vellum.workflows.workflows.event_filters import all_workflow_event_filter
 
 
@@ -162,7 +161,7 @@ class ToolCallingNode(BaseNode[StateType], Generic[StateType]):
         self._function_nodes = {}
         for function in self.functions:
             if isinstance(function, MCPServer):
-                tool_definitions = hydrate_mcp_tool_definitions(function)
+                tool_definitions = compile_mcp_tool_definition(function)
                 for tool_definition in tool_definitions:
                     function_name = get_mcp_tool_name(tool_definition)
 

{vellum_ai-1.3.10 → vellum_ai-1.4.0}/src/vellum/workflows/nodes/displayable/tool_calling_node/utils.py

@@ -33,6 +33,7 @@ from vellum.workflows.state.encoder import DefaultStateEncoder
 from vellum.workflows.types.core import EntityInputsInterface, MergeBehavior, Tool, ToolBase
 from vellum.workflows.types.definition import ComposioToolDefinition, DeploymentDefinition, MCPServer, MCPToolDefinition
 from vellum.workflows.types.generics import is_workflow_class
+from vellum.workflows.utils.functions import compile_mcp_tool_definition, get_mcp_tool_name
 
 CHAT_HISTORY_VARIABLE = "chat_history"
 
@@ -303,26 +304,6 @@ def _hydrate_composio_tool_definition(tool_def: ComposioToolDefinition) -> Funct
         )
 
 
-def hydrate_mcp_tool_definitions(server_def: MCPServer) -> List[MCPToolDefinition]:
-    """Hydrate an MCPToolDefinition with detailed information from the MCP server.
-
-    We do tool discovery on the MCP server to get the tool definitions.
-
-    Args:
-        tool_def: The basic MCPToolDefinition to enhance
-
-    Returns:
-        MCPToolDefinition with detailed parameters and description
-    """
-    try:
-        mcp_service = MCPService()
-        return mcp_service.hydrate_tool_definitions(server_def)
-    except Exception as e:
-        # If hydration fails, log and return original
-        logger.warning(f"Failed to enhance MCP server '{server_def.name}': {e}")
-        return []
-
-
 def create_tool_prompt_node(
     ml_model: str,
     blocks: List[Union[PromptBlock, Dict[str, Any]]],
@@ -341,17 +322,6 @@ def create_tool_prompt_node(
                 # Get Composio tool details and hydrate the function definition
                 enhanced_function = _hydrate_composio_tool_definition(function)
                 prompt_functions.append(enhanced_function)
-            elif isinstance(function, MCPServer):
-                tool_functions: List[MCPToolDefinition] = hydrate_mcp_tool_definitions(function)
-                for tool_function in tool_functions:
-                    name = get_mcp_tool_name(tool_function)
-                    prompt_functions.append(
-                        FunctionDefinition(
-                            name=name,
-                            description=tool_function.description,
-                            parameters=tool_function.parameters,
-                        )
-                    )
             else:
                 prompt_functions.append(function)
     else:
@@ -440,7 +410,7 @@ def create_router_node(
                 port = create_port_condition(function_name)
                 setattr(Ports, function_name, port)
             elif isinstance(function, MCPServer):
-                tool_functions: List[MCPToolDefinition] = hydrate_mcp_tool_definitions(function)
+                tool_functions: List[MCPToolDefinition] = compile_mcp_tool_definition(function)
                 for tool_function in tool_functions:
                     name = get_mcp_tool_name(tool_function)
                     port = create_port_condition(name)
@@ -604,8 +574,3 @@ def get_function_name(function: ToolBase) -> str:
         return function.name  # type: ignore[return-value]
     else:
         return snake_case(function.__name__)
-
-
-def get_mcp_tool_name(tool_def: MCPToolDefinition) -> str:
-    server_name = snake_case(tool_def.server.name)
-    return f"{server_name}__{tool_def.name}"

{vellum_ai-1.3.10 → vellum_ai-1.4.0}/src/vellum/workflows/nodes/tests/test_utils.py

@@ -86,23 +86,23 @@ def test_parse_type_from_str_list_of_models():
             List[str],
             NodeException,
             WorkflowErrorCode.INVALID_OUTPUTS,
-            "Invalid JSON Array format for result_as_str",
+            "Invalid JSON format: expected a valid JSON array",
         ),
         (
             "{invalid json}",
             Person,
             NodeException,
             WorkflowErrorCode.INVALID_OUTPUTS,
-            "Invalid JSON format for result_as_str",
+            "Invalid JSON format: unable to parse the provided data",
         ),
         (
             "{invalid json}",
             Json,
             NodeException,
             WorkflowErrorCode.INVALID_OUTPUTS,
-            "Invalid JSON format for result_as_str",
+            "Invalid JSON format: unable to parse the provided data",
         ),
-        ('{"name": "Alice"}', List[str], ValueError, None, "Expected a list of items for result_as_str, received dict"),
+        ('{"name": "Alice"}', List[str], ValueError, None, "Expected a list of items, but received dict"),
         ("data", object, ValueError, None, "Unsupported output type: <class 'object'>"),
     ],
     ids=[

{vellum_ai-1.3.10 → vellum_ai-1.4.0}/src/vellum/workflows/nodes/utils.py

@@ -129,11 +129,11 @@ def parse_type_from_str(result_as_str: str, output_type: Any) -> Any:
             # raise ValueError("Invalid JSON Array format for result_as_str")
             raise NodeException(
                 code=WorkflowErrorCode.INVALID_OUTPUTS,
-                message="Invalid JSON Array format for result_as_str",
+                message="Invalid JSON format: expected a valid JSON array",
             )
 
         if not isinstance(data, list):
-            raise ValueError(f"Expected a list of items for result_as_str, received {data.__class__.__name__}")
+            raise ValueError(f"Expected a list of items, but received {data.__class__.__name__}")
 
         inner_type = get_args(output_type)[0]
         if issubclass(inner_type, BaseModel):
@@ -151,7 +151,7 @@ def parse_type_from_str(result_as_str: str, output_type: Any) -> Any:
         except json.JSONDecodeError:
             raise NodeException(
                 code=WorkflowErrorCode.INVALID_OUTPUTS,
-                message="Invalid JSON format for result_as_str",
+                message="Invalid JSON format: unable to parse the provided data",
             )
 
     if get_origin(output_type) is Union:
@@ -177,7 +177,7 @@ def parse_type_from_str(result_as_str: str, output_type: Any) -> Any:
         except json.JSONDecodeError:
             raise NodeException(
                 code=WorkflowErrorCode.INVALID_OUTPUTS,
-                message="Invalid JSON format for result_as_str",
+                message="Invalid JSON format: unable to parse the provided data",
             )
 
     raise ValueError(f"Unsupported output type: {output_type}")

{vellum_ai-1.3.10 → vellum_ai-1.4.0}/src/vellum/workflows/sandbox.py

@@ -1,9 +1,10 @@
-from typing import Generic, Optional, Sequence
+from typing import Generic, Optional, Sequence, Union
 
 import dotenv
 
 from vellum.workflows.events.workflow import WorkflowEventStream
 from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.inputs.dataset_row import DatasetRow
 from vellum.workflows.logging import load_logger
 from vellum.workflows.types.generics import WorkflowType
 from vellum.workflows.workflows.event_filters import root_workflow_event_filter
@@ -14,7 +15,7 @@ class WorkflowSandboxRunner(Generic[WorkflowType]):
         self,
         workflow: WorkflowType,
         inputs: Optional[Sequence[BaseInputs]] = None,  # DEPRECATED - remove in v2.0.0
-        dataset: Optional[Sequence[BaseInputs]] = None,
+        dataset: Optional[Sequence[Union[BaseInputs, DatasetRow]]] = None,
     ):
         dotenv.load_dotenv()
         self._logger = load_logger()
@@ -50,6 +51,9 @@ class WorkflowSandboxRunner(Generic[WorkflowType]):
 
         selected_inputs = self._inputs[index]
 
+        if isinstance(selected_inputs, DatasetRow):
+            selected_inputs = selected_inputs.inputs
+
         events = self._workflow.stream(
             inputs=selected_inputs,
             event_filter=root_workflow_event_filter,

vellum_ai-1.4.0/src/vellum/workflows/tests/test_dataset_row.py

@@ -0,0 +1,99 @@
+from typing import Optional
+
+from vellum.client.types.chat_message import ChatMessage
+from vellum.workflows.inputs.base import BaseInputs
+from vellum.workflows.inputs.dataset_row import DatasetRow
+
+
+def test_dataset_row_serialization():
+    """
+    Test that DatasetRow can be properly serialized to JSON and back.
+    """
+
+    class TestInputs(BaseInputs):
+        message: str
+        count: int
+        optional_field: Optional[str] = None
+        chat_history: list[ChatMessage]
+
+    test_inputs = TestInputs(
+        message="Hello World",
+        count=42,
+        optional_field="test",
+        chat_history=[ChatMessage(text="Hello", role="USER"), ChatMessage(text="Hi there!", role="ASSISTANT")],
+    )
+    dataset_row = DatasetRow(label="test_label", inputs=test_inputs)
+
+    serialized_dict = dataset_row.model_dump()
+
+    assert "label" in serialized_dict
+    assert "inputs" in serialized_dict
+    assert serialized_dict["label"] == "test_label"
+
+    inputs_data = serialized_dict["inputs"]
+    assert inputs_data["message"] == "Hello World"
+    assert inputs_data["count"] == 42
+    assert inputs_data["optional_field"] == "test"
+    assert "chat_history" in inputs_data
+    assert len(inputs_data["chat_history"]) == 2
+    assert inputs_data["chat_history"][0]["text"] == "Hello"
+    assert inputs_data["chat_history"][0]["role"] == "USER"
+    assert inputs_data["chat_history"][1]["text"] == "Hi there!"
+    assert inputs_data["chat_history"][1]["role"] == "ASSISTANT"
+
+
+def test_dataset_row_dict_serialization():
+    """
+    Test that DatasetRow can be properly converted to dict.
+    """
+
+    class SimpleInputs(BaseInputs):
+        text: str
+
+    simple_inputs = SimpleInputs(text="sample text")
+    dataset_row = DatasetRow(label="simple_label", inputs=simple_inputs)
+
+    result_dict = dataset_row.model_dump()
+
+    assert result_dict["label"] == "simple_label"
+    assert result_dict["inputs"]["text"] == "sample text"
+
+
+def test_dataset_row_with_multiple_fields():
+    """
+    Test that DatasetRow works with BaseInputs that have multiple fields.
+    """
+
+    class MultiFieldInputs(BaseInputs):
+        text_field: str
+        number_field: int
+        optional_field: Optional[str] = None
+
+    multi_inputs = MultiFieldInputs(text_field="test_text", number_field=456, optional_field="optional_value")
+    dataset_row = DatasetRow(label="multi_field_test", inputs=multi_inputs)
+
+    result_dict = dataset_row.model_dump()
+
+    assert result_dict["label"] == "multi_field_test"
+    assert result_dict["inputs"]["text_field"] == "test_text"
+    assert result_dict["inputs"]["number_field"] == 456
+    assert result_dict["inputs"]["optional_field"] == "optional_value"
+
+
+def test_dataset_row_with_default_inputs():
+    """
+    Test that DatasetRow works with BaseInputs that have default values.
+    """
+
+    class InputsWithDefaults(BaseInputs):
+        required_field: str
+        optional_with_default: str = "default_value"
+
+    inputs_with_defaults = InputsWithDefaults(required_field="required_value")
+    dataset_row = DatasetRow(label="defaults_test", inputs=inputs_with_defaults)
+
+    serialized_dict = dataset_row.model_dump()
+
+    assert serialized_dict["label"] == "defaults_test"
+    assert serialized_dict["inputs"]["required_field"] == "required_value"
+    assert serialized_dict["inputs"]["optional_with_default"] == "default_value"

{vellum_ai-1.3.10 → vellum_ai-1.4.0}/src/vellum/workflows/types/definition.py

@@ -2,13 +2,14 @@ import importlib
 import inspect
 from types import FrameType
 from uuid import UUID
-from typing import Annotated, Any, Dict, Literal, Optional, Union
+from typing import Annotated, Any, Dict, List, Literal, Optional, Union
 
 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.client.types.vellum_variable import VellumVariable
 from vellum.workflows.constants import AuthorizationType
 from vellum.workflows.references.environment_variable import EnvironmentVariableReference
 
@@ -82,6 +83,7 @@ class DeploymentDefinition(UniversalBaseModel):
     # hydrated fields
     name: Optional[str] = None
     description: Optional[str] = None
+    input_variables: Optional[List[VellumVariable]] = None
 
     def _is_uuid(self) -> bool:
         """Check if the deployment field is a valid UUID."""
@@ -105,6 +107,25 @@ class DeploymentDefinition(UniversalBaseModel):
             return self.deployment
         return None
 
+    def get_release_info(self, client: Vellum):
+        try:
+            release = client.workflow_deployments.retrieve_workflow_deployment_release(
+                self.deployment, self.release_tag
+            )
+        except Exception:
+            # If we fail to get the release info, we'll use the deployment name and description
+            return {
+                "name": self.deployment,
+                "description": f"Workflow Deployment for {self.deployment}",
+                "input_variables": [],
+            }
+
+        return {
+            "name": release.deployment.name,
+            "description": release.description or f"Workflow Deployment for {self.deployment}",
+            "input_variables": release.workflow_version.input_variables,
+        }
+
     @model_serializer(mode="wrap")
     def _serialize(self, handler, info: SerializationInfo):
         """Allow Pydantic to serialize directly given a `client` in context.
@@ -115,16 +136,11 @@ class DeploymentDefinition(UniversalBaseModel):
         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}"
-
+            release_info = self.get_release_info(client)
             return {
                 "type": "WORKFLOW_DEPLOYMENT",
-                "name": self.name,
-                "description": self.description,
+                "name": release_info["name"],
+                "description": release_info["description"],
                 "deployment": self.deployment,
                 "release_tag": self.release_tag,
             }