more tests plus some ast builders

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

Author: starpit

pdl-live-react/package.json

@@ -14,9 +14,10 @@
     "tauri": "tauri",
     "test:quality": "concurrently -n 'lint,types,formatting' 'npm run lint' 'tsc --build --noEmit' \"prettier --check 'tests/**/*.ts'  'src/**/*.{ts,tsx,css}'\"",
     "test:ui": "playwright install --with-deps && playwright test",
-    "test:bee": "until [ -f ./src-tauri/target/debug/pdl ]; do sleep 1; done; for i in ./demos/beeai/*.py; do ./src-tauri/target/debug/pdl compile beeai $i -g --output - | jq; done", 
+    "test:bee": "until [ -f ./src-tauri/target/debug/pdl ]; do sleep 1; done; for i in ./demos/beeai/*.py; do ./src-tauri/target/debug/pdl compile beeai $i -g --output - | jq; done",
+    "test:interpreter": "cd src-tauri && cargo test",
     "types": "(cd .. && python -m src.pdl.pdl --schema > src/pdl/pdl-schema.json) && json2ts ../src/pdl/pdl-schema.json src/pdl_ast.d.ts --unreachableDefinitions && npm run format",
-    "test": "concurrently -n 'quality,playwright' 'npm run test:quality' 'npm run test:ui'",
+    "test": "concurrently -n 'quality,playwright,interpreter' 'npm run test:quality' 'npm run test:ui' 'npm run test:interpreter'",
     "pdl": "./src-tauri/target/debug/pdl",
     "view": "npm run pdl view",
     "start": "npm run tauri dev"

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

