vellum-ai 1.2.2__py3-none-any.whl → 1.2.4__py3-none-any.whl

vellum/workflows/nodes/core/templating_node/tests/test_templating_node.py

@@ -317,3 +317,132 @@ def test_api_error_templating_node():
 
     # THEN the output should be empty string
     assert outputs.result == ""
+
+
+@pytest.mark.parametrize(
+    "template,inputs,expected_result",
+    [
+        # String value access
+        ("{{ text_input.value }}", {"text_input": "hello world"}, "hello world"),
+        # Function call value access
+        (
+            "{{ func.value.name }}",
+            {"func": FunctionCall(name="test_function", arguments={"key": "value"})},
+            "test_function",
+        ),
+        # Array item value access
+        ("{{ items[0].value }}", {"items": ["apple"]}, "apple"),
+    ],
+    ids=["string_value", "function_call_value", "array_item_value"],
+)
+def test_templating_node__value_access_patterns_str(template, inputs, expected_result):
+    # GIVEN a templating node that accesses wrapper value properties
+    class TemplateNode(TemplatingNode[BaseState, str]):
+        pass
+
+    # Set template and inputs dynamically
+    TemplateNode.template = template
+    TemplateNode.inputs = inputs
+
+    # WHEN the node is run
+    node = TemplateNode()
+    outputs = node.run()
+
+    # THEN the value is accessible
+    assert outputs.result == expected_result
+
+
+@pytest.mark.parametrize(
+    "template,inputs,expected_result",
+    [
+        # Dict value access
+        ("{{ data.value }}", {"data": {"name": "test", "score": 42}}, {"name": "test", "score": 42}),
+        # List value access
+        ("{{ items.value }}", {"items": ["item1", "item2", "item3"]}, ["item1", "item2", "item3"]),
+    ],
+    ids=["dict_value", "list_value"],
+)
+def test_templating_node__value_access_patterns_json(template, inputs, expected_result):
+    # GIVEN a templating node that accesses wrapper value properties
+    class TemplateNode(TemplatingNode[BaseState, Json]):
+        pass
+
+    # Set template and inputs dynamically
+    TemplateNode.template = template
+    TemplateNode.inputs = inputs
+
+    # WHEN the node is run
+    node = TemplateNode()
+    outputs = node.run()
+
+    # THEN the value is accessible
+    assert outputs.result == expected_result
+
+
+@pytest.mark.parametrize(
+    "template,inputs,expected_result",
+    [
+        # String type access
+        ("{{ text_input.type }}", {"text_input": "hello world"}, "STRING"),
+        # Function call type access
+        ("{{ func.type }}", {"func": FunctionCall(name="test_function", arguments={"key": "value"})}, "FUNCTION_CALL"),
+    ],
+    ids=["string_type", "function_call_type"],
+)
+def test_templating_node__type_access_patterns(template, inputs, expected_result):
+    # GIVEN a templating node that accesses wrapper type properties
+    class TemplateNode(TemplatingNode[BaseState, str]):
+        pass
+
+    # Set template and inputs dynamically
+    TemplateNode.template = template
+    TemplateNode.inputs = inputs
+
+    # WHEN the node is run
+    node = TemplateNode()
+    outputs = node.run()
+
+    # THEN the type is accessible
+    assert outputs.result == expected_result
+
+
+def test_templating_node__nested_dict_access():
+    # GIVEN a templating node with nested dict access
+    class TemplateNode(TemplatingNode[BaseState, str]):
+        template = "{{ data.user.name }}"
+        inputs = {"data": {"user": {"name": "John Doe", "age": 30}, "status": "active"}}
+
+    # WHEN the node is run
+    node = TemplateNode()
+    outputs = node.run()
+
+    # THEN nested properties are accessible
+    assert outputs.result == "John Doe"
+
+
+def test_templating_node__list_iteration_wrapper_access():
+    # GIVEN a templating node that iterates over list with wrapper access
+    class TemplateNode(TemplatingNode[BaseState, str]):
+        template = "{% for item in items %}{{ item.value }}{% if not loop.last %},{% endif %}{% endfor %}"
+        inputs = {"items": ["apple", "banana", "cherry"]}
+
+    # WHEN the node is run
+    node = TemplateNode()
+    outputs = node.run()
+
+    # THEN list iteration with wrapper access works
+    assert outputs.result == "apple,banana,cherry"
+
+
+def test_templating_node__conditional_type_checking():
+    # GIVEN a templating node with conditional type checking
+    class TemplateNode(TemplatingNode[BaseState, str]):
+        template = "{% if input.type == 'STRING' %}{{ input.value }}{% else %}unknown{% endif %}"
+        inputs = {"input": "test string"}
+
+    # WHEN the node is run
+    node = TemplateNode()
+    outputs = node.run()
+
+    # THEN conditional type checking works
+    assert outputs.result == "test string"

