some call args work, plus proper minijinja variable delimieters

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

Author: starpit

pdl-live-react/src-tauri/Cargo.lock

@@ -34,7 +34,7 @@ sha2 = "0.10.8"
 base64ct = { version = "1.7.1", features = ["alloc"] }
 dirs = "6.0.0"
 serde_norway = "0.9.42"
-minijinja = "2.8.0"
+minijinja = { version = "2.9.0", features = ["custom_syntax"] }
 ollama-rs = { version = "0.3.0", features = ["tokio"] }
 tokio = "1.44.1"
 owo-colors = "4.2.0"

pdl-live-react/src-tauri/Cargo.toml

@@ -188,7 +188,7 @@ fn call_tools(model: &String, parameters: &HashMap<String, Value>) -> PdlBlock {
                                 &"${ tool.function.arguments }",
                             ),
                             call: "${ pdl__tools[tool.function.name] }".to_string(), // look up tool in tool_declarations def (see below)
-                            args: Some("${ args }".to_string()), // invoke with arguments as specified by the model
+                            args: Some("${ args }".into()), // invoke with arguments as specified by the model
                         })),
                     })],
                 })

pdl-live-react/src-tauri/src/compile/beeai.rs

@@ -1,6 +1,6 @@
 use ::std::collections::HashMap;
 use serde::{Deserialize, Serialize};
-use serde_json::Value;
+use serde_json::{Map, Value};
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
 #[serde(rename_all_fields = "lowercase")]
@@ -50,7 +50,7 @@ pub enum PdlType {
 pub struct PdlCallBlock {
     pub call: String,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub args: Option<String>,
+    pub args: Option<Box<PdlBlock>>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub defs: Option<HashMap<String, PdlBlock>>,
 }
@@ -235,3 +235,9 @@ impl From<&str> for PdlBlock {
         PdlBlock::String(s.into())
     }
 }
+
+impl From<&str> for Box<PdlBlock> {
+    fn from(s: &str) -> Self {
+        Box::new(PdlBlock::String(s.into()))
+    }
+}

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

@@ -5,8 +5,8 @@ use ::std::error::Error;
 use ::std::fs::File;
 // use ::std::path::PathBuf;
 
