call block with args

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

Author: starpit

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

@@ -13,7 +13,7 @@ use tempfile::Builder;
 
 use crate::pdl::ast::{
     PdlBaseType, PdlBlock, PdlCallBlock, PdlFunctionBlock, PdlMessageBlock, PdlModelBlock,
-    PdlOptionalType, PdlParser, PdlRepeatBlock, PdlTextBlock, PdlType, Role,
+    PdlObjectBlock, PdlOptionalType, PdlParser, PdlRepeatBlock, PdlTextBlock, PdlType, Role,
 };
 use crate::pdl::pip::pip_install_if_needed;
 use crate::pdl::requirements::BEEAI_FRAMEWORK;
@@ -514,9 +514,9 @@ asyncio.run(invoke())
             let mut m = HashMap::new();
             m.insert(
                 "pdl__tools".to_string(),
-                PdlBlock::Object {
+                PdlBlock::Object(PdlObjectBlock {
                     object: tool_declarations,
-                },
+                }),
             );
             Some(m)
         },

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

@@ -1,6 +1,6 @@
 use ::std::collections::HashMap;
 use serde::{Deserialize, Serialize};
-use serde_json::{Map, Value};
+use serde_json::{Number, 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<Box<PdlBlock>>,
+    pub args: Option<Value>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub defs: Option<HashMap<String, PdlBlock>>,
 }
@@ -210,16 +210,23 @@ pub struct PdlMessageBlock {
     pub tool_call_id: Option<String>,
 }
 
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct PdlObjectBlock {
+    pub object: HashMap<String, PdlBlock>,
+}
+
 #[derive(Serialize, Deserialize, Debug, Clone)]
 #[serde(untagged)]
 pub enum PdlBlock {
+    Bool(bool),
+    Number(Number),
     String(String),
     /*If {
             #[serde(rename = "if")]
             condition: String,
             then: Box<PdlBlock>,
     },*/
-    Object { object: HashMap<String, PdlBlock> },
+    Object(PdlObjectBlock),
     Call(PdlCallBlock),
     Array { array: Vec<PdlBlock> },
     Message(PdlMessageBlock),
@@ -236,6 +243,12 @@ impl From<&str> for PdlBlock {
     }
 }
 
