vellum-ai 0.12.17__tar.gz → 0.13.1__tar.gz

{vellum_ai-0.12.17 → vellum_ai-0.13.1}/PKG-INFO

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

{vellum_ai-0.12.17 → vellum_ai-0.13.1}/ee/vellum_cli/__init__.py

@@ -4,6 +4,7 @@ import click
 
 from vellum_cli.aliased_group import ClickAliasedGroup
 from vellum_cli.image_push import image_push_command
+from vellum_cli.ping import ping_command
 from vellum_cli.pull import pull_command
 from vellum_cli.push import push_command
 
@@ -14,6 +15,15 @@ def main() -> None:
     pass
 
 
+@main.command
+def ping() -> None:
+    """
+    Ping Vellum to confirm that requests are correctly authenticated and to return information about the active
+    Workspace/Organization
+    """
+    ping_command()
+
+
 class PushGroup(ClickAliasedGroup):
     def get_command(self, ctx, cmd_name):
         # First try to get the command normally

vellum_ai-0.13.1/ee/vellum_cli/ping.py

@@ -0,0 +1,28 @@
+from dotenv import load_dotenv
+
+from vellum.workflows.vellum_client import create_vellum_client
+from vellum_cli.logger import load_cli_logger
+
+
+def ping_command():
+    load_dotenv()
+    logger = load_cli_logger()
+
+    client = create_vellum_client()
+
+    workspace = client.workspaces.workspace_identity()
+    organization = client.organizations.organization_identity()
+
+    logger.info(
+        f"""\
+Successfully authenticated with Vellum!
+
+Organization:
+    ID: {organization.id}
+    Name: {organization.name}
+
+Workspace:
+    ID: {workspace.id}
+    Name: {workspace.name}
+"""
+    )

vellum_ai-0.13.1/ee/vellum_cli/tests/test_ping.py

@@ -0,0 +1,47 @@
+from datetime import datetime
+
+from click.testing import CliRunner
+
+from vellum.client.types.organization_read import OrganizationRead
+from vellum.client.types.workspace_read import WorkspaceRead
+from vellum_cli import main as cli_main
+
+
+def test_ping__happy_path(vellum_client):
+    # GIVEN a cli
+    runner = CliRunner()
+
+    # AND a valid response from both the workflow and organization API calls
+    vellum_client.workspaces.workspace_identity.return_value = WorkspaceRead(
+        id="1234567890",
+        name="Test Workspace",
+        label="Test Workspace",
+        created=datetime.now(),
+    )
+    vellum_client.organizations.organization_identity.return_value = OrganizationRead(
+        id="1234567890",
+        name="Test Organization",
+        new_member_join_behavior="AUTO_ACCEPT_FROM_SHARED_DOMAIN",
+        allow_staff_access=True,
+    )
+
+    # WHEN calling `vellum ping`
+    result = runner.invoke(cli_main, ["ping"])
+
+    # THEN it should return Status information about the user's workspace
+    assert result.exit_code == 0
+    assert (
+        result.output
+        == """\x1b[38;20m\
+Successfully authenticated with Vellum!
+
+Organization:
+    ID: 1234567890
+    Name: Test Organization
+
+Workspace:
+    ID: 1234567890
+    Name: Test Workspace
+\x1b[0m
+"""
+    )

{vellum_ai-0.12.17 → vellum_ai-0.13.1}/ee/vellum_ee/workflows/display/nodes/base_node_display.py

@@ -25,7 +25,7 @@ from vellum.workflows.types.utils import get_original_base
 from vellum.workflows.utils.names import pascal_to_title_case
 from vellum.workflows.utils.uuids import uuid4_from_hash
 from vellum_ee.workflows.display.nodes.types import NodeOutputDisplay, PortDisplay, PortDisplayOverrides
-from vellum_ee.workflows.display.vellum import CodeResourceDefinition, NodeDefinition
+from vellum_ee.workflows.display.vellum import CodeResourceDefinition
 
 if TYPE_CHECKING:
     from vellum_ee.workflows.display.types import WorkflowDisplayContext
@@ -54,18 +54,25 @@ class BaseNodeDisplay(Generic[NodeType], metaclass=BaseNodeDisplayMeta):
     def serialize(self, display_context: "WorkflowDisplayContext", **kwargs: Any) -> JsonObject:
         raise NotImplementedError(f"Serialization for nodes of type {self._node.__name__} is not supported.")
 
