fix: unbounded regex quantifiers prevent Outlines DFA state explosion (#203)

* fix: use outlines v1.2 get_regex_logits_processor API

The outlines v1.2 API requires:
1. Wrapping the HF model+tokenizer in outlines.Transformers
2. Calling get_regex_logits_processor(None, wrapped, regex)

Prior code tried to construct OutlinesLogitsProcessor directly with
a tokenizer= kwarg that doesn't exist in v1.2. The error was caught
and silently fell back to unconstrained generation.

Tests now verify the ACTUAL API surface (import paths + factory
function signature) instead of just checking class names exist.
This would have caught all three prior Outlines bugs:
- PR #197: wrong class name (RegexLogitsProcessor)
- PR #201: wrong constructor (tokenizer= kwarg)
- This PR: wrong API pattern (direct constructor vs factory)

33/33 tests pass with outlines 1.2.12 installed.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix: use unbounded regex quantifiers to prevent DFA state explosion

Bounded quantifiers like {1,500} create counting DFA states that
cross-product with every alternative in the regex. The Thought
prefix alone created 1,500 states, exceeding Outlines' 2^31 limit.

Changes:
- [^\n]{1,500} → [^\n]+  (Thought prefix: 1 state vs 1,500)
- [^"]{0,200} → [^"]*    (TYPE text: 1 state vs 200)
- \d{1,3} → \d+          (coordinates: 1 state vs 3)

max_new_tokens=512 provides the actual length limit. The DFA
doesn't need to count characters.

New test: test_no_bounded_quantifiers_in_regex asserts no quantifier
in the regex exceeds {N,10}, preventing future regressions.

34/34 tests pass.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: abrichr

openadapt_evals/training/standalone/trainer.py

@@ -91,19 +91,24 @@ def __init__(
     # --- Constrained decoding -------------------------------------------
 
     # Regex matching the required Thought/Action format from SYSTEM_PROMPT.
-    # The model gets up to 500 chars of chain-of-thought reasoning, then
-    # MUST output exactly one valid action.  This preserves the model's
-    # ability to reason while guaranteeing parseable output.
+    # The model reasons freely, then MUST output exactly one valid action.
     #
     # Format:  Thought: <reasoning>\nAction: <action>
+    #
+    # IMPORTANT: All repetitions use unbounded quantifiers (+, *) instead
+    # of bounded ({1,N}).  Bounded quantifiers create counting DFA states
+    # that explode combinatorially — {1,500} alone creates 1,500 states
+    # cross-producted with every action alternative.  Unbounded repetitions
+    # are single-state self-loops that Outlines handles efficiently.
+    # max_new_tokens provides the actual length limit.
     _ACTION_RE = (
-        r"CLICK\(x=0\.\d{1,3},\s*y=0\.\d{1,3}\)"
-        r'|TYPE\(text="[^"]{0,200}"\)'
+        r"CLICK\(x=0\.\d+,\s*y=0\.\d+\)"
+        r'|TYPE\(text="[^"]*"\)'
         r"|WAIT\(\)"
         r"|DONE\(\)"
     )
     _ACTION_REGEX = (
-        r"Thought: [^\n]{1,500}\nAction: (" + _ACTION_RE + r")"
+        r"Thought: [^\n]+\nAction: (" + _ACTION_RE + r")"
     )
     # Sentinel: None = not yet attempted, list = success, False = failed
     _constrained_processor_cache: Any = None

tests/test_standalone_trainer.py

@@ -80,6 +80,23 @@ def test_invalid_text_rejected(self, text: str) -> None:
     def test_action_only_regex_matches(self, action: str) -> None:
         assert re.match(self.action_regex, action), f"Expected match: {action!r}"
 
+    def test_no_bounded_quantifiers_in_regex(self) -> None:
+        """Regression test: bounded quantifiers ({N,M}) cause DFA state explosion.
+
+        Outlines compiles regex to a DFA. Bounded quantifiers like {1,500}
+        create counting states that cross-product with every alternative,
+        exceeding the 2^31 state limit. All repetitions must use +, *, or
+        small bounds ({1,3} is OK, {0,200} is not).
+        """
+        import re as _re
+        # Find all bounded quantifiers in the full regex
+        bounds = _re.findall(r'\{(\d+),(\d+)\}', self.full_regex)
+        for lo, hi in bounds:
+            assert int(hi) <= 10, (
+                f"Bounded quantifier {{{lo},{hi}}} in ACTION_REGEX will cause "
+                f"DFA state explosion in Outlines. Use + or * instead."
+            )
+
 
 # ---------------------------------------------------------------------------
 # Constrained decoding cache tests