PdlResult and ObjectBlock support

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

Author: starpit

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

@@ -2,7 +2,7 @@ use crate::pdl::interpreter::{pretty_print, run_string};
 
 #[tauri::command]
 pub async fn run_pdl_program(program: String, debug: bool) -> Result<String, String> {
-    let (messages, _) = run_string(&program, debug)
+    let (_, messages, _) = run_string(&program, debug)
         .await
         .map_err(|err| err.to_string())?;
 

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

@@ -25,15 +25,16 @@ use serde_json::{from_str, to_string, Map, Value};
 use serde_norway::{from_reader, from_str as from_yaml_str};
 
 use crate::pdl::ast::{
-    CallBlock, IfBlock, ListOrString, ModelBlock, PdlBlock, PdlParser, PdlUsage, PythonCodeBlock,
-    ReadBlock, RepeatBlock, Role, StringOrBoolean, TextBlock,
+    CallBlock, IfBlock, ListOrString, ModelBlock, ObjectBlock, PdlBlock, PdlParser, PdlUsage,
+    PythonCodeBlock, ReadBlock, RepeatBlock, Role, StringOrBoolean, TextBlock,
 };
 
+type PdlResult = Value;
 type Context = Vec<ChatMessage>;
 type Scope = HashMap<String, Value>;
 type PdlError = Box<dyn Error + Send + Sync>;
-type Interpretation = Result<(Context, PdlBlock), PdlError>;
-type InterpretationSync = Result<(Context, PdlBlock), Box<dyn Error>>;
+type Interpretation = Result<(PdlResult, Context, PdlBlock), PdlError>;
+type InterpretationSync = Result<(PdlResult, Context, PdlBlock), Box<dyn Error>>;
 
 struct Interpreter<'a> {
     // batch: u32,
@@ -80,11 +81,18 @@ impl<'a> Interpreter<'a> {
         let prior_emit = self.emit;
         self.emit = emit;
 
-        let (messages, trace) = match program {
+        let (result, messages, trace) = match program {
+            PdlBlock::Number(n) => Ok((
+                Value::Number(n.clone()),
+                vec![ChatMessage::user(format!("{n}"))],
+                PdlBlock::Number(n.clone()),
+            )),
+            PdlBlock::Function(f) => Ok((Value::Null, vec![], PdlBlock::Function(f.clone()))),
             PdlBlock::String(s) => self.run_string(s, context).await,
             PdlBlock::Call(block) => self.run_call(block, context).await,
             PdlBlock::If(block) => self.run_if(block, context).await,
             PdlBlock::Model(block) => self.run_model(block, context).await,
+            PdlBlock::Object(block) => self.run_object(block, context).await,
             PdlBlock::PythonCode(block) => self.run_python_code(block, context).await,
             PdlBlock::Read(block) => self.run_read(block, context).await,
             PdlBlock::Repeat(block) => self.run_repeat(block, context).await,
@@ -101,7 +109,7 @@ impl<'a> Interpreter<'a> {
         }
         self.emit = prior_emit;
 
-        Ok((messages, trace))
+        Ok((result, messages, trace))
     }
 
     #[async_recursion]
@@ -177,12 +185,13 @@ impl<'a> Interpreter<'a> {
             eprintln!("String {} -> {:?}", msg, trace);
         }
 
-        let messages = vec![ChatMessage::user(match &trace {
+        let result = match &trace {
             PdlBlock::String(s) => s.clone(),
             x => to_string(&x)?,
-        })];
+        };
+        let messages = vec![ChatMessage::user(result.clone())];
 
-        Ok((messages, trace))
+        Ok((Value::String(result), messages, trace))
     }
 
     fn path_to(&self, file_path: &String) -> PathBuf {
@@ -194,25 +203,32 @@ impl<'a> Interpreter<'a> {
     fn def(
         &mut self,
         variable: &Option<String>,
-        value: &String,
+        value: &Value,
         parser: &Option<PdlParser>,
-    ) -> Result<(), PdlError> {
-        if let Some(def) = &variable {
-            let result = if let Some(parser) = parser {
-                self.parse_result(parser, &value)?
+    ) -> Result<PdlResult, PdlError> {
+        let result = if let Some(parser) = parser {
+            if let Value::String(s) = value {
+                self.parse_result(parser, s)
             } else {
-                Value::from(value.clone()) // TODO
-            };
+                Err(Box::from(format!(
+                    "Cannot parse as {:?} a non-string value {:?}",
+                    parser, value
+                )))
+            }
+        } else {
+            Ok(value.clone())
+        }?;
 
+        if let Some(def) = &variable {
             if let Some(scope) = self.scope.last_mut() {
                 if self.debug {
                     eprintln!("Def {} -> {}", def, result);
                 }
-                scope.insert(def.clone(), result);
+                scope.insert(def.clone(), result.clone());
             }
         }
 
-        Ok(())
+        Ok(result)
     }
 
     /// Run a PdlBlock::Read
@@ -236,9 +252,13 @@ impl<'a> Interpreter<'a> {
             ))),
         }?;
 
-        self.def(&block.def, &buffer, &block.parser)?;
+        let result = self.def(&block.def, &buffer.clone().into(), &block.parser)?;
 
-        Ok((vec![ChatMessage::user(buffer)], PdlBlock::Read(trace)))
+        Ok((
+            result,
+            vec![ChatMessage::user(buffer)],
+            PdlBlock::Read(trace),
+        ))
     }
 
     /// Run a PdlBlock::Call
@@ -275,7 +295,7 @@ impl<'a> Interpreter<'a> {
             eprintln!("If {:?}({:?})", block.condition, block.then);
         }
 
-        self.extend_scope_with_block_map(&block.defs);
+        self.extend_scope_with_block_map(&block.defs).await?;
 
         let cond = match &block.condition {
             StringOrBoolean::Boolean(b) => Value::Bool(*b),
@@ -285,7 +305,7 @@ impl<'a> Interpreter<'a> {
             Value::Bool(true) => self.run_quiet(&block.then, context).await,
             Value::Bool(false) => match &block.else_ {
                 Some(else_block) => self.run_quiet(&else_block, context).await,
-                None => Ok((vec![], PdlBlock::If(block.clone()))),
+                None => Ok((Value::Null, vec![], PdlBlock::If(block.clone()))),
             },
             x => Err(Box::from(format!(
                 "if block condition evaluated to non-boolean value: {:?}",
@@ -372,7 +392,7 @@ impl<'a> Interpreter<'a> {
                         .unwrap();
                     let messages = vec![ChatMessage::user(result_string.as_str().to_string())];
                     let trace = PdlBlock::PythonCode(block.clone());
-                    Ok((messages, trace))
+                    Ok((Value::String(messages[0].content.clone()), messages, trace))
                 }
                 Err(_) => Err(Box::from(
                     "Python code block failed to assign a 'result' variable",
@@ -401,8 +421,8 @@ impl<'a> Interpreter<'a> {
 
                 let messages = match &block.input {
                     Some(input) => {
-                        // TODO ignoring trace
-                        let (messages, _trace) = self.run_quiet(&*input, context).await?;
+                        // TODO ignoring result, trace
+                        let (_result, messages, _trace) = self.run_quiet(&*input, context).await?;
                         messages
                     }
                     None => context,
@@ -486,16 +506,44 @@ impl<'a> Interpreter<'a> {
                     }
                     let mut message = res.message.clone();
                     message.content = response_string;
-                    Ok((vec![message], PdlBlock::Model(trace)))
+                    Ok((
+                        Value::String(message.content.clone()),
+                        vec![message],
+                        PdlBlock::Model(trace),
+                    ))
                 } else {
-                    Ok((vec![], PdlBlock::Model(trace)))
+                    // nothing came out of the model
+                    Ok((Value::Null, vec![], PdlBlock::Model(trace)))
                 }
                 // dbg!(history);
             }
             _ => Err(Box::from(format!("Unsupported model {}", block.model))),
         }
     }
 
+    async fn run_object(&mut self, block: &ObjectBlock, context: Context) -> Interpretation {
+        let mut messages = vec![];
+        let mut result_map = Map::new();
+        let mut trace_map = HashMap::new();
+        let mut iter = block.object.iter();
+        while let Some((k, v)) = iter.next() {
+            let (this_result, this_messages, this_trace) =
+                self.run_quiet(v, context.clone()).await?;
+            messages.extend(this_messages);
+            result_map.insert(k.clone(), this_result);
+            trace_map.insert(k.clone(), this_trace);
+        }
+
+        if self.debug {
+            eprintln!("Object {:?}", result_map);
+        }
+        Ok((
+            Value::Object(result_map),
+            messages,
+            PdlBlock::Object(ObjectBlock { object: trace_map }),
+        ))
+    }
+
     /// Run a PdlBlock::Repeat
     async fn run_repeat(&mut self, block: &RepeatBlock, context: Context) -> Interpretation {
         // { i:[1,2,3], j: [4,5,6]} -> ([i,j], [[1,2,3],[4,5,6]])
@@ -515,6 +563,7 @@ impl<'a> Interpreter<'a> {
             eprintln!("Repeat {:?}", map);
         }
 
+        let mut results = vec![];
         let mut messages = vec![];
         let mut trace = vec![];
         if let Some(n) = map.iter().map(|(_, v)| v.len()).min() {
@@ -524,14 +573,19 @@ impl<'a> Interpreter<'a> {
                     .map(|(k, v)| (k.clone(), v[iter].clone()))
                     .collect();
                 self.extend_scope_with_map(scope);
-                let (ms, t) = self.run_quiet(&block.repeat, context.clone()).await?;
+                let (result, ms, t) = self.run_quiet(&block.repeat, context.clone()).await?;
+                results.push(result);
                 messages.extend(ms);
                 trace.push(t);
                 self.scope.pop();
             }
         }
 
-        Ok((messages, PdlBlock::Repeat(block.clone())))
+        Ok((
+            Value::Array(results),
+            messages,
+            PdlBlock::Repeat(block.clone()),
+        ))
     }
 
     fn to_ollama_role(&self, role: &Role) -> MessageRole {
@@ -545,8 +599,8 @@ impl<'a> Interpreter<'a> {
 
     fn parse_result(&self, parser: &PdlParser, result: &String) -> Result<Value, PdlError> {
         match parser {
-            PdlParser::Json => Ok(from_str(result)?),
-            PdlParser::Yaml => Ok(from_yaml_str(result)?),
+            PdlParser::Json => from_str(result).map_err(|e| Box::from(e)),
+            PdlParser::Yaml => from_yaml_str(result).map_err(|e| Box::from(e)),
         }
     }
 
@@ -561,24 +615,31 @@ impl<'a> Interpreter<'a> {
         self.extend_scope_with_map(scope);
     }
 
-    fn extend_scope_with_block_map(&mut self, map: &Option<HashMap<String, PdlBlock>>) {
+    async fn extend_scope_with_block_map(
+        &mut self,
+        map: &Option<HashMap<String, PdlBlock>>,
+    ) -> Result<(), PdlError> {
         let cur_scope = self.scope.last().unwrap_or(&HashMap::new()).clone();
         let new_scope = match map {
             Some(defs) => {
                 // this is all non-optimal
                 let mut scope: Scope = HashMap::from(cur_scope);
-                scope.extend(defs.iter().map(|(var, def)| {
-                    (
+                let mut iter = defs.iter();
+                while let Some((var, def)) = iter.next() {
+                    let (result, _, _) = self.run_quiet(def, vec![]).await?;
+                    scope.insert(
                         var.clone(),
-                        from_str(to_string(def).unwrap().as_str()).unwrap(),
-                    )
-                }));
+                        result,
+                        //from_str(to_string(&block).unwrap().as_str()).unwrap(),
+                    );
+                }
                 scope
             }
             None => cur_scope,
         };
 
         self.extend_scope_with_map(new_scope);
+        Ok(())
     }
 
     /// Run a PdlBlock::Text
@@ -594,15 +655,20 @@ impl<'a> Interpreter<'a> {
         }
 
         let mut input_messages = context.clone();
+        let mut output_results = vec![];
         let mut output_messages = vec![];
         let mut output_blocks = vec![];
 
-        self.extend_scope_with_block_map(&block.defs);
+        self.extend_scope_with_block_map(&block.defs).await?;
+        eprintln!("Scope {:?}", self.scope.last());
+
         let mut iter = block.text.iter();
         while let Some(block) = iter.next() {
             // run each element of the Text block
-            let (this_messages, trace) = self.run(&block, input_messages.clone()).await?;
+            let (this_result, this_messages, trace) =
+                self.run(&block, input_messages.clone()).await?;
             input_messages.extend(this_messages.clone());
+            output_results.push(this_result);
             output_messages.extend(this_messages);
             output_blocks.push(trace);
         }
@@ -611,28 +677,24 @@ impl<'a> Interpreter<'a> {
         let mut trace = block.clone();
         trace.text = output_blocks;
 
-        let result_string = output_messages
-            .iter()
-            .map(|m| m.content.clone())
+        let result_string = output_results
+            .into_iter()
+            .map(|m| match m {
+                Value::String(s) => s,
+                x => x.to_string(),
+            })
             .collect::<Vec<_>>()
             .join("\n");
 
-        if let Some(def) = &block.def {
-            let result = if let Some(parser) = &block.parser {
-                self.parse_result(parser, &result_string)?
-            } else {
-                Value::from(result_string.clone()) // TODO
-            };
-
-            if let Some(scope) = self.scope.last_mut() {
-                if self.debug {
-                    eprintln!("Def {} -> {}", def, result);
-                }
-                scope.insert(def.clone(), result);
-            }
-        }
+        // FIXME, use output_results
+        let result = self.def(
+            &block.def,
+            &Value::String(result_string.clone()),
+            &block.parser,
+        )?;
 
         Ok((
+            result,
             match &block.role {
                 Some(role) => vec![ChatMessage::new(self.to_ollama_role(role), result_string)],
                 None => output_messages,