-    def get_definition(self) -> NodeDefinition:
+    def get_base(self) -> CodeResourceDefinition:
         node = self._node
-        node_definition = NodeDefinition(
+
+        base_node_classes = [base for base in node.__bases__ if issubclass(base, BaseNode)]
+        if len(base_node_classes) != 1:
+            raise ValueError(f"Node {node.__name__} must extend from exactly one parent node class.")
+
+        base_node_class = base_node_classes[0]
+
+        return CodeResourceDefinition(
+            name=base_node_class.__name__,
+            module=base_node_class.__module__.split("."),
+        )
+
+    def get_definition(self) -> CodeResourceDefinition:
+        node = self._node
+        node_definition = CodeResourceDefinition(
             name=node.__name__,
             module=node.__module__.split("."),
-            bases=[
-                CodeResourceDefinition(
-                    name=base.__name__,
-                    module=base.__module__.split("."),
-                )
-                for base in node.__bases__
-            ],
         )
         return node_definition
 

{vellum_ai-0.12.17 → vellum_ai-0.13.1}/ee/vellum_ee/workflows/display/nodes/vellum/api_node.py

@@ -197,5 +197,6 @@ class BaseAPINodeDisplay(BaseNodeVellumDisplay[_APINodeType], Generic[_APINodeTy
                 "status_code_output_id": str(status_code_output_display.id),
             },
             "display_data": self.get_display_data().dict(),
+            "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
         }

vellum_ai-0.13.1/ee/vellum_ee/workflows/display/nodes/vellum/base_node.py

@@ -0,0 +1,143 @@
+from typing import Any, Generic, TypeVar
+
+from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.expressions.between import BetweenExpression
+from vellum.workflows.expressions.is_not_null import IsNotNullExpression
+from vellum.workflows.expressions.is_null import IsNullExpression
+from vellum.workflows.expressions.not_between import NotBetweenExpression
+from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.references.execution_count import ExecutionCountReference
+from vellum.workflows.references.output import OutputReference
+from vellum.workflows.references.vellum_secret import VellumSecretReference
+from vellum.workflows.references.workflow_input import WorkflowInputReference
+from vellum.workflows.types.core import JsonArray, 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.nodes.vellum.utils import convert_descriptor_to_operator
+from vellum_ee.workflows.display.types import WorkflowDisplayContext
+from vellum_ee.workflows.display.utils.vellum import primitive_to_vellum_value
+from vellum_ee.workflows.display.vellum import GenericNodeDisplayData
+
+_BaseNodeType = TypeVar("_BaseNodeType", bound=BaseNode)
+
+
+class BaseNodeDisplay(BaseNodeVellumDisplay[_BaseNodeType], Generic[_BaseNodeType]):
+    def serialize(self, display_context: WorkflowDisplayContext, **kwargs: Any) -> JsonObject:
+        node = self._node
+        node_id = self.node_id
+
+        ports: JsonArray = []
+        for idx, port in enumerate(node.Ports):
+            id = str(uuid4_from_hash(f"{node_id}|{idx}"))
+
+            if port._condition_type:
+                ports.append(
+                    {
+                        "id": id,
+                        "type": port._condition_type.value,
+                        "expression": (
+                            self.serialize_condition(display_context, port._condition) if port._condition else None
+                        ),
+                    }
+                )
+            else:
+                ports.append(
+                    {
+                        "id": id,
+                        "type": "DEFAULT",
+                    }
+                )
+
+        return {
+            "id": str(node_id),
+            "label": node.__qualname__,
+            "type": "GENERIC",
+            "display_data": self.get_generic_node_display_data().dict(),
+            "base": self.get_base().dict(),
+            "definition": self.get_definition().dict(),
+            "trigger": {
+                "id": str(uuid4_from_hash(f"{node_id}|trigger")),
+                "merge_behavior": node.Trigger.merge_behavior.value,
+            },
+            "ports": ports,
+            "adornments": None,
+            "attributes": [],
+        }
+
+    def get_generic_node_display_data(self) -> GenericNodeDisplayData:
+        explicit_value = self._get_explicit_node_display_attr("display_data", GenericNodeDisplayData)
+        return explicit_value if explicit_value else GenericNodeDisplayData()
+
+    def serialize_condition(self, display_context: WorkflowDisplayContext, condition: BaseDescriptor) -> JsonObject:
+        if isinstance(condition, (IsNullExpression, IsNotNullExpression)):
+            lhs = self.serialize_value(display_context, condition._expression)  # type: ignore[attr-defined]
+            return {
+                "type": "UNARY_EXPRESSION",
+                "lhs": lhs,
+                "operator": convert_descriptor_to_operator(condition),
+            }
+        elif isinstance(condition, (BetweenExpression, NotBetweenExpression)):
+            base = self.serialize_value(display_context, condition._value)  # type: ignore[attr-defined]
+            lhs = self.serialize_value(display_context, condition._start)  # type: ignore[attr-defined]
+            rhs = self.serialize_value(display_context, condition._end)  # type: ignore[attr-defined]
+
+            return {
+                "type": "TERNARY_EXPRESSION",
+                "base": base,
+                "operator": convert_descriptor_to_operator(condition),
+                "lhs": lhs,
+                "rhs": rhs,
+            }
+        else:
+            lhs = self.serialize_value(display_context, condition._lhs)  # type: ignore[attr-defined]
+            rhs = self.serialize_value(display_context, condition._rhs)  # type: ignore[attr-defined]
+
+            return {
+                "type": "BINARY_EXPRESSION",
+                "lhs": lhs,
+                "operator": convert_descriptor_to_operator(condition),
+                "rhs": rhs,
+            }
+
+    def serialize_value(self, display_context: WorkflowDisplayContext, value: BaseDescriptor) -> JsonObject:
+        if isinstance(value, WorkflowInputReference):
+            workflow_input_display = display_context.global_workflow_input_displays[value]
+            return {
+                "type": "WORKFLOW_INPUT",
+                "input_variable_id": str(workflow_input_display.id),
+            }
+
+        if isinstance(value, OutputReference):
+            upstream_node, output_display = display_context.global_node_output_displays[value]
+            upstream_node_display = display_context.global_node_displays[upstream_node]
+
+            return {
+                "type": "NODE_OUTPUT",
+                "node_id": str(upstream_node_display.node_id),
+                "node_output_id": str(output_display.id),
+            }
+
+        if isinstance(value, VellumSecretReference):
+            return {
+                "type": "VELLUM_SECRET",
+                "vellum_secret_name": value.name,
+            }
+
+        if isinstance(value, ExecutionCountReference):
+            node_class_display = display_context.global_node_displays[value.node_class]
+
+            return {
+                "type": "EXECUTION_COUNTER",
+                "node_id": str(node_class_display.node_id),
+            }
+
+        if not isinstance(value, BaseDescriptor):
+            vellum_value = primitive_to_vellum_value(value)
+            return {
+                "type": "CONSTANT_VALUE",
+                "value": vellum_value.dict(),
+            }
+
+        # If it's not any of the references we know about,
+        # then try to serialize it as a nested value
+        return self.serialize_condition(display_context, value)

{vellum_ai-0.12.17 → vellum_ai-0.13.1}/ee/vellum_ee/workflows/display/nodes/vellum/code_execution_node.py

@@ -92,5 +92,6 @@ class BaseCodeExecutionNodeDisplay(BaseNodeVellumDisplay[_CodeExecutionNodeType]
                 "log_output_id": str(self.log_output_id) if self.log_output_id else str(log_output_display.id),
             },
             "display_data": self.get_display_data().dict(),
+            "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
         }

