dv-pipecat-flows 0.0.0.dev2245__tar.gz → 0.0.0.dev2248__tar.gz

{dv_pipecat_flows-0.0.0.dev2245/src/dv_pipecat_flows.egg-info → dv_pipecat_flows-0.0.0.dev2248}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-flows
-Version: 0.0.0.dev2245
+Version: 0.0.0.dev2248
 Summary: Conversation Flow management for Pipecat AI applications
 License: BSD 2-Clause License
 Project-URL: Source, https://github.com/pipecat-ai/pipecat-flows

{dv_pipecat_flows-0.0.0.dev2245 → dv_pipecat_flows-0.0.0.dev2248/src/dv_pipecat_flows.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-flows
-Version: 0.0.0.dev2245
+Version: 0.0.0.dev2248
 Summary: Conversation Flow management for Pipecat AI applications
 License: BSD 2-Clause License
 Project-URL: Source, https://github.com/pipecat-ai/pipecat-flows

{dv_pipecat_flows-0.0.0.dev2245 → dv_pipecat_flows-0.0.0.dev2248}/src/pipecat_flows/condition_evaluator.py

@@ -37,6 +37,12 @@ Null/type policy:
     * ``null == "paid"`` -> False (no equality between None and a non-None RHS).
     * ``exists`` returns True only when the resolved value is non-None and
       non-empty-string; ``not_exists`` is its inverse.
+
+Case sensitivity:
+    String comparisons (``equals``, ``not_equals``, ``contains``, ``in``) are
+    case-INsensitive. LLM-extracted values are inconsistently cased
+    ("Yes"/"yes"/"YES") and authors write conditions in one form. Numeric and
+    null-shape ops (``greater_than`` etc., ``exists``) are unaffected.
 """
 
 from __future__ import annotations
@@ -150,6 +156,12 @@ def _coerce_numeric(value: Any) -> Optional[float]:
     return None
 
 
+def _ci_str(value: Any) -> Any:
+    """Lowercase a string for case-insensitive comparison; pass non-strings
+    through unchanged. Used by string ops below."""
+    return value.lower() if isinstance(value, str) else value
+
+
 def _evaluate_rule(
     rule: Rule,
     state: Dict[str, Any],
@@ -192,14 +204,20 @@ def _evaluate_rule(
         lhs_num, rhs_num = _coerce_numeric(lhs), _coerce_numeric(rhs)
         if lhs_num is not None and rhs_num is not None:
             return lhs_num == rhs_num
-        return str(lhs) == str(rhs)
+        # String compare is case-INsensitive — LLM-extracted values are
+        # inconsistently cased ("Yes"/"yes"/"YES") and authors write conditions
+        # in one form. NOTE: this is a behavior change — agents that relied on
+        # case to distinguish (e.g. "Apple" vs "apple" as different categories)
+        # will now treat them as equal. ``not_equals`` likewise inverts for
+        # case-only-different values.
+        return _ci_str(str(lhs)) == _ci_str(str(rhs))
     if op == "not_equals":
         if lhs is None:
             return rhs is not None  # None != anything-non-None
         lhs_num, rhs_num = _coerce_numeric(lhs), _coerce_numeric(rhs)
         if lhs_num is not None and rhs_num is not None:
             return lhs_num != rhs_num
-        return str(lhs) != str(rhs)
+        return _ci_str(str(lhs)) != _ci_str(str(rhs))
 
     if op in ("greater_than", "less_than", "greater_or_equal", "less_or_equal"):
         lhs_num, rhs_num = _coerce_numeric(lhs), _coerce_numeric(rhs)
@@ -214,24 +232,28 @@ def _evaluate_rule(
         return lhs_num <= rhs_num  # less_or_equal
 
     if op == "contains":
-        # Strings: substring; lists: membership.
+        # Strings: substring; lists: membership. Strings are case-insensitive
+        # (see ``equals`` rationale); list membership lowercases string
+        # elements so ``["Yes", "No"] contains "yes"`` matches.
         if lhs is None:
             return False
         if isinstance(lhs, str):
-            return str(rhs) in lhs
+            return _ci_str(str(rhs)) in _ci_str(lhs)
         if isinstance(lhs, (list, tuple, set)):
-            return rhs in lhs
+            rhs_ci = _ci_str(rhs)
+            return any(_ci_str(item) == rhs_ci for item in lhs)
         return False
 
     if op == "in":
         # `variable IN value` — value is the haystack (list or comma-string).
         if rhs is None:
             return False
+        lhs_ci = _ci_str(lhs)
         if isinstance(rhs, (list, tuple, set)):
-            return lhs in rhs
+            return any(_ci_str(item) == lhs_ci for item in rhs)
         if isinstance(rhs, str):
             # Comma-separated convenience: "en,hi,es".
-            return str(lhs) in [s.strip() for s in rhs.split(",")]
+            return _ci_str(str(lhs)) in [_ci_str(s.strip()) for s in rhs.split(",")]
         return False
 
     return False