-use minijinja::Environment;
-use owo_colors::{FgColorDisplay, OwoColorize};
+use minijinja::{syntax::SyntaxConfig, Environment};
+use owo_colors::OwoColorize;
 
 use ollama_rs::{
     generation::{
@@ -68,11 +68,17 @@ impl Interpreter {
         Ok((messages, trace))
     }
 
-    fn eval(&self, pdl_expr: &String) -> Result<PdlBlock, Box<dyn Error>> {
-        let expr = pdl_expr.replace("${ ", "{{").replace(" }", "}}"); // FIXME regexp
+    // Evaluate as a Jinja2 expression
+    fn eval(&self, expr: &String) -> Result<PdlBlock, Box<dyn Error>> {
         let mut env = Environment::new();
-        env.add_template(pdl_expr, expr.as_str())?;
-        let tmpl = env.get_template(pdl_expr)?;
+        // 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()))?;
         if self.debug {
             eprintln!("Eval '{}' -> {}", &expr, &result);
@@ -89,6 +95,7 @@ impl Interpreter {
         }
     }
 
+    // Run a PdlBlock::String
     fn run_string(&self, msg: &String, _context: Context) -> Interpretation {
         let trace = self.eval(msg)?;
         if self.debug {
@@ -103,9 +110,10 @@ impl Interpreter {
         Ok((messages, trace))
     }
 
+    // Run a PdlBlock::Call
     fn run_call(&mut self, block: &PdlCallBlock, context: Context) -> Interpretation {
         if self.debug {
-            eprintln!("Call {:?}", &block.call);
+            eprintln!("Call {:?} {:?}", block.call, block.args);
         }
         match self.eval(&block.call)? {
             PdlBlock::Function(f) => self.run(&f.return_, context.clone()),
@@ -146,6 +154,7 @@ impl Interpreter {
         }
     }
 
+    // Run a PdlBlock::Model
     fn run_model(&mut self, block: &PdlModelBlock, context: Context) -> Interpretation {
         match &block.model {
             pdl_model
@@ -159,6 +168,7 @@ impl Interpreter {
                 };
 
                 let (options, tools) = self.to_ollama_model_options(&block.parameters);
+                println!("MODEL OPTIONS {:?}", options);
 
                 let messages = match &block.input {
                     Some(input) => {
@@ -211,6 +221,7 @@ impl Interpreter {
         }
     }
 
+    // Run a PdlBlock::Repeat
     fn run_repeat(&mut self, block: &PdlRepeatBlock, _context: Context) -> Interpretation {
         let for_ = block
             .for_
@@ -241,18 +252,9 @@ impl Interpreter {
         }
     }
 
-    fn run_text(&mut self, block: &PdlTextBlock, context: Context) -> Interpretation {
-        if self.debug {
-            eprintln!(
-                "Text {:?}",
-                block
-                    .description
-                    .clone()
-                    .unwrap_or("<no description>".to_string())
-            );
-        }
+    fn extend_scope_with_map(&mut self, map: &Option<HashMap<String, PdlBlock>>) {
         let cur_scope = self.scope.last().unwrap_or(&HashMap::new()).clone();
-        let new_scope: Scope = match &block.defs {
+        let new_scope = match map {
             Some(defs) => {
                 // this is all non-optimal
                 let mut scope: Scope = HashMap::from(cur_scope);
@@ -267,11 +269,26 @@ impl Interpreter {
             None => cur_scope,
         };
 
+        self.scope.push(new_scope);
+    }
+
+    // Run a PdlBlock::Text
+    fn run_text(&mut self, block: &PdlTextBlock, context: Context) -> Interpretation {
+        if self.debug {
+            eprintln!(
+                "Text {:?}",
+                block
+                    .description
+                    .clone()
+                    .unwrap_or("<no description>".to_string())
+            );
+        }
+
         let mut input_messages = context.clone();
         let mut output_messages = vec![];
         let mut output_blocks = vec![];
 
-        self.scope.push(new_scope);
+        self.extend_scope_with_map(&block.defs);
         block.text.iter().try_for_each(|block| {
             // run each element of the Text block
             let (this_messages, trace) = self.run(&block, input_messages.clone())?;

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

@@ -74,14 +74,19 @@ mod tests {
         assert_eq!(messages[2].role, MessageRole::User);
         assert_eq!(messages[2].content, "in europe?");
         assert_eq!(messages[3].role, MessageRole::Assistant);
+
+        let m = messages[3].content.to_lowercase();
         assert!(
-            messages[3].content.contains("peregrine")
-                || messages[3].content.contains("bison")
-                || messages[3].content.contains("hare")
-                || messages[3].content.contains("Eagle")
-                || messages[3].content.contains("Greyhound")
-                || messages[3].content.contains("gazelle")
-                || messages[3].content.contains("lynx")
+            m.contains("peregrine")
+                || m.contains("bison")
+                || m.contains("hare")
+                || m.contains("golden eagle")
+                || m.contains("greyhound")
+                || m.contains("gazelle")
+                || m.contains("lynx")
+                || m.contains("boar")
+                || m.contains("sailfish")
+                || m.contains("pronghorn")
         );
         Ok(())
     }
@@ -130,4 +135,32 @@ mod tests {
         assert_eq!(messages[0].content, "hello world");
         Ok(())
     }
+
+    #[test]
+    fn text_call_function_with_args() -> Result<(), Box<dyn Error>> {
+        let program = json!({
+            "defs": {
+                "foo": {
+                    "function": {
+                        "x": "int"
+                    },
+                    "return": {
+                        "description": "nullary function",
+                        "text": [
+                            "hello world ${x+1}"
+                        ]
+                    }
+                }
+            },
+            "text": [
+                { "call": "${ foo }", "args": { "x": 3 } },
+            ]
+        });
+
+        let (messages, _) = run_json(program, false)?;
+        assert_eq!(messages.len(), 1);
+        assert_eq!(messages[0].role, MessageRole::User);
+        assert_eq!(messages[0].content, "hello world 4");
+        Ok(())
+    }
 }