{vellum_ai-0.12.17 → vellum_ai-0.13.1}/ee/vellum_ee/workflows/display/nodes/vellum/conditional_node.py

@@ -4,34 +4,16 @@ from typing import Any, ClassVar, Dict, Generic, List, Optional, Tuple, TypeVar,
 
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.expressions.and_ import AndExpression
-from vellum.workflows.expressions.begins_with import BeginsWithExpression
 from vellum.workflows.expressions.between import BetweenExpression
-from vellum.workflows.expressions.contains import ContainsExpression
-from vellum.workflows.expressions.does_not_begin_with import DoesNotBeginWithExpression
-from vellum.workflows.expressions.does_not_contain import DoesNotContainExpression
-from vellum.workflows.expressions.does_not_end_with import DoesNotEndWithExpression
-from vellum.workflows.expressions.does_not_equal import DoesNotEqualExpression
-from vellum.workflows.expressions.ends_with import EndsWithExpression
-from vellum.workflows.expressions.equals import EqualsExpression
-from vellum.workflows.expressions.greater_than import GreaterThanExpression
-from vellum.workflows.expressions.greater_than_or_equal_to import GreaterThanOrEqualToExpression
-from vellum.workflows.expressions.in_ import InExpression
-from vellum.workflows.expressions.is_nil import IsNilExpression
-from vellum.workflows.expressions.is_not_nil import IsNotNilExpression
 from vellum.workflows.expressions.is_not_null import IsNotNullExpression
