delete unused fields

Author: sxlijin

engine/baml-compiler/src/viz.rs

@@ -4,6 +4,7 @@ use baml_vm::VizNodeMeta;
 /// Representation of a viz node during compilation.
 #[derive(Clone, Debug)]
 pub struct VizNode {
+    pub node_id: u32,
     pub id: String,
     pub parent: Option<String>,
     pub node_type: RuntimeNodeType,
@@ -40,6 +41,7 @@ impl VizNodes {
         self.nodes
             .into_iter()
             .map(|node| VizNodeMeta {
+                node_id: node.node_id,
                 id: node.id,
                 parent: node.parent,
                 node_type: node.node_type,

engine/baml-compiler/src/viz_builder.rs

@@ -125,30 +125,36 @@ struct Builder {
     function_name: String,
     frames: Vec<Frame>,
     nodes: VizNodes,
+    next_node_id: u32,
 }
 
 impl Builder {
     fn new(function_name: &str) -> Self {
-        let mut nodes = VizNodes::new();
+        let mut builder = Self {
+            function_name: function_name.to_string(),
+            frames: Vec::new(),
+            nodes: VizNodes::new(),
+            next_node_id: 0,
+        };
+
         let segment = PathSegment::FunctionRoot { ordinal: 0 };
         let lexical_id = encode_segments(function_name, &[segment.clone()]);
-        nodes.push(VizNode {
+        let node_id = builder.allocate_node_id();
+        builder.nodes.push(VizNode {
+            node_id,
             id: lexical_id.clone(),
             parent: None,
             node_type: RuntimeNodeType::FunctionRoot,
             label: function_name.to_string(),
             header_level: None,
         });
 
-        Self {
-            function_name: function_name.to_string(),
-            frames: vec![Frame::new(
-                FrameEntry::FunctionRoot,
-                Some(segment),
-                lexical_id,
-            )],
-            nodes,
-        }
+        builder.frames.push(Frame::new(
+            FrameEntry::FunctionRoot,
+            Some(segment),
+            lexical_id,
+        ));
+        builder
     }
 
     fn finish(self) -> VizNodes {
@@ -169,6 +175,12 @@ impl Builder {
         encode_segments(&self.function_name, &segments)
     }
 
+    fn allocate_node_id(&mut self) -> u32 {
+        let id = self.next_node_id;
+        self.next_node_id += 1;
+        id
+    }
+
     fn push_child(&mut self, node: VizNode, entry: FrameEntry, segment: PathSegment) {
         let lexical_id = node.id.clone();
         let parent_index = self.frames.len() - 1;
@@ -318,6 +330,7 @@ impl Builder {
         let lexical_id = self.build_lexical_id(&segment);
         let parent = self.current_parent_lexical();
         let node = VizNode {
+            node_id: self.allocate_node_id(),
             id: lexical_id.clone(),
             parent,
             node_type: RuntimeNodeType::BranchGroup,
@@ -361,6 +374,7 @@ impl Builder {
         let lexical_id = self.build_lexical_id(&segment);
         let parent = self.current_parent_lexical();
         let node = VizNode {
+            node_id: self.allocate_node_id(),
             id: lexical_id.clone(),
             parent,
             node_type: RuntimeNodeType::BranchArm,
@@ -390,6 +404,7 @@ impl Builder {
         let lexical_id = self.build_lexical_id(&segment);
         let parent = self.current_parent_lexical();
         let node = VizNode {
+            node_id: self.allocate_node_id(),
             id: lexical_id.clone(),
             parent,
             node_type: RuntimeNodeType::Loop,
@@ -421,6 +436,7 @@ impl Builder {
         let lexical_id = self.build_lexical_id(&segment);
         let parent = self.current_parent_lexical();
         let node = VizNode {
+            node_id: self.allocate_node_id(),
             id: lexical_id.clone(),
             parent,
             node_type: RuntimeNodeType::OtherScope,
@@ -445,6 +461,7 @@ impl Builder {
         let lexical_id = self.build_lexical_id(&segment);
         let parent = self.current_parent_lexical();
         let node = VizNode {
+            node_id: self.allocate_node_id(),
             id: lexical_id.clone(),
             parent,
             node_type: RuntimeNodeType::HeaderContextEnter,

engine/baml-compiler/src/watch/watch_event.rs

@@ -89,7 +89,7 @@ pub fn shared_noop_handler() -> SharedWatchHandler {
 #[derive(Debug, Clone)]
 pub enum WatchBamlValue {
     Value(BamlValueWithMeta<WatchValueMetadata>),
-    Header(HeaderContext),
+    VizExecHeader(HeaderContext),
     VizExecState(VizExecEvent),
     StreamStart(StreamId),
     StreamUpdate(StreamId, BamlValueWithMeta<WatchValueMetadata>),
@@ -138,7 +138,7 @@ impl fmt::Display for WatchNotification {
                     write!(f, "{}", value.clone().value())
                 }
             },
-            WatchBamlValue::Header(header) => {
+            WatchBamlValue::VizExecHeader(header) => {
                 write!(
                     f,
                     "(header L{level}) {function}.{title}",
@@ -154,9 +154,9 @@ impl fmt::Display for WatchNotification {
                 };
                 write!(
                     f,
-                    "(context {delta}) {function}.{segment}",
-                    function = self.function_name,
-                    segment = event.path_segment.encode()
+                    "(context {delta}) n{node_id} {lexical}",
+                    node_id = event.node_id,
+                    lexical = event.lexical_id
                 )
             }
             WatchBamlValue::StreamStart(stream_id) => {
@@ -209,7 +209,7 @@ impl WatchNotification {
 
     pub fn new_block(header: HeaderContext, function_name: String) -> Self {
         Self {
-            value: WatchBamlValue::Header(header),
+            value: WatchBamlValue::VizExecHeader(header),
             variable_name: None,
             channel_name: None,
             function_name,

engine/baml-runtime/tests/viz-runtime.rs

@@ -16,14 +16,9 @@ use serde_json::Value;
 #[derive(Debug, Clone, Serialize)]
 struct EventRecord {
     kind: String,
-    function: String,
-    variable: Option<String>,
-    channel: Option<String>,
-    stream_id: Option<String>,
+    lexical_id: Option<String>,
     header: Option<HeaderEvent>,
     viz_event: Option<VizExecEvent>,
-    value: Option<Value>,
-    is_stream: bool,
 }
 
 #[derive(Debug, Clone, Serialize)]
@@ -159,7 +154,7 @@ fn build_watch_handler(
 
         let mut reducer_guard = reducer.lock().unwrap();
         let (updates, state_after) = if let Some(viz_event) = event.viz_event.as_ref() {
-            let updates = reducer_guard.apply(&event.function, viz_event);
+            let updates = reducer_guard.apply(viz_event);
             let state_after = reducer_guard.dump();
             (updates, state_after)
         } else {
@@ -176,42 +171,28 @@ fn build_watch_handler(
 }
 
 fn to_event_record(notification: &WatchNotification) -> EventRecord {
-    let (kind, stream_id, viz_event) = match &notification.value {
-        WatchBamlValue::Value(_) => ("value".to_string(), None, None),
-        WatchBamlValue::Header(_) => ("header".to_string(), None, None),
-        WatchBamlValue::VizExecState(event) => {
-            ("viz_exec_state".to_string(), None, Some(event.clone()))
-        }
-        WatchBamlValue::StreamStart(id) => ("stream_start".to_string(), Some(id.clone()), None),
-        WatchBamlValue::StreamUpdate(id, _) => {
-            ("stream_update".to_string(), Some(id.clone()), None)
-        }
-        WatchBamlValue::StreamEnd(id) => ("stream_end".to_string(), Some(id.clone()), None),
+    let (kind, viz_event, lexical_id) = match &notification.value {
+        WatchBamlValue::VizExecHeader(_) => ("viz_exec_header".to_string(), None, None),
+        WatchBamlValue::VizExecState(event) => (
+            "viz_exec_state".to_string(),
+            Some(event.clone()),
+            Some(event.lexical_id.clone()),
+        ),
+        _ => ("other".to_string(), None, None),
     };
 
     let header = match &notification.value {
-        WatchBamlValue::Header(h) => Some(HeaderEvent {
+        WatchBamlValue::VizExecHeader(h) => Some(HeaderEvent {
             level: h.level,
             title: h.title.clone(),
         }),
         _ => None,
     };
 
-    let value = match &notification.value {
-        WatchBamlValue::Value(v) => serde_json::to_value(v.clone().value()).ok(),
-        WatchBamlValue::StreamUpdate(_, v) => serde_json::to_value(v.clone().value()).ok(),
-        _ => None,
-    };
-
     EventRecord {
         kind,
-        function: notification.function_name.clone(),
-        variable: notification.variable_name.clone(),
-        channel: notification.channel_name.clone(),
-        stream_id,
+        lexical_id,
         header,
         viz_event,
-        value,
-        is_stream: notification.is_stream,
     }
 }