vellum-ai 0.14.77__tar.gz → 0.14.78__tar.gz

{vellum_ai-0.14.77 → vellum_ai-0.14.78}/PKG-INFO

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

{vellum_ai-0.14.77 → vellum_ai-0.14.78}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_inline_prompt_node_serialization.py

@@ -1,6 +1,9 @@
+from typing import List
+
 from deepdiff import DeepDiff
 
 from vellum import ChatMessagePromptBlock, FunctionDefinition, JinjaPromptBlock
+from vellum.client.types.chat_message import ChatMessage
 from vellum.workflows import BaseWorkflow
 from vellum.workflows.inputs import BaseInputs
 from vellum.workflows.nodes import InlinePromptNode
@@ -554,3 +557,52 @@ def test_serialize_workflow_with_nested_descriptor_blocks():
             "type": "DICTIONARY_REFERENCE",
         }
     ]
+
+
+def test_inline_prompt_node__coalesce_expression_serialization():
+    """
+    Tests that prompt nodes can serialize coalesce expressions like State.chat_history.coalesce([]).
+    """
+
+    # GIVEN a custom state with chat_history
+    class MyState(BaseState):
+        chat_history: List[ChatMessage] = []
+
+    # AND a prompt node that uses a coalesce expression as input
+    class MyNode(InlinePromptNode[MyState]):
+        ml_model = "gpt-4o"
+        blocks = []
+        prompt_inputs = {
+            "chat_history": MyState.chat_history.coalesce([]),
+        }
+
+    class TestWorkflow(BaseWorkflow[BaseInputs, MyState]):
+        graph = MyNode
+
+    # WHEN the node is serialized
+    workflow_display = get_workflow_display(workflow_class=TestWorkflow)
+    serialized: dict = workflow_display.serialize()
+
+    # THEN the prompt is serialized with the correct inputs
+    prompt_nodes = [node for node in serialized["workflow_raw_data"]["nodes"] if node["type"] == "PROMPT"]
+    prompt_node = prompt_nodes[0]
+
+    prompt_inputs_attr = next((attr for attr in prompt_node["attributes"] if attr["name"] == "prompt_inputs"), None)
+    assert prompt_inputs_attr
+    assert prompt_inputs_attr["value"]["type"] == "DICTIONARY_REFERENCE"
+    chat_history_entry = prompt_inputs_attr["value"]["entries"][0]
+
+    assert chat_history_entry["key"] == "chat_history"
+    assert chat_history_entry["value"]["type"] == "BINARY_EXPRESSION"
+    assert chat_history_entry["value"]["operator"] == "coalesce"
+    assert chat_history_entry["value"]["lhs"] == {
+        "type": "WORKFLOW_STATE",
+        "state_variable_id": "6012a4f7-a8ff-464d-bd62-7c41fde06fa4",
+    }
+    assert chat_history_entry["value"]["rhs"] == {
+        "type": "CONSTANT_VALUE",
+        "value": {
+            "type": "JSON",
+            "value": [],
+        },
+    }

{vellum_ai-0.14.77 → vellum_ai-0.14.78}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_serialization.py

@@ -146,7 +146,7 @@ def test_serialize_workflow():
                                     "forced": None,
                                     "strict": None,
                                 },
-                                "src": 'def get_current_weather(location: str, unit: str) -> str:\n    """\n    Get the current weather in a given location.\n    """\n    return f"The current weather in {location} is sunny with a temperature of 70 degrees {unit}."\n',  # noqa: E501
+                                "src": 'import math\n\n\ndef get_current_weather(location: str, unit: str) -> str:\n    """\n    Get the current weather in a given location.\n    """\n    return f"The current weather in {location} is sunny with a temperature of {get_temperature(70.1)} degrees {unit}."\n\n\ndef get_temperature(temperature: float) -> int:\n    """\n    Get the temperature in a given location.\n    """\n    return math.floor(temperature)\n',  # noqa: E501
                             }
                         ],
                     },

{vellum_ai-0.14.77 → vellum_ai-0.14.78}/ee/vellum_ee/workflows/display/tests/workflow_serialization/test_basic_tool_calling_node_workflow_deployment_serialization.py

