vellum-ai 0.14.20__tar.gz → 0.14.21__tar.gz

{vellum_ai-0.14.20 → vellum_ai-0.14.21}/PKG-INFO

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

{vellum_ai-0.14.20 → vellum_ai-0.14.21}/ee/vellum_ee/workflows/display/base.py

@@ -59,10 +59,6 @@ class EdgeDisplayOverrides(EdgeDisplay):
     pass
 
 
-EdgeDisplayType = TypeVar("EdgeDisplayType", bound=EdgeDisplay)
-EdgeDisplayOverridesType = TypeVar("EdgeDisplayOverridesType", bound=EdgeDisplayOverrides)
-
-
 @dataclass
 class EntrypointDisplayOverrides:
     id: UUID

{vellum_ai-0.14.20 → vellum_ai-0.14.21}/ee/vellum_ee/workflows/display/nodes/vellum/api_node.py

@@ -14,15 +14,6 @@ _APINodeType = TypeVar("_APINodeType", bound=APINode)
 
 
 class BaseAPINodeDisplay(BaseNodeVellumDisplay[_APINodeType], Generic[_APINodeType]):
-    url_input_id: ClassVar[Optional[UUID]] = None
-    method_input_id: ClassVar[Optional[UUID]] = None
-    body_input_id: ClassVar[Optional[UUID]] = None
-
-    authorization_type_input_id: ClassVar[Optional[UUID]] = None
-    bearer_token_value_input_id: ClassVar[Optional[UUID]] = None
-    api_key_header_key_input_id: ClassVar[Optional[UUID]] = None
-    api_key_header_value_input_id: ClassVar[Optional[UUID]] = None
-
     # A mapping between node input keys and their ids for inputs representing additional header keys
     additional_header_key_input_ids: ClassVar[Optional[Dict[str, UUID]]] = None
 
