pass temperature in lark for all lexemes

parser/src/earley/from_guidance.rs

@@ -116,6 +116,8 @@ fn grammar_from_json(
             lark_to_llguidance(input.lark_grammar.as_ref().unwrap())?
         };
 
+        // println!("GRM: {}", serde_json::to_string(&new_grm).unwrap());
+
         additional_grammars = new_grm.grammars.drain(1..).collect::<Vec<_>>();
         for (off, g) in additional_grammars.iter().enumerate() {
             let name = g

parser/src/earley/grammar.rs

@@ -111,6 +111,10 @@ impl SymbolProps {
             outp.push_str(format!(" max_tokens={}", props.max_tokens).as_str());
         }
 
+        if props.temperature != 0.0 {
+            outp.push_str(format!(" temp={:.2}", props.temperature).as_str());
+        }
+
         outp
     }
 }

parser/src/lark/compiler.rs

@@ -406,7 +406,7 @@ impl Compiler {
                         return Ok(self.builder.add_node(Node::Lexeme {
                             rx: RegexSpec::RegexId(rx_id),
                             contextual: None,
-                            temperature: None,
+                            temperature: rule.temperature,
                             json_string: None,
                             json_raw: None,
                             json_allowed_escapes: None,

sample_parser/src/lib.rs

@@ -248,16 +248,16 @@ lazy_static! {
 pub fn check_lark_grammar_prompt(lark: &str, prompt_str: &str, output: &[&str]) -> Constraint {
     let grm = TopLevelGrammar::from_lark(lark.to_string());
     println!("\nChecking grammar:\n{}\nagainst: {:?}", lark, output);
-    check_grammar(&PARSER_FACTORY, prompt_str, grm, output, 0.0)
+    let temp = find_temperature(lark);
+    check_grammar(&PARSER_FACTORY, prompt_str, grm, output, temp)
 }
 
 pub fn check_lark_grammar(lark: &str, output: &[&str]) -> Constraint {
     check_lark_grammar_prompt(lark, "", output)
 }
 
-pub fn check_lark_grammar_nested(lark: &str, sub_lark: &str, output: &[&str]) -> Constraint {
-    let temp = lark
-        .find("temperature=")
+fn find_temperature(lark: &str) -> f32 {
+    lark.find("temperature=")
         .map(|i| {
             let i = i + "temperature=".len();
             let mut end = i;
@@ -268,7 +268,11 @@ pub fn check_lark_grammar_nested(lark: &str, sub_lark: &str, output: &[&str]) ->
             }
             lark[i..end].parse::<f32>().unwrap()
         })
-        .unwrap_or(0.0);
+        .unwrap_or(0.0)
+}
+
+pub fn check_lark_grammar_nested(lark: &str, sub_lark: &str, output: &[&str]) -> Constraint {
+    let temp = find_temperature(lark);
     let mut top_grm = TopLevelGrammar::from_lark(lark.to_string());
     let mut sub_grm = GrammarWithLexer::from_lark(sub_lark.to_string());
     sub_grm.name = Some("sub".to_string());

sample_parser/tests/test_ll.rs

@@ -299,6 +299,21 @@ fn test_ll_temperature() {
         "#,
         &["", "[‧]"],
     );
+
+    check_lark_grammar(
+        r#"start: gen
+           gen[temperature=0.5, stop=""]: /.*/
+        "#,
+        &["", "foo‧≺EOS≻"],
+    );
+
+    check_lark_grammar(
+        r#"start: foo | bar
+           foo[temperature=0.5]: "foo"
+           bar[temperature=0.5]: "bar"
+        "#,
+        &["", "foo"],
+    );
 }
 
 #[test]