@@ -1,5 +1,16 @@
+from datetime import datetime
+
 from deepdiff import DeepDiff
 
+from vellum.client.types.release_environment import ReleaseEnvironment
+from vellum.client.types.release_release_tag import ReleaseReleaseTag
+from vellum.client.types.release_review_reviewer import ReleaseReviewReviewer
+from vellum.client.types.slim_release_review import SlimReleaseReview
+from vellum.client.types.workflow_deployment_release import WorkflowDeploymentRelease
+from vellum.client.types.workflow_deployment_release_workflow_deployment import (
+    WorkflowDeploymentReleaseWorkflowDeployment,
+)
+from vellum.client.types.workflow_deployment_release_workflow_version import WorkflowDeploymentReleaseWorkflowVersion
 from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
 
 from tests.workflows.basic_tool_calling_node_workflow_deployment.workflow import (
@@ -7,7 +18,41 @@ from tests.workflows.basic_tool_calling_node_workflow_deployment.workflow import
 )
 
 
-def test_serialize_workflow():
+def test_serialize_workflow(vellum_client):
+    vellum_client.release_reviews.retrieve_workflow_deployment_release.return_value = WorkflowDeploymentRelease(
+        id="test-id",
+        created=datetime.now(),
+        environment=ReleaseEnvironment(
+            id="test-id",
+            name="test-name",
+            label="test-label",
+        ),
+        created_by=None,
+        workflow_version=WorkflowDeploymentReleaseWorkflowVersion(
+            id="test-id",
+            input_variables=[],
+            output_variables=[],
+        ),
+        deployment=WorkflowDeploymentReleaseWorkflowDeployment(name="test-name"),
+        description="test-description",  # main mock
+        release_tags=[
+            ReleaseReleaseTag(
+                name="test-name",
+                source="USER",
+            )
+        ],
+        reviews=[
+            SlimReleaseReview(
+                id="test-id",
+                created=datetime.now(),
+                reviewer=ReleaseReviewReviewer(
+                    id="test-id",
+                    full_name="test-name",
+                ),
+                state="APPROVED",
+            )
+        ],
+    )
     # GIVEN a Workflow that uses a generic node
     # WHEN we serialize it
     workflow_display = get_workflow_display(workflow_class=BasicToolCallingNodeWorkflowDeploymentWorkflow)
@@ -51,8 +96,8 @@ def test_serialize_workflow():
                 "value": [
                     {
                         "type": "WORKFLOW_DEPLOYMENT",
-                        "name": "deployment_1",
-                        "description": "Workflow deployment for deployment_1",
+                        "name": "test-name",
+                        "description": "test-description",
                         "deployment": "deployment_1",
                         "release_tag": "LATEST",
                     }

{vellum_ai-0.14.77 → vellum_ai-0.14.78}/ee/vellum_ee/workflows/display/utils/expressions.py

@@ -346,14 +346,20 @@ def serialize_value(display_context: "WorkflowDisplayContext", value: Any) -> Js
         }
 
     if isinstance(value, DeploymentDefinition):