vellum/workflows/nodes/displayable/bases/inline_prompt_node/node.py

@@ -28,6 +28,7 @@ from vellum.workflows.errors.types import vellum_error_to_workflow_error
 from vellum.workflows.events.types import default_serializer
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.displayable.bases.base_prompt_node import BasePromptNode
+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
@@ -197,6 +198,17 @@ class BaseInlinePromptNode(BasePromptNode[StateType], Generic[StateType]):
             elif event.state == "STREAMING":
                 yield BaseOutput(name="results", delta=event.output.value)
             elif event.state == "FULFILLED":
+                if event.meta and event.meta.finish_reason == "LENGTH":
+                    text_value, json_value = process_additional_prompt_outputs(event.outputs)
+                    if text_value == "":
+                        raise NodeException(
+                            message=(
+                                "Maximum tokens reached before model could output any content. "
+                                "Consider increasing the max_tokens Prompt Parameter."
+                            ),
+                            code=WorkflowErrorCode.INVALID_OUTPUTS,
+                        )
+
                 outputs = event.outputs
                 yield BaseOutput(name="results", value=event.outputs)
             elif event.state == "REJECTED":

vellum/workflows/nodes/displayable/bases/inline_prompt_node/tests/test_inline_prompt_node.py

@@ -20,6 +20,7 @@ from vellum import (
 )
 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
@@ -684,3 +685,43 @@ def test_inline_prompt_node__invalid_function_type():
     # AND the error should have the correct code and message
     assert excinfo.value.code == WorkflowErrorCode.INVALID_INPUTS
     assert "`not_a_function` is not a valid function definition" == str(excinfo.value)
+
+
+def test_inline_prompt_node__empty_string_output_with_length_finish_reason(vellum_adhoc_prompt_client):
+    """
+    Tests that InlinePromptNode raises NodeException for empty string output with LENGTH finish_reason.
+    """
+
+    # GIVEN an InlinePromptNode with basic configuration
+    class TestNode(InlinePromptNode):
+        ml_model = "test-model"
+        blocks = []
+        prompt_inputs = {}
+
+    expected_outputs: List[PromptOutput] = [
+        StringVellumValue(value=""),
+    ]
+
+    def generate_prompt_events(*args: Any, **kwargs: Any) -> Iterator[ExecutePromptEvent]:
+        execution_id = str(uuid4())
+        events: List[ExecutePromptEvent] = [
+            InitiatedExecutePromptEvent(execution_id=execution_id),
+            FulfilledExecutePromptEvent(
+                execution_id=execution_id,
+                outputs=expected_outputs,
+                meta=FulfilledPromptExecutionMeta(finish_reason="LENGTH"),
+            ),
+        ]
+        yield from events
+
+    vellum_adhoc_prompt_client.adhoc_execute_prompt_stream.side_effect = generate_prompt_events
+
+    # WHEN the node is run
+    node = TestNode()
+
+    # THEN it should raise a NodeException with INVALID_OUTPUTS error code
+    with pytest.raises(NodeException) as excinfo:
+        list(node.run())
+
+    # AND the exception should have the correct error code
+    assert excinfo.value.code == WorkflowErrorCode.INVALID_OUTPUTS

vellum/workflows/nodes/displayable/bases/utils.py

@@ -1,7 +1,8 @@
 import enum
 import json
-from typing import Any, List, Union, cast
+from typing import Any, List, Optional, Tuple, Union, cast
 
+from vellum import PromptOutput
 from vellum.client.types.array_vellum_value import ArrayVellumValue
 from vellum.client.types.array_vellum_value_request import ArrayVellumValueRequest
 from vellum.client.types.audio_vellum_value import AudioVellumValue
@@ -123,3 +124,39 @@ def primitive_to_vellum_value_request(value: Any) -> VellumValueRequest:
         raise ValueError(f"Unsupported variable type: {vellum_value.__class__.__name__}")
 
     return vellum_value_request_class.model_validate(vellum_value.model_dump())