@@ -41,7 +32,7 @@ class BaseAPINodeDisplay(BaseNodeVellumDisplay[_APINodeType], Generic[_APINodeTy
             input_name="url",
             value=node_url,
             display_context=display_context,
-            input_id=self.url_input_id,
+            input_id=self.node_input_ids_by_name.get(APINode.url.name),
         )
 
         node_method = raise_if_descriptor(node.method)
@@ -50,7 +41,7 @@ class BaseAPINodeDisplay(BaseNodeVellumDisplay[_APINodeType], Generic[_APINodeTy
             input_name="method",
             value=node_method,
             display_context=display_context,
-            input_id=self.method_input_id,
+            input_id=self.node_input_ids_by_name.get(APINode.method.name),
         )
 
         node_data = raise_if_descriptor(node.data)
@@ -60,7 +51,9 @@ class BaseAPINodeDisplay(BaseNodeVellumDisplay[_APINodeType], Generic[_APINodeTy
             input_name="body",
             value=node_data if node_data else node_json,
             display_context=display_context,
-            input_id=self.body_input_id,
+            input_id=self.node_input_ids_by_name.get(APINode.json.name)
+            # Kept for backwards compatibility with a bug in previous versions of SDK serialization
+            or self.node_input_ids_by_name.get("body"),
         )
 
         headers = raise_if_descriptor(node.headers)
@@ -75,7 +68,7 @@ class BaseAPINodeDisplay(BaseNodeVellumDisplay[_APINodeType], Generic[_APINodeTy
                 input_name="authorization_type",
                 value=authorization_type,
                 display_context=display_context,
-                input_id=self.authorization_type_input_id,
+                input_id=self.node_input_ids_by_name.get(APINode.authorization_type.name),
             )
             if authorization_type
             else None
@@ -85,7 +78,7 @@ class BaseAPINodeDisplay(BaseNodeVellumDisplay[_APINodeType], Generic[_APINodeTy
             input_name="bearer_token_value",
             value=bearer_token_value,
             display_context=display_context,
-            input_id=self.bearer_token_value_input_id,
+            input_id=self.node_input_ids_by_name.get(APINode.bearer_token_value.name),
             pointer_type=WorkspaceSecretPointer,
         )
         api_key_header_key_node_input = (
@@ -94,7 +87,7 @@ class BaseAPINodeDisplay(BaseNodeVellumDisplay[_APINodeType], Generic[_APINodeTy
                 input_name="api_key_header_key",
                 value=api_key_header_key,
                 display_context=display_context,
-                input_id=self.api_key_header_key_input_id,
+                input_id=self.node_input_ids_by_name.get(APINode.api_key_header_key.name),
             )
             if api_key_header_key
             else None
@@ -104,7 +97,7 @@ class BaseAPINodeDisplay(BaseNodeVellumDisplay[_APINodeType], Generic[_APINodeTy
             input_name="api_key_header_value",
             value=api_key_header_value,
             display_context=display_context,
-            input_id=self.api_key_header_value_input_id,
+            input_id=self.node_input_ids_by_name.get(APINode.api_key_header_value.name),
             pointer_type=WorkspaceSecretPointer,
         )
 

{vellum_ai-0.14.20 → vellum_ai-0.14.21}/ee/vellum_ee/workflows/display/nodes/vellum/merge_node.py

@@ -6,7 +6,6 @@ from vellum.workflows.types.core import JsonObject
 from vellum.workflows.utils.uuids import uuid4_from_hash
 from vellum_ee.workflows.display.nodes.base_node_vellum_display import BaseNodeVellumDisplay
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
-from vellum_ee.workflows.display.vellum import EdgeVellumDisplay
 
 _MergeNodeType = TypeVar("_MergeNodeType", bound=MergeNode)
 
@@ -22,16 +21,20 @@ class BaseMergeNodeDisplay(BaseNodeVellumDisplay[_MergeNodeType], Generic[_Merge
         node = self._node
         node_id = self.node_id
 
-        all_edges: List[EdgeVellumDisplay] = [edge_display for _, edge_display in display_context.edge_displays.items()]
-        merged_edges = [edge for edge in all_edges if edge.target_node_id == self.node_id]
+        merged_source_ports = [
+            source_node_port
+            for (source_node_port, target_node), _ in display_context.edge_displays.items()
+            if target_node.__id__ == self.node_id
+        ]
 
         target_handle_ids = self.get_target_handle_ids()
 
         if target_handle_ids is None:
             target_handle_ids = [
-                uuid4_from_hash(f"{node_id}|target_handle|{edge.source_node_id}") for edge in merged_edges
+                uuid4_from_hash(f"{node_id}|target_handle|{source_node_port.node_class.__id__}")
+                for source_node_port in merged_source_ports
             ]
-        elif len(target_handle_ids) != len(merged_edges):
+        elif len(target_handle_ids) != len(merged_source_ports):
             raise ValueError("If you explicitly specify target_handle_ids, you must specify one for each incoming edge")
 
         return {

{vellum_ai-0.14.20 → vellum_ai-0.14.21}/ee/vellum_ee/workflows/display/types.py

@@ -7,6 +7,7 @@ from vellum.workflows.nodes import BaseNode
 from vellum.workflows.ports import Port
 from vellum.workflows.references import OutputReference, StateValueReference, WorkflowInputReference
 from vellum_ee.workflows.display.base import (
+    EdgeDisplay,
     EntrypointDisplayType,
     StateValueDisplayType,
     WorkflowInputsDisplayType,
@@ -17,7 +18,6 @@ from vellum_ee.workflows.display.base import (
 if TYPE_CHECKING:
     from vellum_ee.workflows.display.nodes.base_node_display import BaseNodeDisplay
     from vellum_ee.workflows.display.nodes.types import NodeOutputDisplay, PortDisplay
-    from vellum_ee.workflows.display.vellum import EdgeVellumDisplay
     from vellum_ee.workflows.display.workflows import BaseWorkflowDisplay
 
 WorkflowDisplayType = TypeVar("WorkflowDisplayType", bound="BaseWorkflowDisplay")
@@ -47,5 +47,5 @@ class WorkflowDisplayContext(
     )
     entrypoint_displays: Dict[Type[BaseNode], EntrypointDisplayType] = field(default_factory=dict)
     workflow_output_displays: Dict[BaseDescriptor, WorkflowOutputDisplay] = field(default_factory=dict)
-    edge_displays: Dict[Tuple[Port, Type[BaseNode]], "EdgeVellumDisplay"] = field(default_factory=dict)
+    edge_displays: Dict[Tuple[Port, Type[BaseNode]], EdgeDisplay] = field(default_factory=dict)
     port_displays: Dict[Port, "PortDisplay"] = field(default_factory=dict)

{vellum_ai-0.14.20 → vellum_ai-0.14.21}/ee/vellum_ee/workflows/display/vellum.py

@@ -121,7 +121,7 @@ class EntrypointVellumDisplayOverrides(EntrypointDisplay, EntrypointDisplayOverr
 
 @dataclass
 class EntrypointVellumDisplay(EntrypointVellumDisplayOverrides):
-    edge_display: EdgeVellumDisplay
+    edge_display: EdgeDisplay
 
 
 @dataclass

{vellum_ai-0.14.20 → vellum_ai-0.14.21}/ee/vellum_ee/workflows/display/workflows/base_workflow_display.py

@@ -12,7 +12,7 @@ from vellum.workflows.edges import Edge
 from vellum.workflows.events.workflow import NodeEventDisplayContext, WorkflowEventDisplayContext
 from vellum.workflows.expressions.coalesce_expression import CoalesceExpression
 from vellum.workflows.nodes.bases import BaseNode
-from vellum.workflows.nodes.utils import get_unadorned_node, get_unadorned_port, get_wrapped_node
+from vellum.workflows.nodes.utils import get_unadorned_node, get_wrapped_node
 from vellum.workflows.ports import Port
 from vellum.workflows.references import OutputReference, StateValueReference, WorkflowInputReference
 from vellum.workflows.types.core import JsonObject
@@ -36,7 +36,6 @@ from vellum_ee.workflows.display.nodes.get_node_display_class import get_node_di
 from vellum_ee.workflows.display.nodes.types import NodeOutputDisplay, PortDisplay, PortDisplayOverrides
 from vellum_ee.workflows.display.nodes.utils import raise_if_descriptor
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
-from vellum_ee.workflows.display.vellum import EdgeVellumDisplay
 from vellum_ee.workflows.display.workflows.get_vellum_workflow_display_class import get_workflow_display
 
 logger = logging.getLogger(__name__)
@@ -267,14 +266,14 @@ class BaseWorkflowDisplay(
                 entrypoint, workflow_display, node_displays, overrides=entrypoint_display_overrides
             )
 
-        edge_displays: Dict[Tuple[Port, Type[BaseNode]], EdgeVellumDisplay] = {}
+        edge_displays: Dict[Tuple[Port, Type[BaseNode]], EdgeDisplay] = {}
         for edge in self._workflow.get_edges():
             if edge in edge_displays:
                 continue
 
             edge_display_overrides = self.edge_displays.get((edge.from_port, edge.to_node))
             edge_displays[(edge.from_port, edge.to_node)] = self._generate_edge_display(
-                edge, node_displays, port_displays, overrides=edge_display_overrides
+                edge, node_displays, overrides=edge_display_overrides
             )
 
         for edge in self._workflow.get_unused_edges():
@@ -283,7 +282,7 @@ class BaseWorkflowDisplay(
 
             edge_display_overrides = self.edge_displays.get((edge.from_port, edge.to_node))
             edge_displays[(edge.from_port, edge.to_node)] = self._generate_edge_display(
-                edge, node_displays, port_displays, overrides=edge_display_overrides
+                edge, node_displays, overrides=edge_display_overrides
             )
 
         workflow_output_displays: Dict[BaseDescriptor, WorkflowOutputDisplay] = {}
@@ -448,42 +447,26 @@ class BaseWorkflowDisplay(
         self,
         edge: Edge,
         node_displays: Dict[Type[BaseNode], BaseNodeDisplay],
-        port_displays: Dict[Port, PortDisplay],
         overrides: Optional[EdgeDisplay] = None,
-    ) -> EdgeVellumDisplay:
+    ) -> EdgeDisplay:
         source_node = get_unadorned_node(edge.from_port.node_class)
         target_node = get_unadorned_node(edge.to_node)
 
         source_node_id = node_displays[source_node].node_id
-        from_port = get_unadorned_port(edge.from_port)
-        source_handle_id = port_displays[from_port].id
-
-        target_node_display = node_displays[target_node]
-        target_node_id = target_node_display.node_id
-        target_handle_id = target_node_display.get_target_handle_id_by_source_node_id(source_node_id)
+        target_node_id = node_displays[target_node].node_id
 
-        return self._generate_edge_display_from_source(
-            source_node_id, source_handle_id, target_node_id, target_handle_id, overrides
-        )
+        return self._generate_edge_display_from_source(source_node_id, target_node_id, overrides)
 
     def _generate_edge_display_from_source(
         self,
         source_node_id: UUID,
-        source_handle_id: UUID,
         target_node_id: UUID,
-        target_handle_id: UUID,
         overrides: Optional[EdgeDisplay] = None,
-    ) -> EdgeVellumDisplay:
+    ) -> EdgeDisplay:
         edge_id: UUID
         if overrides:
             edge_id = overrides.id
         else:
             edge_id = uuid4_from_hash(f"{self.workflow_id}|id|{source_node_id}|{target_node_id}")
 
-        return EdgeVellumDisplay(
-            id=edge_id,
-            source_node_id=source_node_id,
-            target_node_id=target_node_id,
-            source_handle_id=source_handle_id,
-            target_handle_id=target_handle_id,
-        )
+        return EdgeDisplay(id=edge_id)

{vellum_ai-0.14.20 → vellum_ai-0.14.21}/ee/vellum_ee/workflows/display/workflows/vellum_workflow_display.py

@@ -351,7 +351,6 @@ class VellumWorkflowDisplay(
         overrides: Optional[EntrypointVellumDisplayOverrides] = None,
     ) -> EntrypointVellumDisplay:
         entrypoint_node_id = workflow_display.entrypoint_node_id
-        source_handle_id = workflow_display.entrypoint_node_source_handle_id
 
         edge_display_overrides = overrides.edge_display if overrides else None
         entrypoint_id = (
@@ -363,10 +362,9 @@ class VellumWorkflowDisplay(
         entrypoint_target = get_unadorned_node(entrypoint)
         target_node_display = node_displays[entrypoint_target]
         target_node_id = target_node_display.node_id
-        target_handle_id = target_node_display.get_target_handle_id_by_source_node_id(entrypoint_node_id)
 
         edge_display = self._generate_edge_display_from_source(
-            entrypoint_node_id, source_handle_id, target_node_id, target_handle_id, overrides=edge_display_overrides
+            entrypoint_node_id, target_node_id, overrides=edge_display_overrides
         )
 
         return EntrypointVellumDisplay(id=entrypoint_id, edge_display=edge_display)

{vellum_ai-0.14.20 → vellum_ai-0.14.21}/ee/vellum_ee/workflows/tests/local_workflow/display/workflow.py

@@ -1,7 +1,7 @@
 from uuid import UUID
 
+from vellum_ee.workflows.display.base import EdgeDisplay
 from vellum_ee.workflows.display.vellum import (
-    EdgeVellumDisplayOverrides,
     EntrypointVellumDisplayOverrides,
     NodeDisplayData,
     NodeDisplayPosition,
@@ -36,13 +36,11 @@ class WorkflowDisplay(VellumWorkflowDisplay[Workflow]):
     entrypoint_displays = {
         TemplatingNode: EntrypointVellumDisplayOverrides(
             id=UUID("0bf86989-13f2-438c-ab9c-d172e5771d31"),
-            edge_display=EdgeVellumDisplayOverrides(id=UUID("38532a0e-9432-4ed2-8a34-48a29fd6984d")),
+            edge_display=EdgeDisplay(id=UUID("38532a0e-9432-4ed2-8a34-48a29fd6984d")),
         )
     }
     edge_displays = {
-        (TemplatingNode.Ports.default, FinalOutput): EdgeVellumDisplayOverrides(
-            id=UUID("417c56a4-cdc1-4f9d-a10c-b535163f51e8")
-        )
+        (TemplatingNode.Ports.default, FinalOutput): EdgeDisplay(id=UUID("417c56a4-cdc1-4f9d-a10c-b535163f51e8"))
     }
     output_displays = {
         Workflow.Outputs.final_output: WorkflowOutputVellumDisplayOverrides(

{vellum_ai-0.14.20 → vellum_ai-0.14.21}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "vellum-ai"
-version = "0.14.20"
+version = "0.14.21"
 description = ""
 readme = "README.md"
 authors = []

{vellum_ai-0.14.20 → vellum_ai-0.14.21}/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.20",
+            "X-Fern-SDK-Version": "0.14.21",
         }
         headers["X_API_KEY"] = self.api_key
         return headers

{vellum_ai-0.14.20 → vellum_ai-0.14.21}/src/vellum/workflows/nodes/displayable/api_node/node.py

@@ -50,7 +50,7 @@ class APINode(BaseAPINode):
         return self._run(
             method=self.method,
             url=self.url,
-            data=self.data or self.json,
+            data=self.data,
             json=self.json,
             headers={**headers, **header_overrides},
             bearer_token=bearer_token,

{vellum_ai-0.14.20 → vellum_ai-0.14.21}/src/vellum/workflows/nodes/displayable/bases/api_node/node.py

@@ -28,7 +28,7 @@ class BaseAPINode(BaseNode, Generic[StateType]):
     class Trigger(BaseNode.Trigger):
         merge_behavior = MergeBehavior.AWAIT_ANY
 
-    url: str
+    url: str = ""
     method: Optional[APIRequestMethod] = APIRequestMethod.GET
     data: Optional[str] = None
     json: Optional[Json] = None
@@ -63,7 +63,12 @@ class BaseAPINode(BaseNode, Generic[StateType]):
 
     def _local_execute_api(self, data, headers, json, method, url):
         try:
-            prepped = Request(method=method.value, url=url, data=data, json=json, headers=headers).prepare()
+            if data is not None:
+                prepped = Request(method=method.value, url=url, data=data, headers=headers).prepare()
+            elif json is not None:
+                prepped = Request(method=method.value, url=url, json=json, headers=headers).prepare()
+            else:
+                prepped = Request(method=method.value, url=url, headers=headers).prepare()
         except Exception as e:
             raise NodeException(f"Failed to prepare HTTP request: {e}", code=WorkflowErrorCode.PROVIDER_ERROR)
         try:

{vellum_ai-0.14.20 → vellum_ai-0.14.21}/src/vellum/workflows/nodes/tests/test_utils.py

@@ -1,11 +1,14 @@
 import pytest
-from typing import List, Union
+from typing import Any, List, Union
 
 from pydantic import BaseModel
 
+from vellum.client.types.chat_message import ChatMessage
+from vellum.client.types.function_call import FunctionCall as FunctionCallType
+from vellum.client.types.vellum_value import VellumValue
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
-from vellum.workflows.nodes.utils import parse_type_from_str
+from vellum.workflows.nodes.utils import cast_to_output_type, parse_type_from_str
 from vellum.workflows.types.core import Json
 
 
@@ -131,3 +134,32 @@ def test_parse_type_from_str_error_cases(input_str, output_type, expected_except
         assert excinfo.value.code == expected_code
 
     assert expected_message in str(excinfo.value)
+
+
+@pytest.mark.parametrize(
+    "output_type,expected_result",
+    [
+        (str, ""),  # String
+        (int, 0),  # Number
+        (float, 0.0),  # Number
+        (Any, None),  # Json
+        (FunctionCallType, {}),  # FunctionCall
+        (List[ChatMessage], []),  # Chat History
+        (List[VellumValue], []),  # Array
+        (Union[float, int], 0.0),  # Union
+    ],
+    ids=[
+        "string",
+        "integer",
+        "float",
+        "json",
+        "function_call",
+        "chat_history",
+        "array",
+        "union",
+    ],
+)
+def test_cast_to_output_type_none_value(output_type, expected_result):
+    """Test that cast_to_output_type returns appropriate default values when None is provided."""
+    result = cast_to_output_type(None, output_type)
+    assert result == expected_result

{vellum_ai-0.14.20 → vellum_ai-0.14.21}/src/vellum/workflows/nodes/utils.py

@@ -6,6 +6,7 @@ from typing import Any, Callable, Dict, ForwardRef, List, Optional, Type, TypeVa
 
 from pydantic import BaseModel, create_model
 
+from vellum.client.types.function_call import FunctionCall
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
 from vellum.workflows.nodes import BaseNode
@@ -195,7 +196,32 @@ def _clean_output_type(output_type: Any) -> Any:
     return output_type
 
 
+def _get_default_value(output_type: Any) -> Any:
+    origin = get_origin(output_type)
+    args = get_args(output_type)
+
+    if output_type is int or output_type is float:
+        return 0.0
+    elif output_type is str:
+        return ""
+    elif origin is list:
+        return []
+    elif output_type is FunctionCall:
+        return {}
+    elif origin is Union:
+        # Always use the first argument type's default value
+        if args:
+            return _get_default_value(args[0])
+        return None
+    else:
+        # We defined Json as Any now which is why it returns None
+        return None
+
+
 def cast_to_output_type(result: Any, output_type: Any) -> Any:
+    if result is None:
+        return _get_default_value(output_type)
+
     clean_output_type = _clean_output_type(output_type)
     DynamicModel = create_model("Output", output_type=(clean_output_type, ...))