strip nulls

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

Author: starpit

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

@@ -8,7 +8,7 @@ use ::std::path::{Path, PathBuf};
 use duct::cmd;
 use futures::executor::block_on;
 use serde::Deserialize;
-use serde_json::{from_reader, json, to_string, Value};
+use serde_json::{from_reader, json, to_string, Map, Value};
 use tempfile::Builder;
 
 use crate::pdl::ast::{
@@ -137,23 +137,46 @@ fn a_tool(tool: &BeeAiToolState) -> Value {
             "description": tool.description,
             "parameters": json!({
                 "type": "object",
-                "properties": tool.input_schema.properties,
+                "properties": strip_nulls(&tool.input_schema.properties),
             }),
-            "options": tool.options
+            // "options": tool.options
         })
     })
 }
 
+// Strip null values out of the given HashMap
+fn strip_nulls(parameters: &HashMap<String, Value>) -> HashMap<String, Value> {
+    parameters
+        .into_iter()
+        .filter_map(|(k, v)| match v {
+            Value::Null => None,
+            Value::Object(m) => Some((k.clone(), Value::Object(strip_nulls2(m)))),
+            _ => Some((k.clone(), v.clone())),
+        })
+        .collect()
+}
+// sigh, i need to figure out generics IntoIterator, FromIterator
+fn strip_nulls2(parameters: &Map<String, Value>) -> Map<String, Value> {
+    parameters
+        .into_iter()
+        .filter_map(|(k, v)| match v {
+            Value::Null => None,
+            Value::Object(m) => Some((k.clone(), Value::Object(strip_nulls2(&m)))),
+            _ => Some((k.clone(), v.clone())),
+        })
+        .collect()
+}
+
 fn with_tools(
     tools: &Option<Vec<BeeAiTool>>,
     parameters: &HashMap<String, Value>,
 ) -> HashMap<String, Value> {
     match tools {
         Some(tools) => {
             match tools.len() {
-                0 => parameters.clone(), // litellm barfs on tools: []
+                0 => strip_nulls(parameters), // Note: litellm barfs on tools: []
                 _ => {
-                    let mut copy = parameters.clone();
+                    let mut copy = strip_nulls(parameters);
                     copy.insert(
                         "tools".to_string(),
                         tools.into_iter().map(|tool| a_tool(&tool.state)).collect(),
@@ -162,7 +185,7 @@ fn with_tools(
                 }
             }
         }
-        _ => parameters.clone(),
+        _ => strip_nulls(parameters),
     }
 }
 
@@ -175,7 +198,7 @@ fn call_tools(model: &String, parameters: &HashMap<String, Value>) -> PdlBlock {
         description: Some("Calling tool ${ tool.function.name }".to_string()),
         text: vec![PdlBlock::Model(
             PdlModelBlock::new(model.as_str())
-                .parameters(parameters)
+                .parameters(&strip_nulls(parameters))
                 .input(PdlBlock::Array {
                     array: vec![PdlBlock::Message(PdlMessageBlock {
                         role: Role::Tool,
@@ -239,7 +262,10 @@ fn json_schema_type_to_pdl_type(spec: &Value) -> PdlType {
                 "boolean" => PdlBaseType::Bool,
                 "integer" => PdlBaseType::Int,
                 "null" => PdlBaseType::Null,
-                _ => PdlBaseType::Null,
+                x => {
+                    eprintln!("Warning: unhandled JSONSchema type mapping to PDL {:?}", x);
+                    PdlBaseType::Null
+                }
             };
             match spec.get("default") {
                 Some(_) => PdlType::Optional(PdlOptionalType { optional: base }),
@@ -258,10 +284,16 @@ fn json_schema_type_to_pdl_type(spec: &Value) -> PdlType {
                             optional: t.clone(),
                         })
                     }
-                    _ => PdlType::Base(PdlBaseType::Null),
+                    x => {
+                        eprintln!("Warning: unhandled JSONSchema type mapping to PDL {:?}", x);
+                        PdlType::Base(PdlBaseType::Null)
+                    }
                 }
             }
-            _ => PdlType::Base(PdlBaseType::Null),
+            x => {
+                eprintln!("Warning: unhandled JSONSchema type mapping to PDL {:?}", x);
+                PdlType::Base(PdlBaseType::Null)
+            }
         },
     }
 }

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

@@ -3,11 +3,15 @@ use serde::{Deserialize, Serialize};
 use serde_json::{Number, Value};
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
-#[serde(rename_all_fields = "lowercase")]
+//why doesn't this work? #[serde(rename_all_fields(serialize = "lowercase"))]
 pub enum Role {
+    #[serde(rename = "user")]
     User,
+    #[serde(rename = "assistant")]
     Assistant,
+    #[serde(rename = "system")]
     System,
+    #[serde(rename = "tool")]
     Tool,
 }
 
@@ -139,6 +143,7 @@ pub struct PdlUsage {
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct PdlModelBlock {
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub description: Option<String>,
     pub model: String,
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -147,6 +152,7 @@ pub struct PdlModelBlock {
     pub parameters: Option<HashMap<String, Value>>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub input: Option<Box<PdlBlock>>, // really this should be restricted to be PdlBlock::Array; how do we do this in rust?
+    #[serde(skip_serializing_if = "Option::is_none")]
     #[serde(rename = "modelResponse")]
     pub model_response: Option<String>,
     #[serde(rename = "pdl__result")]

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

@@ -118,9 +118,10 @@ impl<'a> Interpreter<'a> {
         }
 
         let backup = result.clone();
-        Ok(from_str(&result).unwrap_or_else(|_err| {
+        Ok(from_str(&result).unwrap_or_else(|err| {
             if self.debug {
-                eprintln!("Plain string {}", &result);
+                eprintln!("Treating as plain string {}", &result);
+                eprintln!("... due to {}", err);
             }
             backup.into()
         }))
@@ -171,7 +172,7 @@ impl<'a> Interpreter<'a> {
 
         let res = match self.eval::<PdlBlock>(&block.call)? {
             PdlBlock::Function(f) => self.run(&f.return_, context.clone()),
-            _ => Err(Box::from("call of non-function")),
+            _ => Err(Box::from(format!("call of non-function {:?}", &block.call))),
         };
         self.scope.pop();
 
@@ -242,14 +243,14 @@ impl<'a> Interpreter<'a> {
                     vm::compiler::Mode::Exec,
                     "<embedded>".to_owned(),
                 )
-                .map_err(|err| {
+                .map_err(|_err| {
                     panic!("Syntax error in Python code");
                 })
                 .unwrap();
 
             let _output = vm
                 .run_code_obj(code_obj, scope.clone())
-                .map_err(|err| {
+                .map_err(|_err| {
                     // TODO vm.print_exception(exc);
                     println!("Error executing Python code");
                 })