+
+
+def process_additional_prompt_outputs(outputs: List[PromptOutput]) -> Tuple[str, Optional[Any]]:
+    """
+    Process prompt outputs using the same logic as prompt nodes to determine text output.
+
+    Args:
+        outputs: List of prompt outputs to process
+
+    Returns:
+        The text representation of the outputs joined with newlines
+        The JSON representation of the outputs
+    """
+    string_outputs = []
+    json_output = None
+    for output in outputs:
+        if output.value is None:
+            continue
+
+        if output.type == "STRING":
+            string_outputs.append(output.value)
+            try:
+                json_output = json.loads(output.value)
+            except (json.JSONDecodeError, TypeError):
+                pass
+        elif output.type == "JSON":
+            string_outputs.append(json.dumps(output.value, indent=4))
+            json_output = output.value
+        elif output.type == "FUNCTION_CALL":
+            string_outputs.append(output.value.model_dump_json(indent=4))
+        elif output.type == "THINKING":
+            continue
+        else:
+            string_outputs.append(output.value.message)
+
+    return "\n".join(string_outputs), json_output

vellum/workflows/nodes/displayable/code_execution_node/utils.py

@@ -4,13 +4,10 @@ import sys
 import traceback
 from typing import Any, Optional, Tuple, Union
 
-from pydantic import BaseModel
-
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
-from vellum.workflows.nodes.utils import cast_to_output_type
+from vellum.workflows.nodes.utils import cast_to_output_type, wrap_inputs_for_backward_compatibility
 from vellum.workflows.state.context import WorkflowContext
-from vellum.workflows.types.code_execution_node_wrappers import ListWrapper, clean_for_dict_wrapper
 from vellum.workflows.types.core import EntityInputsInterface
 
 
@@ -51,23 +48,9 @@ def run_code_inline(
         print_line = f"{' '.join(str_args)}\n"
         log_buffer.write(print_line)
 
-    def wrap_value(value):
-        if isinstance(value, list):
-            return ListWrapper(
-                [
-                    # Convert VellumValue to dict with its fields
-                    (
-                        item.model_dump()
-                        if isinstance(item, BaseModel)
-                        else clean_for_dict_wrapper(item) if isinstance(item, (dict, list, str)) else item
-                    )
-                    for item in value
-                ]
-            )
-        return clean_for_dict_wrapper(value)
-
+    wrapped_inputs = wrap_inputs_for_backward_compatibility(inputs)
     exec_globals = {
-        "__arg__inputs": {name: wrap_value(value) for name, value in inputs.items()},
+        "__arg__inputs": wrapped_inputs,
         "__arg__out": None,
         "print": _inline_print,
     }

vellum/workflows/nodes/displayable/final_output_node/node.py

@@ -4,6 +4,7 @@ from vellum.workflows.constants import undefined
 from vellum.workflows.nodes.bases import BaseNode
 from vellum.workflows.nodes.bases.base import BaseNodeMeta
 from vellum.workflows.nodes.utils import cast_to_output_type
+from vellum.workflows.ports import NodePorts
 from vellum.workflows.types import MergeBehavior
 from vellum.workflows.types.generics import StateType
 from vellum.workflows.types.utils import get_original_base
@@ -47,6 +48,9 @@ class FinalOutputNode(BaseNode[StateType], Generic[StateType, _OutputType], meta
     class Trigger(BaseNode.Trigger):
         merge_behavior = MergeBehavior.AWAIT_ANY
 
+    class Ports(NodePorts):
+        pass
+
     class Outputs(BaseNode.Outputs):
         # We use our mypy plugin to override the _OutputType with the actual output type
         # for downstream references to this output.

vellum/workflows/nodes/displayable/inline_prompt_node/node.py

@@ -1,10 +1,10 @@
-import json
 from typing import Any, Dict, Generic, Iterator, Type, Union
 
 from vellum.workflows.constants import undefined
 from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.displayable.bases import BaseInlinePromptNode as BaseInlinePromptNode
+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.generics import StateType
@@ -45,31 +45,8 @@ class InlinePromptNode(BaseInlinePromptNode[StateType], Generic[StateType]):
                 code=WorkflowErrorCode.INTERNAL_ERROR,
             )
 
-        string_outputs = []
-        json_output = None
-
-        for output in outputs:
-            if output.value is None:
-                continue
-
-            if output.type == "STRING":
-                string_outputs.append(output.value)
-                try:
-                    json_output = json.loads(output.value)
-                except (json.JSONDecodeError, TypeError):
-                    pass
-            elif output.type == "JSON":
-                string_outputs.append(json.dumps(output.value, indent=4))
-                json_output = output.value
-            elif output.type == "FUNCTION_CALL":
-                string_outputs.append(output.value.model_dump_json(indent=4))
-            elif output.type == "THINKING":
-                continue
-            else:
-                string_outputs.append(output.value.message)
-
-        value = "\n".join(string_outputs)
-        yield BaseOutput(name="text", value=value)
+        text_output, json_output = process_additional_prompt_outputs(outputs)
+        yield BaseOutput(name="text", value=text_output)
 
         if json_output:
             yield BaseOutput(name="json", value=json_output)

vellum/workflows/nodes/displayable/prompt_deployment_node/node.py

@@ -1,10 +1,10 @@
-import json
 from typing import Any, Dict, Iterator, Type, Union
 
 from vellum.workflows.constants import undefined
 from vellum.workflows.errors import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes.displayable.bases import BasePromptDeploymentNode as BasePromptDeploymentNode
+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.generics import StateType
@@ -48,30 +48,8 @@ class PromptDeploymentNode(BasePromptDeploymentNode[StateType]):
                 code=WorkflowErrorCode.INTERNAL_ERROR,
             )
 