-from vellum.workflows.expressions.is_not_undefined import IsNotUndefinedExpression
 from vellum.workflows.expressions.is_null import IsNullExpression
-from vellum.workflows.expressions.is_undefined import IsUndefinedExpression
-from vellum.workflows.expressions.less_than import LessThanExpression
-from vellum.workflows.expressions.less_than_or_equal_to import LessThanOrEqualToExpression
 from vellum.workflows.expressions.not_between import NotBetweenExpression
-from vellum.workflows.expressions.not_in import NotInExpression
 from vellum.workflows.expressions.or_ import OrExpression
 from vellum.workflows.nodes.displayable import ConditionalNode
 from vellum.workflows.types.core import ConditionType, 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.nodes.vellum.utils import create_node_input
+from vellum_ee.workflows.display.nodes.vellum.utils import convert_descriptor_to_operator, create_node_input
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
 from vellum_ee.workflows.display.vellum import NodeInput
 
@@ -113,7 +95,7 @@ but the defined conditions have length {len(condition_ids)}"""
                 )
                 node_inputs.append(expression_node_input)
                 field_node_input_id = expression_node_input.id
-                operator = self._convert_descriptor_to_operator(descriptor)
+                operator = convert_descriptor_to_operator(descriptor)
 
             elif isinstance(descriptor, (BetweenExpression, NotBetweenExpression)):
                 field_node_input = create_node_input(
@@ -127,7 +109,7 @@ but the defined conditions have length {len(condition_ids)}"""
                     value_node_input_id,
                 )
                 node_inputs.extend([field_node_input, value_node_input])
-                operator = self._convert_descriptor_to_operator(descriptor)
+                operator = convert_descriptor_to_operator(descriptor)
                 field_node_input_id = field_node_input.id
                 value_node_input_id = value_node_input.id
 
@@ -147,7 +129,7 @@ but the defined conditions have length {len(condition_ids)}"""
                     node_inputs.append(rhs_node_input)
                     value_node_input_id = rhs_node_input.id
 
-                operator = self._convert_descriptor_to_operator(descriptor)
+                operator = convert_descriptor_to_operator(descriptor)
                 field_node_input_id = lhs_node_input.id
 
             return {
@@ -218,49 +200,10 @@ but the defined conditions have length {len(condition_ids)}"""
                 "version": "2",
             },
             "display_data": self.get_display_data().dict(),
+            "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
         }
 
-    def _convert_descriptor_to_operator(self, descriptor: BaseDescriptor) -> str:
-        if isinstance(descriptor, EqualsExpression):
-            return "="
-        elif isinstance(descriptor, DoesNotEqualExpression):
-            return "!="
-        elif isinstance(descriptor, LessThanExpression):
-            return "<"
-        elif isinstance(descriptor, GreaterThanExpression):
-            return ">"
-        elif isinstance(descriptor, LessThanOrEqualToExpression):
-            return "<="
-        elif isinstance(descriptor, GreaterThanOrEqualToExpression):
-            return ">="
-        elif isinstance(descriptor, ContainsExpression):
-            return "contains"
-        elif isinstance(descriptor, BeginsWithExpression):
-            return "beginsWith"
-        elif isinstance(descriptor, EndsWithExpression):
-            return "endsWith"
-        elif isinstance(descriptor, DoesNotContainExpression):
-            return "doesNotContain"
-        elif isinstance(descriptor, DoesNotBeginWithExpression):
-            return "doesNotBeginWith"
-        elif isinstance(descriptor, DoesNotEndWithExpression):
-            return "doesNotEndWith"
-        elif isinstance(descriptor, (IsNullExpression, IsNilExpression, IsUndefinedExpression)):
-            return "null"
-        elif isinstance(descriptor, (IsNotNullExpression, IsNotNilExpression, IsNotUndefinedExpression)):
-            return "notNull"
-        elif isinstance(descriptor, InExpression):
-            return "in"
-        elif isinstance(descriptor, NotInExpression):
-            return "notIn"
-        elif isinstance(descriptor, BetweenExpression):
-            return "between"
-        elif isinstance(descriptor, NotBetweenExpression):
-            return "notBetween"
-        else:
-            raise ValueError(f"Unsupported descriptor type: {descriptor}")
-
     def get_nested_rule_details_by_path(
         self, rule_ids: List[RuleIdMap], path: List[int]
     ) -> Union[Tuple[str, Optional[str], Optional[str]], None]:

{vellum_ai-0.12.17 → vellum_ai-0.13.1}/ee/vellum_ee/workflows/display/nodes/vellum/error_node.py

@@ -44,5 +44,6 @@ class BaseErrorNodeDisplay(BaseNodeVellumDisplay[_ErrorNodeType], Generic[_Error
                 "error_output_id": str(self.error_output_id),
             },
             "display_data": self.get_display_data().dict(),
+            "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
         }

{vellum_ai-0.12.17 → vellum_ai-0.13.1}/ee/vellum_ee/workflows/display/nodes/vellum/final_output_node.py

@@ -45,6 +45,7 @@ class BaseFinalOutputNodeDisplay(BaseNodeVellumDisplay[_FinalOutputNodeType], Ge
             },
             "inputs": [node_input.dict()],
             "display_data": self.get_display_data().dict(),
+            "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
         }
 

{vellum_ai-0.12.17 → vellum_ai-0.13.1}/ee/vellum_ee/workflows/display/nodes/vellum/guardrail_node.py

@@ -45,5 +45,6 @@ class BaseGuardrailNodeDisplay(BaseNodeVellumDisplay[_GuardrailNodeType], Generi
                 "release_tag": raise_if_descriptor(node.release_tag),
             },
             "display_data": self.get_display_data().dict(),
+            "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
         }

{vellum_ai-0.12.17 → vellum_ai-0.13.1}/ee/vellum_ee/workflows/display/nodes/vellum/inline_prompt_node.py

@@ -59,6 +59,7 @@ class BaseInlinePromptNodeDisplay(BaseNodeVellumDisplay[_InlinePromptNodeType],
                 "ml_model_name": raise_if_descriptor(node.ml_model),
             },
             "display_data": self.get_display_data().dict(),
+            "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
         }
 