+        workflow_deployment_release = display_context.client.release_reviews.retrieve_workflow_deployment_release(
+            value.deployment, value.release_tag
+        )
+        name = workflow_deployment_release.deployment.name or value.deployment
+        description = workflow_deployment_release.description or f"Workflow Deployment for {name}"
+
         return {
             "type": "CONSTANT_VALUE",
             "value": {
                 "type": "JSON",
                 "value": {
                     "type": "WORKFLOW_DEPLOYMENT",
-                    "name": value.deployment,
-                    "description": f"Workflow deployment for {value.deployment}",
+                    "name": name,
+                    "description": description,
                     "deployment": value.deployment,
                     "release_tag": value.release_tag,
                 },

{vellum_ai-0.14.77 → vellum_ai-0.14.78}/pyproject.toml

@@ -3,7 +3,7 @@ name = "vellum-ai"
 
 [tool.poetry]
 name = "vellum-ai"
-version = "0.14.77"
+version = "0.14.78"
 description = ""
 readme = "README.md"
 authors = []
@@ -85,7 +85,6 @@ types-requests = "2.32.0.20240712"
 [tool.pytest.ini_options]
 testpaths = [ "tests" ]
 asyncio_mode = "auto"
-addopts = "--cov --cov-report=html --cov-report=term-missing"
 filterwarnings = [
     "ignore::pytest.PytestCollectionWarning"
 ]

{vellum_ai-0.14.77 → vellum_ai-0.14.78}/src/vellum/client/core/client_wrapper.py

@@ -18,7 +18,7 @@ class BaseClientWrapper:
         headers: typing.Dict[str, str] = {
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "vellum-ai",
-            "X-Fern-SDK-Version": "0.14.77",
+            "X-Fern-SDK-Version": "0.14.78",
         }
         headers["X-API-KEY"] = self.api_key
         return headers

{vellum_ai-0.14.77 → vellum_ai-0.14.78}/src/vellum/plugins/pydantic.py

@@ -71,7 +71,10 @@ class OnValidatePython(ValidatePythonHandlerProtocol):
                 self.tracked_descriptors[key] = value
                 # TODO: This does not yet work for descriptors that map to more complex types
                 # https://app.shortcut.com/vellum/story/4636
-                input[key] = value.types[0]()
+                if len(value.types) == 0:
+                    input[key] = dict()
+                else:
+                    input[key] = value.types[0]()
 
     def on_success(self, result: Any) -> None:
         if self.tracked_descriptors:

vellum_ai-0.14.78/src/vellum/plugins/tests/test_pydantic.py

@@ -0,0 +1,30 @@
+from typing import Any
+
+from pydantic import BaseModel
+
+from vellum.workflows.expressions.accessor import AccessorExpression
+from vellum.workflows.references.constant import ConstantValueReference
+from vellum.workflows.state.base import BaseState
+
+
+class TestState(BaseState):
+    pass
+
+
+class TestModel(BaseModel):
+    field: Any
+
+
+def test_pydantic_plugin__empty_types_descriptor():
+    """
+    Test that the pydantic plugin handles BaseDescriptor with empty types gracefully.
+    """
+
+    base_ref = ConstantValueReference({"name": "test"})
+    accessor = AccessorExpression(base=base_ref, field="name")
+
+    model = TestModel(field=accessor)
+
+    assert model is not None
+    assert hasattr(model, "field")
+    assert model.field == accessor

vellum_ai-0.14.78/src/vellum/prompts/__init__.py

@@ -0,0 +1,3 @@
+from .blocks import TextSystemMessage, TextUserMessage
+
+__all__ = ["TextSystemMessage", "TextUserMessage"]

vellum_ai-0.14.78/src/vellum/prompts/blocks/__init__.py

@@ -0,0 +1,3 @@
+from .helpers import TextSystemMessage, TextUserMessage
+
+__all__ = ["TextSystemMessage", "TextUserMessage"]

vellum_ai-0.14.78/src/vellum/prompts/blocks/helpers.py

@@ -0,0 +1,31 @@
+from vellum import ChatMessagePromptBlock, PlainTextPromptBlock, RichTextPromptBlock
+
+
+def TextSystemMessage(content: str) -> ChatMessagePromptBlock:
+    """
+    Create a text system message that autocasts to ChatMessagePromptBlock.
+
+    Args:
+        content: The text content for the system message
+
+    Returns:
+        ChatMessagePromptBlock configured as a system message
+    """
+    return ChatMessagePromptBlock(
+        chat_role="SYSTEM", blocks=[RichTextPromptBlock(blocks=[PlainTextPromptBlock(text=content)])]
+    )
+
+
+def TextUserMessage(content: str) -> ChatMessagePromptBlock:
+    """
+    Create a text user message that autocasts to ChatMessagePromptBlock.
+
+    Args:
+        content: The text content for the user message
+
+    Returns:
+        ChatMessagePromptBlock configured as a user message
+    """
+    return ChatMessagePromptBlock(
+        chat_role="USER", blocks=[RichTextPromptBlock(blocks=[PlainTextPromptBlock(text=content)])]
+    )

{vellum_ai-0.14.77 → vellum_ai-0.14.78}/src/vellum/workflows/expressions/accessor.py

@@ -1,6 +1,6 @@
 from collections.abc import Mapping
 import dataclasses
-from typing import Any, Sequence, Type, TypeVar, Union
+from typing import Any, Sequence, Type, TypeVar, Union, get_args, get_origin
 
 from pydantic import BaseModel, GetCoreSchemaHandler
 from pydantic_core import core_schema
@@ -22,12 +22,41 @@ class AccessorExpression(BaseDescriptor[Any]):
     ) -> None:
         super().__init__(
             name=f"{base.name}.{field}",
-            types=(),
+            types=self._infer_accessor_types(base, field),
             instance=None,
         )
         self._base = base
         self._field = field
 
+    def _infer_accessor_types(self, base: BaseDescriptor[LHS], field: Union[str, int]) -> tuple[Type, ...]:
+        """
+        Infer the types for this accessor expression based on the base descriptor's types
+        and the field being accessed.
+        """
+        if not base.types:
+            return ()
+
+        inferred_types = []
+
+        for base_type in base.types:
+            origin = get_origin(base_type)
+            args = get_args(base_type)
+
+            if isinstance(field, int) and origin in (list, tuple) and args:
+                if origin is list:
+                    inferred_types.append(args[0])
+                elif origin is tuple and len(args) == 2 and args[1] is ...:
+                    inferred_types.append(args[0])
+                elif origin is tuple and len(args) > abs(field):
+                    if field >= 0:
+                        inferred_types.append(args[field])
+                    else:
+                        inferred_types.append(args[field])
+            elif isinstance(field, str) and origin in (dict,) and len(args) >= 2:
+                inferred_types.append(args[1])  # Value type from Dict[K, V]
+
+        return tuple(set(inferred_types)) if inferred_types else ()
+
     def resolve(self, state: "BaseState") -> Any:
         base = resolve_value(self._base, state)
 

{vellum_ai-0.14.77 → vellum_ai-0.14.78}/src/vellum/workflows/expressions/tests/test_accessor.py

@@ -1,11 +1,14 @@
 import pytest
 from dataclasses import dataclass
+from typing import Dict, List
 
 from pydantic import BaseModel
 
 from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.expressions.accessor import AccessorExpression
+from vellum.workflows.outputs.base import BaseOutputs
 from vellum.workflows.references.constant import ConstantValueReference
+from vellum.workflows.references.output import OutputReference
 from vellum.workflows.state.base import BaseState
 
 
@@ -187,3 +190,59 @@ def test_accessor_expression_unsupported_type():
         accessor.resolve(state)
 
     assert "Cannot get field field from 42" in str(exc_info.value)
+
+
+def test_accessor_expression_list_type_inference():
+    """Test that accessor expressions correctly infer element types from List[str]."""
+    base_ref: OutputReference = OutputReference(
+        name="test_list",
+        types=(List[str],),
+        instance=None,
+        outputs_class=BaseOutputs,
+    )
+
+    accessor = AccessorExpression(base=base_ref, field=0)
+
+    assert accessor.types == (str,)
+
+
+def test_accessor_expression_tuple_type_inference():
+    """Test that accessor expressions correctly infer element types from Tuple types."""
+    base_ref: OutputReference = OutputReference(
+        name="test_tuple",
+        types=(tuple,),
+        instance=None,
+        outputs_class=BaseOutputs,
+    )
+
+    accessor = AccessorExpression(base=base_ref, field=0)
+
+    assert accessor.types == ()
+
+
+def test_accessor_expression_dict_type_inference():
+    """Test that accessor expressions correctly infer value types from Dict types."""
+    base_ref: OutputReference = OutputReference(
+        name="test_dict",
+        types=(Dict[str, int],),
+        instance=None,
+        outputs_class=BaseOutputs,
+    )
+
+    accessor = AccessorExpression(base=base_ref, field="some_key")
+
+    assert accessor.types == (int,)
+
+
+def test_accessor_expression_empty_base_types():
+    """Test that accessor expressions handle empty base types gracefully."""
+    base_ref: OutputReference = OutputReference(
+        name="test_empty",
+        types=(),
+        instance=None,
+        outputs_class=BaseOutputs,
+    )
+
+    accessor = AccessorExpression(base=base_ref, field=0)
+
+    assert accessor.types == ()

{vellum_ai-0.14.77 → vellum_ai-0.14.78}/src/vellum/workflows/nodes/experimental/tool_calling_node/utils.py

@@ -251,7 +251,12 @@ def create_function_node(
         )
     else:
         # For regular functions, use CodeExecutionNode approach
-        function_source = inspect.getsource(function)
+        # function tool must be put in another file (no need to have the same name)
+        source_path = inspect.getmodule(function)
+        if source_path is not None:
+            function_source = inspect.getsource(source_path)
+        else:
+            function_source = f"<source code not available for {function.__name__}>"
         function_name = function.__name__
 
         code = f'''

{vellum_ai-0.14.77 → vellum_ai-0.14.78}/src/vellum/workflows/state/encoder.py

@@ -10,6 +10,7 @@ from typing import Any, Callable, Dict, Type
 from pydantic import BaseModel
 
 from vellum.workflows.constants import undefined
+from vellum.workflows.expressions.coalesce_expression import CoalesceExpression
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.outputs.base import BaseOutput, BaseOutputs
 from vellum.workflows.ports.port import Port
@@ -21,6 +22,10 @@ class DefaultStateEncoder(JSONEncoder):
     encoders: Dict[Type, Callable] = {}
 
     def default(self, obj: Any) -> Any:
+        if isinstance(obj, CoalesceExpression):
+            empty_state = BaseState()
+            return self.default(obj.resolve(empty_state))
+
         if isinstance(obj, BaseState):
             return dict(obj)
 
@@ -61,9 +66,11 @@ class DefaultStateEncoder(JSONEncoder):
 
         if callable(obj):
             function_definition = compile_function_definition(obj)
-            try:
-                source_code = inspect.getsource(obj)
-            except Exception:
+            source_path = inspect.getsourcefile(obj)
+            if source_path is not None:
+                with open(source_path, "r") as f:
+                    source_code = f.read()
+            else:
                 source_code = f"<source code not available for {obj.__name__}>"
 
             return {

{vellum_ai-0.14.77 → vellum_ai-0.14.78}/src/vellum/workflows/utils/vellum_variables.py

@@ -50,6 +50,11 @@ def primitive_type_to_vellum_variable_type(type_: Union[Type, BaseDescriptor]) -
             # Number now supports float and int
             elif types == [float, int]:
                 return "NUMBER"
+
+            collapse_types = _collapse_types(types)
+            if len(collapse_types) == 1:
+                return primitive_type_to_vellum_variable_type(collapse_types[0])
+
             raise ValueError(f"Expected Descriptor to only have one type, got {types}")
 
         type_ = type_.types[0]
@@ -129,3 +134,35 @@ def _is_type_optionally_equal(type_: Type, target_type: Type) -> bool:
 
 def _is_type_optionally_in(type_: Type, target_types: Tuple[Type, ...]) -> bool:
     return any(_is_type_optionally_equal(type_, target_type) for target_type in target_types)
+
+
+def _collapse_types(types: List[Type]) -> List[Type]:
+    """
+    Collapses a list of types into a list of types that are not subtypes of each other.
+    What remains are the "most specific" types.
+    """
+
+    new_types: List[Type] = []
+    for target_type in types:
+        if any(_is_subtype(source_type, target_type) for source_type in new_types):
+            continue
+
+        new_types.append(target_type)
+
+    return new_types
+
+
+def _is_subtype(source_type: Type, target_type: Type) -> bool:
+    """
+    Checks if `source_type` is a strict subtype of `target_type`. Meaning all values that are
+    of type `source_type` are also of type `target_type`.
+    """
+
+    if source_type == target_type:
+        return True
+
+    source_origin = get_origin(source_type)
+    if source_origin == target_type:
+        return True
+
+    return False