-        string_outputs = []
-        json_output = None
-
-        for output in outputs:
-            if output.value is None:
-                continue
-
-            if output.type == "STRING":
-                string_outputs.append(output.value)
-                try:
-                    json_output = json.loads(output.value)
-                except (json.JSONDecodeError, TypeError):
-                    pass
-            elif output.type == "JSON":
-                string_outputs.append(json.dumps(output.value, indent=4))
-            elif output.type == "FUNCTION_CALL":
-                string_outputs.append(output.value.model_dump_json(indent=4))
-            elif output.type == "THINKING":
-                continue
-            else:
-                string_outputs.append(output.value.message)
-
-        value = "\n".join(string_outputs)
-        yield BaseOutput(name="text", value=value)
+        text_output, json_output = process_additional_prompt_outputs(outputs)
+        yield BaseOutput(name="text", value=text_output)
 
         if json_output:
             yield BaseOutput(name="json", value=json_output)

vellum/workflows/nodes/displayable/subworkflow_deployment_node/node.py

@@ -232,7 +232,7 @@ class SubworkflowDeploymentNode(BaseNode[StateType], Generic[StateType]):
             )
 
         resolved_workflow = self._context.resolve_workflow_deployment(
-            deployment_name=deployment_name, release_tag=self.release_tag
+            deployment_name=deployment_name, release_tag=self.release_tag, state=self.state
         )
         if resolved_workflow:
             yield from self._run_resolved_workflow(resolved_workflow)

vellum/workflows/nodes/utils.py

@@ -15,7 +15,12 @@ from vellum.workflows.nodes import BaseNode
 from vellum.workflows.nodes.bases.base_adornment_node import BaseAdornmentNode
 from vellum.workflows.ports.port import Port
 from vellum.workflows.state.base import BaseState
-from vellum.workflows.types.code_execution_node_wrappers import DictWrapper, ListWrapper, StringValueWrapper
+from vellum.workflows.types.code_execution_node_wrappers import (
+    DictWrapper,
+    ListWrapper,
+    StringValueWrapper,
+    clean_for_dict_wrapper,
+)
 from vellum.workflows.types.core import Json
 from vellum.workflows.types.generics import NodeType
 
@@ -261,3 +266,23 @@ def cast_to_output_type(result: Any, output_type: Any) -> Any:
             code=WorkflowErrorCode.INVALID_OUTPUTS,
             message=f"Expected an output of type '{output_type_name}', but received '{result_type_name}'",
         )
+
+
+def wrap_inputs_for_backward_compatibility(inputs: Dict[str, Any]) -> Dict[str, Any]:
+    """Wrap inputs with backward-compatible wrapper classes for legacy .value and .type support."""
+
+    def _wrap_single_value(value: Any) -> Any:
+        if isinstance(value, list):
+            return ListWrapper(
+                [
+                    (
+                        item.model_dump()
+                        if isinstance(item, BaseModel)
+                        else clean_for_dict_wrapper(item) if isinstance(item, (dict, list, str)) else item
+                    )
+                    for item in value
+                ]
+            )
+        return clean_for_dict_wrapper(value)
+
+    return {name: _wrap_single_value(value) for name, value in inputs.items()}

