jinja_env as state, run_quiet/self.emit

Signed-off-by: Nick Mitchell <[email protected]>

Author: starpit

pdl-live-react/src-tauri/src/pdl/interpreter.rs

@@ -29,32 +29,51 @@ type Context = Vec<ChatMessage>;
 type Scope = HashMap<String, Value>;
 type Interpretation = Result<(Context, PdlBlock), Box<dyn Error>>;
 
-struct Interpreter {
+struct Interpreter<'a> {
     // batch: u32,
     // role: Role,
     // cwd: Box<PathBuf>,
     // id_stack: Vec<String>,
-    // jinja_env: Environment<'a>,
+    jinja_env: Environment<'a>,
     rt: Runtime,
     scope: Vec<Scope>,
     debug: bool,
+    emit: bool,
 }
 
-impl Interpreter {
+impl<'a> Interpreter<'a> {
     fn new() -> Self {
+        let mut jinja_env = Environment::new();
+        // PDL uses custom variable delimeters, because {{ }} have pre-defined meaning in yaml
+        jinja_env.set_syntax(
+            SyntaxConfig::builder()
+                .variable_delimiters("${", "}")
+                .build()
+                .unwrap(),
+        );
+
         Self {
             // batch: 0,
             // role: Role::User,
             // cwd: Box::new(current_dir().unwrap_or(PathBuf::from("/"))),
             // id_stack: vec![],
-            // jinja_env: Environment::new(),
+            jinja_env: jinja_env,
             rt: Runtime::new().unwrap(),
             scope: vec![Scope::new()],
             debug: false,
+            emit: true,
         }
     }
 
-    fn run(&mut self, program: &PdlBlock, context: Context) -> Interpretation {
+    fn run_with_emit(
+        &mut self,
+        program: &PdlBlock,
+        context: Context,
+        emit: bool,
+    ) -> Interpretation {
+        let prior_emit = self.emit;
+        self.emit = emit;
+
         let (messages, trace) = match program {
             PdlBlock::String(s) => self.run_string(s, context),
             PdlBlock::Call(block) => self.run_call(block, context),
@@ -64,22 +83,31 @@ impl Interpreter {
             _ => Err(Box::from(format!("Unsupported block {:?}", program))),
         }?;
 
-        pretty_print(&messages);
+        if match program {
+            PdlBlock::Call(_) | PdlBlock::Text(_) => false,
+            _ => self.emit,
+        } {
+            // eprintln!("{:?}", program);
+            pretty_print(&messages);
+        }
+        self.emit = prior_emit;
+
         Ok((messages, trace))
     }
 
+    fn run_quiet(&mut self, program: &PdlBlock, context: Context) -> Interpretation {
+        self.run_with_emit(program, context, false)
+    }
+
+    fn run(&mut self, program: &PdlBlock, context: Context) -> Interpretation {
+        self.run_with_emit(program, context, self.emit)
+    }
+
     // Evaluate as a Jinja2 expression
     fn eval(&self, expr: &String) -> Result<PdlBlock, Box<dyn Error>> {
-        let mut env = Environment::new();
-        // PDL uses custom variable delimeters, because {{ }} have pre-defined meaning in yaml
-        env.set_syntax(
-            SyntaxConfig::builder()
-                .variable_delimiters("${", "}")
-                .build()?,
-        );
-        env.add_template(expr, expr.as_str())?;
-        let tmpl = env.get_template(expr)?;
-        let result = tmpl.render(self.scope.last().unwrap_or(&HashMap::new()))?;
+        let result = self
+            .jinja_env
+            .render_str(expr.as_str(), self.scope.last().unwrap_or(&HashMap::new()))?;
         if self.debug {
             eprintln!("Eval '{}' -> {}", &expr, &result);
         }
@@ -168,12 +196,14 @@ impl Interpreter {
                 };
 
                 let (options, tools) = self.to_ollama_model_options(&block.parameters);
-                println!("MODEL OPTIONS {:?}", options);
+                if self.debug {
+                    println!("Model options {:?}", options);
+                }
 
                 let messages = match &block.input {
                     Some(input) => {
                         // TODO ignoring trace
-                        let (messages, _trace) = self.run(&*input, context)?;
+                        let (messages, _trace) = self.run_quiet(&*input, context)?;
                         messages
                     }
                     None => context,