+impl From<String> for PdlBlock {
+    fn from(s: String) -> Self {
+        PdlBlock::String(s.clone())
+    }
+}
+
 impl From<&str> for Box<PdlBlock> {
     fn from(s: &str) -> Self {
         Box::new(PdlBlock::String(s.into()))

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

@@ -17,7 +17,7 @@ use ollama_rs::{
     Ollama,
 };
 
-use serde_json::{from_str, to_string, Value};
+use serde_json::{from_str, to_string, Map, Value};
 use serde_norway::from_reader;
 use tokio::runtime::Runtime;
 
@@ -104,28 +104,29 @@ impl<'a> Interpreter<'a> {
     }
 
     // Evaluate as a Jinja2 expression
-    fn eval(&self, expr: &String) -> Result<PdlBlock, Box<dyn Error>> {
+    fn eval<T: serde::de::DeserializeOwned + ::std::convert::From<String>>(
+        &self,
+        expr: &String,
+    ) -> Result<T, Box<dyn Error>> {
         let result = self
             .jinja_env
             .render_str(expr.as_str(), self.scope.last().unwrap_or(&HashMap::new()))?;
         if self.debug {
             eprintln!("Eval '{}' -> {}", &expr, &result);
         }
 
-        match from_str(&result) {
-            Err(_) => {
-                if self.debug {
-                    eprintln!("Plain string {}", &result);
-                }
-                Ok(PdlBlock::String(result))
+        let backup = result.clone();
+        Ok(from_str(&result).unwrap_or_else(|_err| {
+            if self.debug {
+                eprintln!("Plain string {}", &result);
             }
-            Ok(x) => Ok(x),
-        }
+            backup.into()
+        }))
     }
 
     // Run a PdlBlock::String
     fn run_string(&self, msg: &String, _context: Context) -> Interpretation {
-        let trace = self.eval(msg)?;
+        let trace = self.eval::<PdlBlock>(msg)?;
         if self.debug {
             eprintln!("String {} -> {:?}", msg, trace);
         }
@@ -141,12 +142,56 @@ impl<'a> Interpreter<'a> {
     // Run a PdlBlock::Call
     fn run_call(&mut self, block: &PdlCallBlock, context: Context) -> Interpretation {
         if self.debug {
-            eprintln!("Call {:?} {:?}", block.call, block.args);
+            eprintln!("Call {:?}({:?})", block.call, block.args);
         }
-        match self.eval(&block.call)? {
+
+        let args = match &block.args {
+            Some(x) => match x {
+                // args is a string; eval it and see if we get an Object out the other side
+                Value::String(s) => match self.eval::<Value>(&s)? {
+                    // args was a string that eval'd to an Object
+                    Value::Object(m) => Ok(Some(self.to_pdl(&m))),
+                    // args was a string that eval'd to something we don't understand
+                    y => Err(Box::<dyn Error>::from(format!(
+                        "Invalid arguments to call {:?}",
+                        y
+                    ))),
+                },
+                // args is already an Object
+                Value::Object(m) => Ok(Some(self.to_pdl(&m))),
+                // args is something we don't understand
+                y => Err(Box::from(format!("Invalid arguments to call {:?}", y))),
+            },
+            // no args... that's ok (TODO: check against function schema)
+            None => Ok(None),
+        }?;
+        self.extend_scope_with_map(&args);
+
+        let res = match self.eval::<PdlBlock>(&block.call)? {
             PdlBlock::Function(f) => self.run(&f.return_, context.clone()),
             _ => Err(Box::from("call of non-function")),
-        }
+        };
+        self.scope.pop();
+
+        res
+    }
+
+    fn to_pdl(&self, m: &Map<String, Value>) -> HashMap<String, PdlBlock> {
+        m.into_iter()
+            .map(|(k, v)| {
+                (
+                    k.clone(),
+                    match v {
+                        Value::String(s) => PdlBlock::String(s.clone()),
+                        Value::Number(n) => PdlBlock::Number(n.clone()),
+                        x => {
+                            eprintln!("Unhandled arg value {:?}", x);
+                            "error".into()
+                        }
+                    },
+                )
+            })
+            .collect()
     }
 
     fn to_ollama_model_options(
@@ -256,7 +301,7 @@ impl<'a> Interpreter<'a> {
         let for_ = block
             .for_
             .iter()
-            .map(|(var, values)| (var, self.eval(&values)));
+            .map(|(var, values)| (var, self.eval::<PdlBlock>(&values)));
 
         if self.debug {
             eprintln!("Repeat {:?}", &for_);

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

@@ -70,23 +70,24 @@ mod tests {
         assert_eq!(messages[0].role, MessageRole::User);
         assert_eq!(messages[0].content, "what is the fastest animal?");
         assert_eq!(messages[1].role, MessageRole::Assistant);
-        assert!(messages[1].content.contains("cheetah"));
+        let m1 = messages[1].content.to_lowercase();
+        assert!(m1.contains("cheetah") || m1.contains("springbok"));
         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();
+        let m3 = messages[3].content.to_lowercase();
         assert!(
-            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")
+            m3.contains("peregrine")
+                || m3.contains("bison")
+                || m3.contains("hare")
+                || m3.contains("golden eagle")
+                || m3.contains("greyhound")
+                || m3.contains("gazelle")
+                || m3.contains("lynx")
+                || m3.contains("boar")
+                || m3.contains("sailfish")
+                || m3.contains("pronghorn")
         );
         Ok(())
     }
@@ -145,7 +146,7 @@ mod tests {
                         "x": "int"
                     },
                     "return": {
-                        "description": "nullary function",
+                        "description": "unary function",
                         "text": [
                             "hello world ${x+1}"
                         ]