vellum/workflows/ports/node_ports.py

@@ -40,6 +40,9 @@ class NodePorts(metaclass=_NodePortsMeta):
 
         invoked_ports: Set[Port] = set()
         all_ports = [port for port in self.__class__]
+        if not all_ports:
+            return set()
+
         enforce_single_invoked_conditional_port = validate_ports(all_ports)
 
         for port in all_ports:

vellum/workflows/ports/port.py

@@ -9,6 +9,7 @@ from vellum.workflows.edges.edge import Edge
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.graph import Graph, GraphTarget
+from vellum.workflows.graph.graph import NoPortsNode
 from vellum.workflows.state.base import BaseState
 from vellum.workflows.types.core import ConditionType
 
@@ -66,6 +67,12 @@ class Port:
         if isinstance(other, Port):
             return Graph.from_port(self) >> Graph.from_port(other)
 
+        if isinstance(other, NoPortsNode):
+            raise ValueError(
+                f"Cannot create edge to {other.node_class.__name__} because it has no ports defined. "
+                f"Nodes with empty Ports classes cannot be connected to other nodes."
+            )
+
         edge = Edge(from_port=self, to_node=other)
         if edge not in self._edges:
             self._edges.append(edge)

vellum/workflows/state/context.py

@@ -4,15 +4,17 @@ from uuid import uuid4
 from typing import TYPE_CHECKING, Dict, List, Optional, Type
 
 from vellum import Vellum
-from vellum.workflows.context import ExecutionContext, get_execution_context
+from vellum.workflows.context import ExecutionContext, get_execution_context, set_execution_context
 from vellum.workflows.events.types import ExternalParentContext
 from vellum.workflows.nodes.mocks import MockNodeExecution, MockNodeExecutionArg
 from vellum.workflows.outputs.base import BaseOutputs
 from vellum.workflows.references.constant import ConstantValueReference
+from vellum.workflows.utils.uuids import generate_workflow_deployment_prefix
 from vellum.workflows.vellum_client import create_vellum_client
 
 if TYPE_CHECKING:
     from vellum.workflows.events.workflow import WorkflowEvent
+    from vellum.workflows.state.base import BaseState
     from vellum.workflows.workflows.base import BaseWorkflow
 
 
@@ -23,11 +25,13 @@ class WorkflowContext:
         vellum_client: Optional[Vellum] = None,
         execution_context: Optional[ExecutionContext] = None,
         generated_files: Optional[dict[str, str]] = None,
+        namespace: Optional[str] = None,
     ):
         self._vellum_client = vellum_client
         self._event_queue: Optional[Queue["WorkflowEvent"]] = None
         self._node_output_mocks_map: Dict[Type[BaseOutputs], List[MockNodeExecution]] = {}
         self._execution_context = get_execution_context()
+        self._namespace = namespace
 
         if execution_context is not None:
             self._execution_context.trace_id = execution_context.trace_id
@@ -36,6 +40,8 @@ class WorkflowContext:
 
         if self._execution_context.parent_context is None:
             self._execution_context.parent_context = ExternalParentContext(span_id=uuid4())
+            # Propagate the updated context back to the global execution context
+            set_execution_context(self._execution_context)
 
         self._generated_files = generated_files
 
@@ -54,6 +60,10 @@ class WorkflowContext:
     def generated_files(self) -> Optional[dict[str, str]]:
         return self._generated_files
 
+    @cached_property
+    def namespace(self) -> Optional[str]:
+        return self._namespace
+
     @cached_property
     def node_output_mocks_map(self) -> Dict[Type[BaseOutputs], List[MockNodeExecution]]:
         return self._node_output_mocks_map
@@ -132,19 +142,40 @@ class WorkflowContext:
     def _get_all_node_output_mocks(self) -> List[MockNodeExecution]:
         return [mock for mocks in self._node_output_mocks_map.values() for mock in mocks]
 
-    def resolve_workflow_deployment(self, deployment_name: str, release_tag: str) -> Optional["BaseWorkflow"]:
+    def resolve_workflow_deployment(
+        self, deployment_name: str, release_tag: str, state: "BaseState"
+    ) -> Optional["BaseWorkflow"]:
         """
         Resolve a workflow deployment by name and release tag.
 
         Args:
             deployment_name: The name of the workflow deployment
             release_tag: The release tag to resolve
+            state: The base state to pass to the workflow
 
         Returns:
             BaseWorkflow instance if found, None otherwise
         """
