_build_resolver: preserve raw rule body when sampling fails

Author: charludo

custom_components/closest_intent/conversation.py

@@ -39,6 +39,8 @@
         VERSION,
     )
     from .matching import (
+        _RULE_RE,
+        _SLOT_RE,
         Candidate,
         Resolver,
         build_canonical,
@@ -70,6 +72,8 @@
         VERSION,
     )
     from matching import (  # type: ignore
+        _RULE_RE,
+        _SLOT_RE,
         Candidate,
         Resolver,
         build_canonical,
@@ -452,11 +456,22 @@ def _build_resolver(self, language: str, custom_docs: list[dict]) -> Resolver:
                 intents = None
 
             if intents is not None:
+                raw_rules = (raw or {}).get("expansion_rules") or {}
                 # Expansion rules -> list of surface forms.
                 for name, rule in (intents.expansion_rules or {}).items():
                     try:
                         forms = list(_dedupe(sample_expression(rule.expression, intents)))
                     except Exception:
+                        forms = []
+                    # When we can't expand a rule, do not leave its name in as a literal string.
+                    raw_text = raw_rules.get(name)
+                    if isinstance(raw_text, str) and raw_text:
+                        needs_raw = (
+                            not forms or _SLOT_RE.search(raw_text) or _RULE_RE.search(raw_text)
+                        )
+                        if needs_raw and raw_text not in forms:
+                            forms.insert(0, raw_text)
+                    if not forms:
                         continue
                     # Cap rule expansion to keep alternation explosions bounded.
                     resolver.expansion_rules[name] = forms[: max(self._expansion_cap, 32)]

tests/test_matching.py

@@ -321,6 +321,18 @@ def test_resolver_inlines_unknown_rule_as_wildcard_slot() -> None:
     assert r.inline_rules("<unknown> rest") == "{unknown} rest"
 
 
+def test_expand_pattern_rule_body_with_slot_produces_wildcard() -> None:
+    """When an <expansion rule>'s body is a {slot} reference, the rule must inline as the slot."""
+    from const import SLOT_WILDCARD  # type: ignore
+
+    r = Resolver(expansion_rules={"name": ["{name}"]})
+    out = expand_pattern("<name> an", cap=16, resolver=r)
+    texts = [t for (t, _, _) in out]
+    slot_lists = [s for (_, _, s) in out]
+    assert any(SLOT_WILDCARD in t for t in texts)
+    assert ["name"] in slot_lists
+
+
 def test_expand_pattern_uses_resolver_rules() -> None:
     r = Resolver(expansion_rules={"gruss": ["hallo", "moin"]})
     out = expand_pattern("<gruss> closest_intent", cap=16, resolver=r)