@@ -171,30 +171,28 @@ fn call_tools(model: &String, parameters: &HashMap<String, Value>) -> PdlBlock {
         role: None,
         parser: None,
         description: Some("Calling tool ${ tool.function.name }".to_string()),
-        text: vec![PdlBlock::Model(PdlModelBlock {
-            parameters: Some(parameters.clone()),
-            description: None, /*Some(
-                                   "Sending tool ${ tool.function.name } response back to model".to_string(),
-                               ),*/
-            def: None,
-            model_response: None,
-            model: model.clone(),
-            pdl_result: None,
-            pdl_usage: None,
-            input: Some(Box::new(PdlBlock::Array {
-                array: vec![PdlBlock::Message(PdlMessageBlock {
-                    role: Role::Tool,
-                    description: None,
-                    name: Some("${ tool.function.name }".to_string()),
-                    tool_call_id: Some("${ tool.id }".to_string()),
-                    content: Box::new(PdlBlock::Call(PdlCallBlock {
-                        defs: json_loads(&"args", &"pdl__args", &"${ 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
-                    })),
-                })],
-            })),
-        })],
+        text: vec![PdlBlock::Model(
+            PdlModelBlock::new(model.as_str())
+                .parameters(parameters)
+                .input(PdlBlock::Array {
+                    array: vec![PdlBlock::Message(PdlMessageBlock {
+                        role: Role::Tool,
+                        description: None,
+                        name: Some("${ tool.function.name }".to_string()),
+                        tool_call_id: Some("${ tool.id }".to_string()),
+                        content: Box::new(PdlBlock::Call(PdlCallBlock {
+                            defs: json_loads(
+                                &"args",
+                                &"pdl__args",
+                                &"${ 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
+                        })),
+                    })],
+                })
+                .build(),
+        )],
     });
 
     let mut for_ = HashMap::new();
@@ -218,16 +216,15 @@ fn json_loads(
     let mut m = HashMap::new();
     m.insert(
         outer_name.to_owned(),
-        PdlBlock::Text(PdlTextBlock {
-            defs: None,
-            role: None,
-            description: Some(format!("Parsing json for {}={}", inner_name, value)),
-            text: vec![PdlBlock::String(format!(
+        PdlBlock::Text(
+            PdlTextBlock::new(vec![PdlBlock::String(format!(
                 "{{\"{}\": {}}}",
                 inner_name, value
-            ))],
-            parser: Some(PdlParser::Json),
-        }),
+            ))])
+            .description(format!("Parsing json for {}={}", inner_name, value))
+            .parser(PdlParser::Json)
+            .build(),
+        ),
     );
     Some(m)
 }

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

@@ -68,6 +68,38 @@ pub struct PdlTextBlock {
     pub parser: Option<PdlParser>,
 }
 
+impl PdlTextBlock {
+    pub fn new(text: Vec<PdlBlock>) -> Self {
+        PdlTextBlock {
+            defs: None,
+            description: None,
+            role: None,
+            parser: None,
+            text: text,
+        }
+    }
+
+    pub fn description(&mut self, description: String) -> &mut Self {
+        self.description = Some(description);
+        self
+    }
+
+    pub fn parser(&mut self, parser: PdlParser) -> &mut Self {
+        self.parser = Some(parser);
+        self
+    }
+
+    pub fn build(&self) -> Self {
+        self.clone()
+    }
+}
+
+impl From<Vec<PdlBlock>> for PdlTextBlock {
+    fn from(v: Vec<PdlBlock>) -> Self {
+        PdlTextBlock::new(v).build()
+    }
+}
+
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct PdlFunctionBlock {
     pub function: HashMap<String, PdlType>,
@@ -107,6 +139,40 @@ pub struct PdlModelBlock {
     pub pdl_usage: Option<PdlUsage>,
 }
 
+impl PdlModelBlock {
+    pub fn new(model: &str) -> Self {
+        PdlModelBlock {
+            def: None,
+            description: None,
+            model_response: None,
+            parameters: None,
+            pdl_result: None,
+            pdl_usage: None,
+            model: model.into(),
+            input: None,
+        }
+    }
+
+    pub fn input(&mut self, input: PdlBlock) -> &mut Self {
+        self.input = Some(Box::new(input));
+        self
+    }
+
+    pub fn input_str(&mut self, input: &str) -> &mut Self {
+        self.input = Some(Box::new(PdlBlock::String(input.into())));
+        self
+    }
+
+    pub fn parameters(&mut self, parameters: &HashMap<String, Value>) -> &mut Self {
+        self.parameters = Some(parameters.clone());
+        self
+    }
+
+    pub fn build(&self) -> Self {
+        self.clone()
+    }
+}
+
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct PdlRepeatBlock {
     #[serde(rename = "for")]
@@ -145,3 +211,9 @@ pub enum PdlBlock {
     Function(PdlFunctionBlock),
     PythonCode { lang: String, code: String },
 }
+
+impl From<&str> for PdlBlock {
+    fn from(s: &str) -> Self {
+        PdlBlock::String(s.into())
+    }
+}

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

@@ -5,9 +5,8 @@ mod tests {
 
     use crate::pdl::{
         ast::{
-            PdlBlock,
-            /*PdlCallBlock,*/
-            PdlModelBlock, /*PdlRepeatBlock, PdlTextBlock, PdlUsage, Role,*/
+            PdlBlock,      /*PdlCallBlock,*/
+            PdlModelBlock, /*PdlRepeatBlock,*/ /*PdlTextBlock,*/ /*, PdlUsage, Role,*/
         },
         interpreter::run,
     };
@@ -18,31 +17,42 @@ mod tests {
 
     #[test]
     fn string() -> Result<(), Box<dyn Error>> {
-        let (messages, _) = run(&PdlBlock::String("hello".into()), false)?;
+        let (messages, _) = run(&"hello".into(), false)?;
         assert_eq!(messages.len(), 1);
         assert_eq!(messages[0].role, MessageRole::User);
         assert_eq!(messages[0].content, "hello");
         Ok(())
     }
 
     #[test]
-    fn single_model() -> Result<(), Box<dyn Error>> {
+    fn single_model_via_input() -> Result<(), Box<dyn Error>> {
         let (messages, _) = run(
-            &PdlBlock::Model(PdlModelBlock {
-                def: None,
-                description: None,
-                model_response: None,
-                parameters: None,
-                pdl_result: None,
-                pdl_usage: None,
-                model: DEFAULT_MODEL.into(),
-                input: Some(Box::new(PdlBlock::String("hello".into()))),
-            }),
+            &PdlBlock::Model(PdlModelBlock::new(DEFAULT_MODEL).input_str("hello").build()),
             false,
         )?;
         assert_eq!(messages.len(), 1);
         assert_eq!(messages[0].role, MessageRole::Assistant);
         assert!(messages[0].content.contains("Hello!"));
         Ok(())
     }
+
+    #[test]
+    fn single_model_via_text_chain() -> Result<(), Box<dyn Error>> {
+        let (messages, _) = run(
+            &PdlBlock::Text(
+                vec![
+                    "hello".into(),
+                    PdlBlock::Model(PdlModelBlock::new(DEFAULT_MODEL).build()),
+                ]
+                .into(),
+            ),
+            false,
+        )?;
+        assert_eq!(messages.len(), 2);
+        assert_eq!(messages[0].role, MessageRole::User);
+        assert!(messages[0].content.contains("hello"));
+        assert_eq!(messages[1].role, MessageRole::Assistant);
+        assert!(messages[1].content.contains("Hello!"));
+        Ok(())
+    }
 }