-        return None
+        if not self.generated_files or not self.namespace:
+            return None
+
+        expected_prefix = generate_workflow_deployment_prefix(deployment_name, release_tag)
+
+        workflow_file_key = f"{expected_prefix}/workflow.py"
+        if workflow_file_key not in self.generated_files:
+            return None
+
+        try:
+            from vellum.workflows.workflows.base import BaseWorkflow
+
+            WorkflowClass = BaseWorkflow.load_from_module(f"{self.namespace}.{expected_prefix}")
+            workflow_instance = WorkflowClass(context=WorkflowContext.create_from(self), parent_state=state)
+            return workflow_instance
+        except Exception:
+            return None
 
     @classmethod
     def create_from(cls, context):
-        return cls(vellum_client=context.vellum_client, generated_files=context.generated_files)
+        return cls(
+            vellum_client=context.vellum_client, generated_files=context.generated_files, namespace=context.namespace
+        )

vellum/workflows/types/definition.py

@@ -121,6 +121,7 @@ class ComposioToolDefinition(UniversalBaseModel):
 class MCPServer(UniversalBaseModel):
     type: Literal["MCP_SERVER"] = "MCP_SERVER"
     name: str
+    description: str = ""  # We don't use this field, its for compatibility with UI
     url: str
     authorization_type: Optional[AuthorizationType] = None
     bearer_token_value: Optional[Union[str, EnvironmentVariableReference]] = None

vellum/workflows/utils/functions.py

@@ -89,6 +89,10 @@ def compile_annotation(annotation: Optional[Any], defs: dict[str, Any]) -> dict:
                 # Mypy is incorrect here, the `annotation` attribute is defined on `FieldInfo`
                 field_annotation = field.annotation  # type: ignore[attr-defined]
                 properties[field_name] = compile_annotation(field_annotation, defs)
+
+                if hasattr(field, "description") and field.description is not None:
+                    properties[field_name]["description"] = field.description  # type: ignore[attr-defined]
+
                 if field.default is PydanticUndefined:
                     required.append(field_name)
                 else:

vellum/workflows/utils/tests/test_functions.py

@@ -4,7 +4,7 @@ from enum import Enum
 from unittest.mock import Mock
 from typing import Annotated, Dict, List, Literal, Optional, Tuple, Union
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 from vellum.client.types.function_definition import FunctionDefinition
 from vellum.client.types.string_vellum_value import StringVellumValue
@@ -206,7 +206,7 @@ def test_compile_function_definition__dataclasses():
 def test_compile_function_definition__pydantic():
     # GIVEN a function with a pydantic model
     class MyPydanticModel(BaseModel):
-        a: int
+        a: int = Field(description="The first number")
         b: str
 
     def my_function(c: MyPydanticModel):
@@ -225,7 +225,10 @@ def test_compile_function_definition__pydantic():
             "$defs": {
                 "MyPydanticModel": {
                     "type": "object",
-                    "properties": {"a": {"type": "integer"}, "b": {"type": "string"}},
+                    "properties": {
+                        "a": {"type": "integer", "description": "The first number"},
+                        "b": {"type": "string"},
+                    },
                     "required": ["a", "b"],
                 }
             },

vellum/workflows/utils/uuids.py

@@ -2,6 +2,21 @@ import hashlib
 from uuid import UUID
 
 
+def generate_workflow_deployment_prefix(deployment_name: str, release_tag: str) -> str:
+    """
+    Generate a workflow deployment prefix from deployment name and release tag.
+
+    Args:
+        deployment_name: The name of the workflow deployment
+        release_tag: The release tag to resolve
+
+    Returns:
+        The generated prefix in format vellum_workflow_deployment_{hash}
+    """
+    expected_hash = str(uuid4_from_hash(f"{deployment_name}|{release_tag}")).replace("-", "_")
+    return f"vellum_workflow_deployment_{expected_hash}"
+
+
 def uuid4_from_hash(input_str: str) -> UUID:
     # Create a SHA-256 hash of the input string
     hash_bytes = hashlib.sha256(input_str.encode()).digest()

{vellum_ai-1.2.2.dist-info → vellum_ai-1.2.4.dist-info}/METADATA

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