vellum-ai 0.12.3__py3-none-any.whl → 0.12.5__py3-none-any.whl

vellum_ee/workflows/display/nodes/vellum/search_node.py

@@ -28,7 +28,9 @@ class VariableIdMap:
 
 
 class BaseSearchNodeDisplay(BaseNodeVellumDisplay[_SearchNodeType], Generic[_SearchNodeType]):
-    input_variable_ids_by_logical_id: Optional[Dict[str, str]] = None
+    # A mapping between the id of the operand (e.g. "lhs_variable_id" or "rhs_variable_id") and the id of the node input
+    # that the operand is pointing to.
+    metadata_filter_input_id_by_operand_id: Dict[UUID, UUID] = {}
 
     def serialize(
         self, display_context: WorkflowDisplayContext, error_output_id: Optional[UUID] = None, **kwargs
@@ -149,18 +151,20 @@ class BaseSearchNodeDisplay(BaseNodeVellumDisplay[_SearchNodeType], Generic[_Sea
                 variables,
             )
         elif isinstance(logical_expression, VellumValueLogicalConditionRequest):
-            lhs_variable_id = str(logical_expression.lhs_variable.value)
-            rhs_variable_id = str(logical_expression.rhs_variable.value)
-            lhs_query_input_id = (
-                self.input_variable_ids_by_logical_id[lhs_variable_id]
-                if self.input_variable_ids_by_logical_id
-                else str(uuid4_from_hash(f"{self.node_id}|{hash(tuple(path))}"))
-            )
-            rhs_query_input_id = (
-                self.input_variable_ids_by_logical_id[rhs_variable_id]
-                if self.input_variable_ids_by_logical_id
-                else str(uuid4_from_hash(f"{self.node_id}|{hash(tuple(path))}"))
-            )
+            lhs_variable_id = logical_expression.lhs_variable.value
+            if not isinstance(lhs_variable_id, str):
+                raise TypeError(f"Expected lhs_variable_id to be a string, got {type(lhs_variable_id)}")
+
+            rhs_variable_id = logical_expression.rhs_variable.value
+            if not isinstance(rhs_variable_id, str):
+                raise TypeError(f"Expected rhs_variable_id to be a string, got {type(rhs_variable_id)}")
+
+            lhs_query_input_id: UUID = self.metadata_filter_input_id_by_operand_id.get(
+                UUID(lhs_variable_id)
+            ) or uuid4_from_hash(f"{self.node_id}|{hash(tuple(path))}")
+            rhs_query_input_id: UUID = self.metadata_filter_input_id_by_operand_id.get(
+                UUID(rhs_variable_id)
+            ) or uuid4_from_hash(f"{self.node_id}|{hash(tuple(path))}")
 
             return (
                 {
@@ -173,7 +177,7 @@ class BaseSearchNodeDisplay(BaseNodeVellumDisplay[_SearchNodeType], Generic[_Sea
                     create_node_input(
                         self.node_id,
                         f"vellum-query-builder-variable-{lhs_variable_id}",
-                        lhs_query_input_id,
+                        str(lhs_query_input_id),
                         display_context,
                         input_id=UUID(lhs_variable_id),
                         pointer_type=InputVariablePointer,
@@ -181,7 +185,7 @@ class BaseSearchNodeDisplay(BaseNodeVellumDisplay[_SearchNodeType], Generic[_Sea
                     create_node_input(
                         self.node_id,
                         f"vellum-query-builder-variable-{rhs_variable_id}",
-                        rhs_query_input_id,
+                        str(rhs_query_input_id),
                         display_context,
                         input_id=UUID(rhs_variable_id),
                         pointer_type=InputVariablePointer,

vellum_ee/workflows/display/nodes/vellum/templating_node.py

@@ -25,7 +25,7 @@ class BaseTemplatingNodeDisplay(BaseNodeVellumDisplay[_TemplatingNodeType], Gene
 
         template_input_id = self.template_input_id or next(
             (
-                input_id
+                UUID(input_id) if isinstance(input_id, str) else input_id
                 for input_name, input_id in self.node_input_ids_by_name.items()
                 if input_name == TEMPLATE_INPUT_NAME
             ),

vellum_ee/workflows/display/nodes/vellum/utils.py

@@ -1,5 +1,5 @@
 from uuid import UUID
-from typing import Any, List, Optional, Type, cast
+from typing import Any, List, Optional, Type, Union, cast
 
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.expressions.coalesce_expression import CoalesceExpression
@@ -27,10 +27,10 @@ def create_node_input(
     input_name: str,
     value: Any,
     display_context: WorkflowDisplayContext,
-    input_id: Optional[UUID],
+    input_id: Union[Optional[UUID], Optional[str]],
     pointer_type: Optional[Type[NodeInputValuePointerRule]] = ConstantValuePointer,
 ) -> NodeInput:
-    input_id = input_id or uuid4_from_hash(f"{node_id}|{input_name}")
+    input_id = str(input_id) if input_id else str(uuid4_from_hash(f"{node_id}|{input_name}"))
     if (
         isinstance(value, OutputReference)
         and value.outputs_class._node_class
@@ -42,7 +42,7 @@ def create_node_input(
 
     rules = create_node_input_value_pointer_rules(value, display_context, pointer_type=pointer_type)
     return NodeInput(
-        id=str(input_id),
+        id=input_id,
         key=input_name,
         value=NodeInputValuePointer(
             rules=rules,

vellum_ee/workflows/display/utils/vellum.py

@@ -9,7 +9,6 @@ from vellum.workflows.references import OutputReference, WorkflowInputReference
 from vellum.workflows.references.execution_count import ExecutionCountReference
 from vellum.workflows.references.node import NodeReference
 from vellum.workflows.references.vellum_secret import VellumSecretReference
-from vellum.workflows.types.core import VellumValuePrimitive
 from vellum.workflows.utils.vellum_variables import primitive_type_to_vellum_variable_type
 from vellum.workflows.vellum_client import create_vellum_client
 from vellum_ee.workflows.display.types import WorkflowDisplayContext
@@ -93,7 +92,7 @@ def create_node_input_value_pointer_rule(
     raise ValueError(f"Unsupported descriptor type: {value.__class__.__name__}")
 
 
-def primitive_to_vellum_value(value: VellumValuePrimitive) -> VellumValue:
+def primitive_to_vellum_value(value: Any) -> VellumValue:
     """Converts a python primitive to a VellumVariableValue"""
 
     if isinstance(value, str):