@1kbirds/chidori 0.1.16 → 0.1.20

package/Cargo.toml

@@ -53,6 +53,8 @@ pyo3-log = { version = "0.8.2", optional = true }
 
 neon-serde3 = "0.10.0"
 
+tracing = "0.1"
+
 [dependencies.prompt-graph-exec]
 path = "../prompt-graph-exec"
 version = "0.1.0"

package/README.md

@@ -0,0 +1,7 @@
+# Chidori
+
+## Generating Python Client
+- maturin develop --features python
+
+## Generating Nodejs Client
+- npm run build-release

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@1kbirds/chidori",
-  "version": "v0.1.16",
-  "description": "Prompt Graph SDK",
+  "version": "v0.1.20",
+  "description": "Chidori is a library for building and running reactive AI agents.",
   "main": "package_node/index.js",
   "scripts": {
     "build": "cargo-cp-artifact -nc ./package_node/native/chidori.node -- cargo build --message-format=json-render-diagnostics --features nodejs",

package/package_python/test_chidori.py

@@ -29,5 +29,7 @@ async def test_simple_agent():
     )
     await client.play(0, 0)
     await pn.query(0, 100)
+    assert 1 == 1
+
 
 

package/src/translations/nodejs.rs

@@ -788,20 +788,6 @@ impl Chidori {
 //     // TODO: nodes that are added should return a clean definition of what their addition looks like
 //     // TODO: adding a node should also display any errors
 
-    fn obj_interface(mut cx: FunctionContext) -> JsResult<JsValue> {
-        let arg0 = cx.argument::<JsValue>(0)?;
-        let arg0_value: ExecutionStatus = match neon_serde3::from_value(&mut cx, arg0) {
-            Ok(value) => value,
-            Err(e) => {
-                return cx.throw_error(e.to_string());
-            }
-        };
-        println!("{:?}", &arg0_value);
-
-        neon_serde3::to_value(&mut cx, &arg0_value)
-            .or_else(|e| cx.throw_error(e.to_string()))
-    }
-
 
     fn prompt_node(mut cx: FunctionContext) -> JsResult<JsPromise> {
         let channel = cx.channel();
@@ -1227,7 +1213,6 @@ fn main(mut cx: ModuleContext) -> NeonResult<()> {
     cx.export_function("chidoriBranch", Chidori::branch)?;
     cx.export_function("chidoriQuery", Chidori::query)?;
     cx.export_function("chidoriGraphStructure", Chidori::display_graph_structure)?;
-    cx.export_function("chidoriObjInterface", Chidori::obj_interface)?;
     cx.export_function("chidoriCustomNode", Chidori::custom_node)?;
     cx.export_function("chidoriDenoCodeNode", Chidori::deno_code_node)?;
     cx.export_function("chidoriVectorMemoryNode", Chidori::vector_memory_node)?;

package/src/translations/python.rs

@@ -22,12 +22,6 @@ use ::prompt_graph_core::graph_definition::{create_prompt_node, create_op_map, c
 use ::prompt_graph_core::utils::wasm_error::CoreError;
 use ::prompt_graph_core::build_runtime_graph::graph_parse::{CleanedDefinitionGraph, CleanIndividualNode, construct_query_from_output_type, derive_for_individual_node};
 
-// https://pyo3.rs/v0.19.0/
-
-// https://chat.openai.com/c/4dfe5b29-0cd9-493f-be8f-9362d376e764
-
-// TODO: create worker object
-
 #[derive(Debug)]
 pub struct CoreErrorWrapper(CoreError);
 
@@ -43,6 +37,13 @@ impl std::convert::From<CoreError> for PyErrWrapper {
     }
 }
 
+impl std::convert::From<anyhow::Error> for PyErrWrapper {
+    fn from(err: anyhow::Error) -> PyErrWrapper {
+        PyErrWrapper(exceptions::PyOSError::new_err(err.to_string()))
+    }
+}
+
+
 #[derive(Debug)]
 pub struct PyErrWrapper(pyo3::PyErr);
 
@@ -869,7 +870,7 @@ impl Chidori {
         })
     }
 
-    #[pyo3(signature = (name=String::new(), queries=vec![None], output_tables=vec![], output=String::from("type O { }"), code=String::new(), is_template=false))]
+    #[pyo3(signature = (name=String::new(), queries=vec![None], output_tables=vec![], output=String::from("type O { output: String }"), code=String::new(), is_template=false))]
     fn deno_code_node<'a>(
         mut self_: PyRefMut<'_, Self>,
         py: Python<'a>,

package/src/translations/rust.rs

@@ -1,177 +1,508 @@
+use std::cell::RefCell;
+use std::collections::{HashMap, VecDeque};
+use std::hash::Hash;
+use std::marker::PhantomData;
+use anyhow::Error;
+use futures::StreamExt;
+use log::{debug, info};
+use once_cell::sync::OnceCell;
+use tokio::runtime::Runtime;
+use prompt_graph_core::build_runtime_graph::graph_parse::{CleanedDefinitionGraph, CleanIndividualNode, construct_query_from_output_type, derive_for_individual_node};
+use prompt_graph_core::graph_definition::{create_code_node, create_custom_node, create_prompt_node, create_vector_memory_node, SourceNodeType};
+use prompt_graph_core::proto2::{ChangeValue, ChangeValueWithCounter, Empty, ExecutionStatus, File, FileAddressedChangeValueWithCounter, FilteredPollNodeWillExecuteEventsRequest, Item, ListBranchesRes, Path, Query, QueryAtFrame, QueryAtFrameResponse, RequestAckNodeWillExecuteEvent, RequestAtFrame, RequestFileMerge, RequestListBranches, RequestNewBranch, RequestOnlyId, RespondPollNodeWillExecuteEvents, SerializedValue, SerializedValueArray, SerializedValueObject};
+use prompt_graph_core::proto2::execution_runtime_client::ExecutionRuntimeClient;
+use prompt_graph_core::proto2::serialized_value::Val;
+use prompt_graph_exec::tonic_runtime::run_server;
+use neon_serde3;
+use serde::{Deserialize, Serialize};
+use tonic::Status;
 
-use anyhow::Result;
+async fn get_client(url: String) -> Result<ExecutionRuntimeClient<tonic::transport::Channel>, tonic::transport::Error> {
+    ExecutionRuntimeClient::connect(url.clone()).await
+}
 
-use prompt_graph_core::graph_definition::DefinitionGraph;
-use prompt_graph_core::build_runtime_graph::graph_parse::CleanedDefinitionGraph;
-use prompt_graph_core::proto2::execution_runtime_client::ExecutionRuntimeClient;
-use prompt_graph_core::proto2::RequestFileMerge;
+struct Chidori {
+    file_id: String,
+    current_head: u64,
+    current_branch: u64,
+    url: String
+}
 
+impl Chidori {
 
-// TODO: need to define pattern for automatically wiring dependencies
-// TODO: add methods
-// create_entrypoint_query
+    fn new(file_id: String, url: String) -> Self {
+        if !url.contains("://") {
+            panic!("Invalid url, must include protocol");
+        }
+        // let api_token = cx.argument_opt(2)?.value(&mut cx);
+        debug!("Creating new Chidori instance with file_id={}, url={}, api_token={:?}", file_id, url, "".to_string());
+        Chidori {
+            file_id,
+            current_head: 0,
+            current_branch: 0,
+            url,
+        }
+    }
 
-pub fn new_graph() -> DefinitionGraph {
-    DefinitionGraph::zero()
-}
+    async fn start_server(&self, file_path: Option<String>) -> anyhow::Result<()> {
+        let url_server = self.url.clone();
+        std::thread::spawn(move || {
+            let result = run_server(url_server, file_path);
+            match result {
+                Ok(_) => {
+                    println!("Server exited");
+                },
+                Err(e) => {
+                    println!("Error running server: {}", e);
+                },
+            }
+        });
 
-#[macro_export]
-macro_rules! register_all {
-    ($graph:expr, $($statement:expr,)*) => {
-        $( $graph.register_node($statement); )*
-    };
+        let url = self.url.clone();
+        loop {
+            match get_client(url.clone()).await {
+                Ok(connection) => {
+                    eprintln!("Connection successfully established {:?}", &url);
+                    return Ok(());
+                },
+                Err(e) => {
+                    eprintln!("Error connecting to server: {} with Error {}. Retrying...", &url, &e.to_string());
+                    std::thread::sleep(std::time::Duration::from_millis(1000));
+                }
+            }
+        }
+    }
+
+    async fn play(&self, branch: u64, frame: u64) -> anyhow::Result<ExecutionStatus> {
+        let file_id = self.file_id.clone();
+        let url = self.url.clone();
+        let mut client = get_client(url).await?;
+        let result = client.play(RequestAtFrame {
+            id: file_id,
+            frame,
+            branch,
+        }).await?;
+        Ok(result.into_inner())
+    }
+
+    async fn pause(&self, frame: u64) -> anyhow::Result<ExecutionStatus> {
+        let file_id = self.file_id.clone();
+        let url = self.url.clone();
+        let branch = self.current_branch.clone();
+
+        let mut client = get_client(url).await?;
+        let result = client.pause(RequestAtFrame {
+            id: file_id,
+            frame,
+            branch,
+        }).await?;
+        Ok(result.into_inner())
+    }
+
+    async fn query( &self, query: String, branch: u64, frame: u64, ) -> anyhow::Result<QueryAtFrameResponse> {
+        let file_id = self.file_id.clone();
+        let url = self.url.clone();
+        let mut client = get_client(url).await?;
+        let result = client.run_query(QueryAtFrame {
+            id: file_id,
+            query: Some(Query {
+                query: Some(query)
+            }),
+            frame,
+            branch,
+        }).await?;
+        Ok(result.into_inner())
+    }
+
+    async fn list_branches( &self) -> anyhow::Result<ListBranchesRes> {
+        let file_id = self.file_id.clone();
+        let url = self.url.clone();
+        let mut client = get_client(url).await?;
+        let result = client.list_branches(RequestListBranches {
+            id: file_id,
+        }).await?;
+        Ok(result.into_inner())
+    }
+
+    async fn display_graph_structure( &self, query: String, branch: u64, frame: u64, ) -> anyhow::Result<String> {
+        let file_id = self.file_id.clone();
+        let url = self.url.clone();
+        let mut client = get_client(url).await?;
+        let file = client.current_file_state(RequestOnlyId {
+            id: file_id,
+            branch
+        }).await?;
+        let mut file = file.into_inner();
+        let mut g = CleanedDefinitionGraph::zero();
+        g.merge_file(&mut file).unwrap();
+        Ok(g.get_dot_graph())
+    }
+
+    async fn list_registered_graphs(&self) -> anyhow::Result<()> {
+        let file_id = self.file_id.clone();
+        let url = self.url.clone();
+        let mut client = get_client(url).await?;
+        let resp = client.list_registered_graphs(Empty { }).await?;
+        let mut stream = resp.into_inner();
+        while let Some(x) = stream.next().await {
+            // callback.call(py, (x,), None);
+            info!("Registered Graph = {:?}", x);
+        };
+        Ok(())
+    }
+
+//
+//     // TODO: need to figure out how to handle callbacks
+//     // fn list_input_proposals<'a>(
+//     //     mut self_: PyRefMut<'_, Self>,
+//     //     py: Python<'a>,
+//     //     callback: PyObject
+//     // ) -> PyResult<&'a PyAny> {
+//     //     let file_id = self_.file_id.clone();
+//     //     let url = self_.url.clone();
+//     //     let branch = self_.current_branch;
+//     //     pyo3_asyncio::tokio::future_into_py(py, async move {
+//     //         let mut client = get_client(url).await?;
+//     //         let resp = client.list_input_proposals(RequestOnlyId {
+//     //             id: file_id,
+//     //             branch,
+//     //         }).await.map_err(PyErrWrapper::from)?;
+//     //         let mut stream = resp.into_inner();
+//     //         while let Some(x) = stream.next().await {
+//     //             // callback.call(py, (x,), None);
+//     //             info!("InputProposals = {:?}", x);
+//     //         };
+//     //         Ok(())
+//     //     })
+//     // }
+//
+//     // fn respond_to_input_proposal(mut self_: PyRefMut<'_, Self>) -> PyResult<()> {
+//     //     Ok(())
+//     // }
+//
+//     // TODO: need to figure out how to handle callbacks
+//     // fn list_change_events<'a>(
+//     //     mut self_: PyRefMut<'_, Self>,
+//     //     py: Python<'a>,
+//     //     callback: PyObject
+//     // ) -> PyResult<&'a PyAny> {
+//     //     let file_id = self_.file_id.clone();
+//     //     let url = self_.url.clone();
+//     //     let branch = self_.current_branch;
+//     //     pyo3_asyncio::tokio::future_into_py(py, async move {
+//     //         let mut client = get_client(url).await?;
+//     //         let resp = client.list_change_events(RequestOnlyId {
+//     //             id: file_id,
+//     //             branch,
+//     //         }).await.map_err(PyErrWrapper::from)?;
+//     //         let mut stream = resp.into_inner();
+//     //         while let Some(x) = stream.next().await {
+//     //             Python::with_gil(|py| pyo3_asyncio::tokio::into_future(callback.as_ref(py).call((x.map(ChangeValueWithCounterWrapper).map_err(PyErrWrapper::from)?,), None)?))?
+//     //                 .await?;
+//     //         };
+//     //         Ok(())
+//     //     })
+//     // }
+//
+//
+//
+//     // TODO: this should accept an "Object" instead of args
+//     // TODO: nodes that are added should return a clean definition of what their addition looks like
+//     // TODO: adding a node should also display any errors
+
+
+    async fn poll_local_code_node_execution(&self) -> anyhow::Result<RespondPollNodeWillExecuteEvents> {
+        let file_id = self.file_id.clone();
+        let url = self.url.clone();
+        let mut client = get_client(url).await?;
+        let req = FilteredPollNodeWillExecuteEventsRequest { id: file_id.clone() };
+        let result = client.poll_node_will_execute_events(req).await?;
+        Ok(result.into_inner())
+    }
+
+    async fn ack_local_code_node_execution(&self, branch: u64, counter : u64) -> anyhow::Result<ExecutionStatus> {
+        let file_id = self.file_id.clone();
+        let url = self.url.clone();
+        let mut client = get_client(url).await?;
+        let result = client.ack_node_will_execute_event(RequestAckNodeWillExecuteEvent {
+            id: file_id.clone(),
+            branch,
+            counter,
+        }).await?;
+        Ok(result.into_inner())
+    }
+
+    async fn respond_local_code_node_execution(&self, branch: u64, counter: u64, node_name: String, response: Vec<ChangeValue>) -> anyhow::Result<ExecutionStatus> {
+        let file_id = self.file_id.clone();
+        let url = self.url.clone();
+
+        // TODO: need parent counters from the original change
+        // TODO: need source node
+        let mut client = get_client(url).await?;
+
+        // TODO: need to add the output table paths to these
+        // TODO: this needs to look more like a real change
+        Ok(client.push_worker_event(FileAddressedChangeValueWithCounter {
+            branch,
+            counter,
+            node_name,
+            id: file_id.clone(),
+            change: Some(ChangeValueWithCounter {
+                filled_values: response,
+                parent_monotonic_counters: vec![],
+                monotonic_counter: counter,
+                branch,
+                source_node: "".to_string(),
+            })
+        }).await?.into_inner())
+    }
 }
 
-#[macro_export]
-macro_rules! parameter {
-    ($output_def:expr) => {
-        create_node_parameter(
-            format!("{}:{}", file!(), line!()),
-            String::from($output_def)
-        )
-    };
-    ($name:expr, $output_def:expr) => {
-        create_node_parameter(
-            String::from($name),
-            String::from($output_def)
-        )
-    };
+
+#[derive(serde::Serialize, serde::Deserialize)]
+struct PromptNodeCreateOpts {
+    name: String,
+    queries: Option<Vec<String>>,
+    output_tables: Option<Vec<String>>,
+    template: String,
+    model: Option<String>
 }
 
-#[macro_export]
-macro_rules! map {
-    ($query_def:expr, $path:expr) => {
-        create_op_map(
-            format!("{}:{}", file!(), line!()),
-            String::from($query_def),
-            String::from($path),
-        )
-    };
-    ($name:expr, $query_def:expr, $path:expr) => {
-        create_code_node(
-            String::from($name),
-            String::from($query_def),
-            String::from($path),
-        )
-    };
+
+#[derive(serde::Serialize, serde::Deserialize)]
+struct CustomNodeCreateOpts {
+    name: String,
+    queries: Option<Vec<String>>,
+    output_tables: Option<Vec<String>>,
+    output: Option<String>,
+    node_type_name: String
 }
 
+#[derive(serde::Serialize, serde::Deserialize)]
+struct DenoCodeNodeCreateOpts {
+    name: String,
+    queries: Option<Vec<String>>,
+    output_tables: Option<Vec<String>>,
+    output: Option<String>,
+    code: String,
+    is_template: Option<bool>
+}
 
-#[macro_export]
-macro_rules! code_node {
-    ($query_def:expr, $output_def:expr, $source_type:expr) => {
-        create_code_node(
-            format!("{}:{}", file!(), line!()),
-            String::from($query_def),
-            String::from($output_def),
-            $source_type,
-        )
-    };
-    ($name:expr, $query_def:expr, $output_def:expr, $source_type:expr) => {
-        create_code_node(
-            String::from($name),
-            String::from($query_def),
-            String::from($output_def),
-            String::from($source_type),
-        )
-    };
+#[derive(serde::Serialize, serde::Deserialize)]
+struct VectorMemoryNodeCreateOpts {
+    name: String,
+    queries: Option<Vec<String>>,
+    output_tables: Option<Vec<String>>,
+    output: Option<String>,
+    template: Option<String>, // TODO: default is the contents of the query
+    action: Option<String>, // TODO: default WRITE
+    embedding_model: Option<String>, // TODO: default TEXT_EMBEDDING_ADA_002
+    db_vendor: Option<String>, // TODO: default QDRANT
+    collection_name: String,
 }
 
 
-#[macro_export]
-macro_rules! observation_node {
-    ($query_def:expr, $output_def:expr) => {
-        create_observation_node(
-            format!("{}:{}", file!(), line!()),
-            String::from($query_def),
-            String::from($output_def),
-        )
-    };
-    ($name:expr, $query_def:expr, $output_def:expr) => {
-        create_observation_node(
-            String::from($name),
-            String::from($query_def),
-            String::from($output_def),
-        )
+fn remap_queries(queries: Option<Vec<String>>) -> Vec<Option<String>> {
+    let queries: Vec<Option<String>> = if let Some(queries) = queries {
+        queries.into_iter().map(|q| {
+            if q == "None".to_string() {
+                None
+            } else {
+                Some(q)
+            }
+        }).collect()
+    } else {
+        vec![]
     };
+    queries
 }
 
+struct GraphBuilder {
+    clean_graph: CleanedDefinitionGraph,
+}
 
-#[macro_export]
-macro_rules! memory_node {
-    ($query_def:expr, $output_def:expr, $model:expr, $db:expr) => {
-        create_vector_memory_node(
-            format!("{}:{}", file!(), line!()),
-            String::from($query_def),
-            String::from($output_def),
-            String::from($model),
-            String::from($db)
-        )
-    };
-    ($name:expr, $query_def:expr, $output_def:expr, $model:expr, $db:expr) => {
-        create_vector_memory_node(
-            String::from($name),
-            String::from($query_def),
-            String::from($output_def),
-            String::from($model),
-            String::from($db)
-        )
-    };
+impl GraphBuilder {
+    fn prompt_node(&mut self, arg: PromptNodeCreateOpts) -> anyhow::Result<NodeHandle> {
+        let node = create_prompt_node(
+            arg.name,
+            remap_queries(arg.queries),
+            arg.template,
+            arg.model.unwrap_or("GPT_3_5_TURBO".to_string()),
+            arg.output_tables.unwrap_or(vec![]))?;
+        self.clean_graph.merge_file(&File { nodes: vec![node.clone()], ..Default::default() })?;
+        Ok(NodeHandle::from(node)?)
+    }
+
+    fn custom_node(&mut self, arg: CustomNodeCreateOpts) -> anyhow::Result<NodeHandle> {
+        let node = create_custom_node(
+            arg.name,
+            remap_queries(arg.queries.clone()),
+            arg.output.unwrap_or("type O {}".to_string()),
+            arg.node_type_name,
+            arg.output_tables.unwrap_or(vec![])
+        );
+        self.clean_graph.merge_file(&File { nodes: vec![node.clone()], ..Default::default() })?;
+        Ok(NodeHandle::from(node)?)
+    }
+
+
+    fn deno_code_node(&mut self, arg: DenoCodeNodeCreateOpts) -> anyhow::Result<NodeHandle> {
+        let node = create_code_node(
+            arg.name,
+            remap_queries(arg.queries.clone()),
+            arg.output.unwrap_or("type O {}".to_string()),
+            SourceNodeType::Code("DENO".to_string(), arg.code, arg.is_template.unwrap_or(false)),
+            arg.output_tables.unwrap_or(vec![])
+        );
+        self.clean_graph.merge_file(&File { nodes: vec![node.clone()], ..Default::default() })?;
+        Ok(NodeHandle::from(node)?)
+    }
+
+
+    fn vector_memory_node(&mut self, arg: VectorMemoryNodeCreateOpts) -> anyhow::Result<NodeHandle> {
+        let node = create_vector_memory_node(
+            arg.name,
+            remap_queries(arg.queries.clone()),
+            arg.output.unwrap_or("type O {}".to_string()),
+            arg.action.unwrap_or("READ".to_string()),
+            arg.embedding_model.unwrap_or("TEXT_EMBEDDING_ADA_002".to_string()),
+            arg.template.unwrap_or("".to_string()),
+            arg.db_vendor.unwrap_or("QDRANT".to_string()),
+            arg.collection_name,
+            arg.output_tables.unwrap_or(vec![])
+        )?;
+        self.clean_graph.merge_file(&File { nodes: vec![node.clone()], ..Default::default() })?;
+        Ok(NodeHandle::from(node)?)
+    }
+//
+//
+//     //
+//     // fn observation_node(mut self_: PyRefMut<'_, Self>, name: String, query_def: Option<String>, template: String, model: String) -> PyResult<()> {
+//     //     let file_id = self_.file_id.clone();
+//     //     let node = create_observation_node(
+//     //         "".to_string(),
+//     //         None,
+//     //         "".to_string(),
+//     //     );
+//     //     executor::block_on(self_.client.merge(RequestFileMerge {
+//     //         id: file_id,
+//     //         file: Some(File {
+//     //             nodes: vec![node],
+//     //             ..Default::default()
+//     //         }),
+//     //         branch: 0,
+//     //     }));
+//     //     Ok(())
+//     // }
+
+    //     // TODO: need to figure out passing a buffer of bytes
+//     // TODO: nodes that are added should return a clean definition of what their addition looks like
+//     // TODO: adding a node should also display any errors
+//     /// x = None
+//     /// with open("/Users/coltonpierson/Downloads/files_and_dirs.zip", "rb") as zip_file:
+//     ///     contents = zip_file.read()
+//     ///     x = await p.load_zip_file("LoadZip", """ output: String """, contents)
+//     /// x
+//     // #[pyo3(signature = (name=String::new(), output_tables=vec![], output=String::new(), bytes=vec![]))]
+//     // fn load_zip_file<'a>(
+//     //     mut self_: PyRefMut<'_, Self>,
+//     //     py: Python<'a>,
+//     //     name: String,
+//     //     output_tables: Vec<String>,
+//     //     output: String,
+//     //     bytes: Vec<u8>
+//     // ) -> PyResult<&'a PyAny> {
+//     //     let file_id = self_.file_id.clone();
+//     //     let url = self_.url.clone();
+//     //     pyo3_asyncio::tokio::future_into_py(py, async move {
+//     //         let node = create_loader_node(
+//     //             name,
+//     //             vec![],
+//     //             output,
+//     //             LoadFrom::ZipfileBytes(bytes),
+//     //             output_tables
+//     //         );
+//     //         Ok(push_file_merge(&url, &file_id, node).await?)
+//     //     })
+//     // }
+
+    async fn commit(&self, file_id: String, url: String, branch: u64) -> anyhow::Result<ExecutionStatus> {
+        let mut client = get_client(url.clone()).await?;
+        let nodes = self.clean_graph.node_by_name.clone().into_values().collect();
+        Ok(client.merge(RequestFileMerge {
+            id: file_id.clone(),
+            file: Some(File { nodes, ..Default::default() }),
+            branch: 0,
+        }).await.map(|x| x.into_inner())?)
+    }
 }
 
-#[macro_export]
-macro_rules! component_node {
-    ($query_def:expr, $output_def:expr) => {
-        create_component_node(
-            format!("{}:{}", file!(), line!()),
-            String::from($query_def),
-            String::from($output_def),
-        )
-    };
-    ($name:expr, $query_def:expr, $output_def:expr) => {
-        create_component_node(
-            String::from($name),
-            String::from($query_def),
-            String::from($output_def),
-        )
-    };
+
+// Node handle
+#[derive(Clone)]
+pub struct NodeHandle {
+    node: Item,
+    indiv: CleanIndividualNode
 }
 
-#[macro_export]
-macro_rules! prompt_node {
-    ($query_def:expr, $template:expr, $model:expr) => {
-        create_prompt_node(
-            format!("{}:{}", file!(), line!()),
-            String::from($query_def),
-            String::from($template),
-            String::from($model),
-        )
-    };
-    ($name:expr, $query_def:expr, $template:expr, $model:expr) => {
-        create_prompt_node(
-            String::from($name),
-            String::from($query_def),
-            String::from($template),
-            String::from($model),
-        )
-    };
+impl NodeHandle {
+    fn from(node: Item) -> anyhow::Result<NodeHandle> {
+        let indiv = derive_for_individual_node(&node)?;
+        Ok(NodeHandle {
+            node,
+            indiv
+        })
+    }
 }
 
-pub async fn run_worker(url: String, graph: DefinitionGraph) -> Result<()> {
-    // validate the graph
-    CleanedDefinitionGraph::new(&graph);
-    let file_merge = RequestFileMerge{ file: Some(graph.get_file().clone()), branch: 0, id: "".to_string() };
-    let mut client = ExecutionRuntimeClient::connect(url).await?;
-    let _response = client.merge(file_merge).await?.into_inner();
-    Ok(())
+
+impl NodeHandle {
+    fn get_name(&self) -> String {
+        self.node.core.as_ref().unwrap().name.clone()
+    }
+
+    pub fn run_when(&mut self, other_node: &NodeHandle) -> anyhow::Result<bool> {
+        let queries = &mut self.node.core.as_mut().unwrap().queries;
+        let q = construct_query_from_output_type(
+            &other_node.get_name(),
+            &other_node.get_name(),
+            &self.indiv.output_path
+        ).unwrap();
+        queries.push(Query { query: Some(q)});
+        Ok(true)
+    }
+
+
+    pub async fn query(&self, file_id: String, url: String, branch: u64, frame: u64) -> anyhow::Result<HashMap<String, SerializedValue>> {
+        let name = &self.node.core.as_ref().unwrap().name;
+        let query = construct_query_from_output_type(&name, &name, &self.indiv.output_path).unwrap();
+        let mut client = get_client(url).await?;
+        let result = client.run_query(QueryAtFrame {
+            id: file_id,
+            query: Some(Query {
+                query: Some(query)
+            }),
+            frame,
+            branch,
+        }).await?;
+        let res = result.into_inner();
+        let mut obj = HashMap::new();
+        for value in res.values.iter() {
+            let c = value.change_value.as_ref().unwrap();
+            let k = c.path.as_ref().unwrap().address.join(":");
+            let v = c.value.as_ref().unwrap().clone();
+            obj.insert(k, v).unwrap();
+        }
+        Ok(obj)
+    }
+
 }
 
 #[cfg(test)]
 mod tests {
-    use super::new_graph;
+    use super::*;
 
     #[test]
     fn test_new_graph() {
-        new_graph();
     }
 }