@@ -73,6 +74,9 @@ class BaseInlinePromptNodeDisplay(BaseNodeVellumDisplay[_InlinePromptNodeType],
         node_inputs: List[NodeInput] = []
         prompt_inputs: List[VellumVariable] = []
 
+        if not value:
+            return node_inputs, prompt_inputs
+
         for variable_name, variable_value in value.items():
             node_input = create_node_input(
                 node_id=node_id,

{vellum_ai-0.12.17 → vellum_ai-0.13.1}/ee/vellum_ee/workflows/display/nodes/vellum/inline_subworkflow_node.py

@@ -52,6 +52,7 @@ class BaseInlineSubworkflowNodeDisplay(
                 "output_variables": [workflow_output.dict() for workflow_output in workflow_outputs],
             },
             "display_data": self.get_display_data().dict(),
+            "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
         }
 

{vellum_ai-0.12.17 → vellum_ai-0.13.1}/ee/vellum_ee/workflows/display/nodes/vellum/map_node.py

@@ -69,11 +69,12 @@ class BaseMapNodeDisplay(BaseNodeVellumDisplay[_MapNodeType], Generic[_MapNodeTy
                 "workflow_raw_data": serialized_subworkflow["workflow_raw_data"],
                 "input_variables": cast(JsonObject, renamed_input_variables),
                 "output_variables": serialized_subworkflow["output_variables"],
-                "concurrency": raise_if_descriptor(node.concurrency),
+                "concurrency": raise_if_descriptor(node.max_concurrency),
                 "items_input_id": items_workflow_input_id,
                 "item_input_id": item_workflow_input_id,
                 "index_input_id": index_workflow_input_id,
             },
             "display_data": self.get_display_data().dict(),
+            "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
         }

{vellum_ai-0.12.17 → vellum_ai-0.13.1}/ee/vellum_ee/workflows/display/nodes/vellum/merge_node.py

@@ -45,6 +45,7 @@ class BaseMergeNodeDisplay(BaseNodeVellumDisplay[_MergeNodeType], Generic[_Merge
                 "source_handle_id": str(self.get_source_handle_id(display_context.port_displays)),
             },
             "display_data": self.get_display_data().dict(),
+            "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
         }
 

{vellum_ai-0.12.17 → vellum_ai-0.13.1}/ee/vellum_ee/workflows/display/nodes/vellum/note_node.py

@@ -26,5 +26,6 @@ class BaseNoteNodeDisplay(BaseNodeVellumDisplay[_NoteNodeType], Generic[_NoteNod
                 "style": json.dumps(self.style) if self.style else None,
             },
             "display_data": self.get_display_data().dict(),
+            "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
         }

{vellum_ai-0.12.17 → vellum_ai-0.13.1}/ee/vellum_ee/workflows/display/nodes/vellum/prompt_deployment_node.py

@@ -27,16 +27,20 @@ class BasePromptDeploymentNodeDisplay(
         node_id = self.node_id
 
         prompt_inputs = raise_if_descriptor(node.prompt_inputs)
-        node_inputs = [
-            create_node_input(
-                node_id=node_id,
-                input_name=variable_name,
-                value=variable_value,
-                display_context=display_context,
-                input_id=self.prompt_input_ids_by_name.get(variable_name),
-            )
-            for variable_name, variable_value in prompt_inputs.items()
-        ]
+        node_inputs = (
+            [
+                create_node_input(
+                    node_id=node_id,
+                    input_name=variable_name,
+                    value=variable_value,
+                    display_context=display_context,
+                    input_id=self.prompt_input_ids_by_name.get(variable_name),
+                )
+                for variable_name, variable_value in prompt_inputs.items()
+            ]
+            if prompt_inputs
+            else []
+        )
 
         _, output_display = display_context.global_node_output_displays[cast(OutputReference, node.Outputs.text)]
         _, array_display = display_context.global_node_output_displays[cast(OutputReference, node.Outputs.results)]
@@ -64,5 +68,6 @@ class BasePromptDeploymentNodeDisplay(
                 "release_tag": raise_if_descriptor(node.release_tag),
             },
             "display_data": self.get_display_data().dict(),
+            "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
         }

{vellum_ai-0.12.17 → vellum_ai-0.13.1}/ee/vellum_ee/workflows/display/nodes/vellum/search_node.py

@@ -65,6 +65,7 @@ class BaseSearchNodeDisplay(BaseNodeVellumDisplay[_SearchNodeType], Generic[_Sea
                 "metadata_filters_node_input_id": str(node_inputs["metadata_filters"].id),
             },
             "display_data": self.get_display_data().dict(),
+            "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
         }
 

{vellum_ai-0.12.17 → vellum_ai-0.13.1}/ee/vellum_ee/workflows/display/nodes/vellum/subworkflow_deployment_node.py

@@ -56,5 +56,6 @@ class BaseSubworkflowDeploymentNodeDisplay(
                 "release_tag": raise_if_descriptor(node.release_tag),
             },
             "display_data": self.get_display_data().dict(),
+            "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
         }

{vellum_ai-0.12.17 → vellum_ai-0.13.1}/ee/vellum_ee/workflows/display/nodes/vellum/templating_node.py

@@ -73,5 +73,6 @@ class BaseTemplatingNodeDisplay(BaseNodeVellumDisplay[_TemplatingNodeType], Gene
                 "output_type": inferred_output_type,
             },
             "display_data": self.get_display_data().dict(),
+            "base": self.get_base().dict(),
             "definition": self.get_definition().dict(),
         }

{vellum_ai-0.12.17 → vellum_ai-0.13.1}/ee/vellum_ee/workflows/display/nodes/vellum/tests/test_utils.py

@@ -2,6 +2,7 @@ import pytest
 from uuid import UUID, uuid4
 from typing import List, cast
 
+from vellum.client.types.string_vellum_value import StringVellumValue
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.inputs import BaseInputs
 from vellum.workflows.nodes.bases import BaseNode
@@ -19,7 +20,6 @@ from vellum_ee.workflows.display.vellum import (
     NodeInputValuePointerRule,
     NodeOutputData,
     NodeOutputPointer,
-    StringVellumValue,
     WorkflowInputsVellumDisplayOverrides,
     WorkflowMetaVellumDisplay,
 )
@@ -74,7 +74,7 @@ class MyNodeB(BaseNode):
                     type="INPUT_VARIABLE",
                     data=InputVariableData(input_variable_id="a154c29d-fac0-4cd0-ba88-bc52034f5470"),
                 ),
-                ConstantValuePointer(type="CONSTANT_VALUE", data=StringVellumValue(type="STRING", value="fallback")),
+                ConstantValuePointer(type="CONSTANT_VALUE", data=StringVellumValue(value="fallback")),
             ],
         ),
     ],