sep 29 studio (BoundaryML#2576)

- **type fixes**
- **use blak3 hash when hashing blobs**
- **fix streams being null in studio**
- **http metadata was serialized incorrectly**
- **Fix issue with python exceptions not counting as exceptions in
studio, http bodies serialized as byte arrays, add test for checking
publisher spans**


<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> Switches blob hashing to blake3, fixes HTTP body serialization and
Python exception handling, adds trace function
summaries/match-highlights and blob fetch API, enables optional trace
event file dump, and adjusts stream/function end payloads.
> 
> - **Tracing/Serialization**:
> - Serialize `HTTPBody.raw` bytes as UTF-8 string with flexible
deserializer; fix HTTP metadata typing and headers shapes.
> - Treat Python exceptions as errors in function end events; propagate
proper error to tracer.
> - Stream end events now carry parsed value meta instead of always
null.
> - Optional local trace dump via `BAML_TRACE_FILE` (writes
newline-delimited JSON events).
> - **Blobs**:
>   - Use `blake3` for blob hashing; replace SHA-256 and add dependency.
> - New UI API/types `ui_blobs` with `GetBlobRequest/Response` and
`BlobFormat`.
> - **UI/Types**:
> - TS type refinements (`any` -> `unknown`, header maps stricter) and
added `http_metadata_summary`.
> - Traces API: add `matched_descendant_ids` field and
`include_match_highlights` flag.
> - New endpoint: `/v1/traces/function-summaries` with request/response
and `FunctionSummary` aggregates.
> - **Tests/Infra**:
> - Python tests verify publisher span counts via file, adjust stream
test name, and add session flush.
>   - Ignore trace debug files in git.
> 
> <sup>Written by [Cursor
Bugbot](https://cursor.com/dashboard?tab=bugbot) for commit
29e202f. This will update automatically
on new commits. Configure
[here](https://cursor.com/dashboard?tab=bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

---------

Signed-off-by: aaronvg <[email protected]>

Author: aaronvg

.gitignore

@@ -171,5 +171,7 @@ jj-workflow.mdc
 third_party
 
 baml_repl_history.txt
+trace_events_debug.json
 
 result
+

engine/Cargo.lock

@@ -151,9 +151,78 @@ pub enum IntermediateData<'a> {
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct HTTPBody<'a> {
+    #[serde(
+        serialize_with = "serialize_bytes_as_string",
+        deserialize_with = "deserialize_string_as_bytes"
+    )]
     pub raw: Cow<'a, [u8]>,
 }
 
+fn serialize_bytes_as_string<S>(bytes: &[u8], serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: serde::Serializer,
+{
+    // Serialize as text to avoid exploding arrays of bytes; use lossy UTF-8 if needed
+    let s = String::from_utf8_lossy(bytes);
+    serializer.serialize_str(&s)
+}
+
+fn deserialize_string_as_bytes<'de, D>(deserializer: D) -> Result<Cow<'static, [u8]>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    struct BytesVisitor;
+
+    impl<'de> serde::de::Visitor<'de> for BytesVisitor {
+        type Value = Cow<'static, [u8]>;
+
+        fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+            formatter.write_str("a string or byte array")
+        }
+
+        fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+        where
+            E: serde::de::Error,
+        {
+            Ok(Cow::Owned(value.as_bytes().to_vec()))
+        }
+
+        fn visit_string<E>(self, value: String) -> Result<Self::Value, E>
+        where
+            E: serde::de::Error,
+        {
+            Ok(Cow::Owned(value.into_bytes()))
+        }
+
+        fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
+        where
+            E: serde::de::Error,
+        {
+            Ok(Cow::Owned(value.to_vec()))
+        }
+
+        fn visit_byte_buf<E>(self, value: Vec<u8>) -> Result<Self::Value, E>
+        where
+            E: serde::de::Error,
+        {
+            Ok(Cow::Owned(value))
+        }
+
+        fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+        where
+            A: serde::de::SeqAccess<'de>,
+        {
+            let mut bytes = Vec::new();
+            while let Some(byte) = seq.next_element::<u8>()? {
+                bytes.push(byte);
+            }
+            Ok(Cow::Owned(bytes))
+        }
+    }
+
+    deserializer.deserialize_any(BytesVisitor)
+}
+
 #[derive(Debug, Serialize, Deserialize)]
 pub struct Event<'a> {
     pub raw: Cow<'a, str>,

engine/baml-rpc/src/runtime_api/trace_event.rs

@@ -1,4 +1,5 @@
 pub mod ui_baml_src;
+pub mod ui_blobs;
 pub mod ui_control_plane_orgs;
 pub mod ui_control_plane_projects;
 pub mod ui_dashboard;

engine/baml-rpc/src/ui/mod.rs

@@ -32,7 +32,7 @@ pub struct BamlSourceCode {
 pub struct AstNodeDefinition {
     pub project_id: String,
     pub ast_node_id: String,
-    #[ts(type = "any")]
+    #[ts(type = "unknown")]
     pub ast_node_definition: serde_json::Value,
     pub flattened_dependencies_ast_nodes: Vec<String>,
     pub baml_src_node_ids: Vec<String>,

engine/baml-rpc/src/ui/ui_baml_src.rs

@@ -0,0 +1,42 @@
+use serde::{Deserialize, Serialize};
+use ts_rs::TS;
+
+use crate::ProjectId;
+
+/// Request to fetch blob content
+#[derive(Debug, Serialize, Deserialize, TS)]
+#[ts(export)]
+pub struct GetBlobRequest {
+    /// The 64-character BLAKE3 hash of the blob
+    pub blob_hash: String,
+    /// The project ID that owns this blob
+    #[ts(type = "string")]
+    pub project_id: ProjectId,
+    /// Response format: 'raw' returns binary, 'json' returns base64-encoded content
+    #[serde(default)]
+    pub format: BlobFormat,
+}
+
+/// Response format for blob content
+#[derive(Debug, Serialize, Deserialize, TS, Default)]
+#[ts(export)]
+#[serde(rename_all = "lowercase")]
+pub enum BlobFormat {
+    /// Return raw binary content with appropriate Content-Type header
+    #[default]
+    Raw,
+    /// Return JSON with base64-encoded content
+    Json,
+}
+
+/// JSON response format for blob content
+#[derive(Debug, Serialize, Deserialize, TS)]
+#[ts(export)]
+pub struct GetBlobResponse {
+    /// The blob hash
+    pub blob_hash: String,
+    /// The content type of the decoded blob (e.g., "image/png")
+    pub content_type: String,
+    /// Base64-encoded content (exact same as used in LLM request)
+    pub base64_content: String,
+}

engine/baml-rpc/src/ui/ui_blobs.rs

@@ -45,6 +45,10 @@ pub struct NodeDetails {
     pub children_limit: Option<u32>, // How many children were requested/returned
     #[ts(type = "number", optional)]
     pub children_offset: Option<u32>, // Pagination offset for children
+
+    // Match highlighting - IDs of descendants that matched filters
+    #[ts(optional)]
+    pub matched_descendant_ids: Option<Vec<String>>,
 }
 
 #[derive(Debug, Serialize, Deserialize, TS)]
@@ -130,6 +134,9 @@ pub struct ListTracesRequest {
     /// Filter to only show LLM function calls (function_type = 'baml_llm')
     #[ts(optional)]
     pub llm_only: Option<FilterExpression<bool>>,
+    /// Whether to include matched_descendant_ids in the response for match highlighting. Defaults to false.
+    #[ts(optional)]
+    pub include_match_highlights: Option<bool>,
 }
 
 impl Default for ListTracesRequest {
@@ -160,6 +167,7 @@ impl Default for ListTracesRequest {
             relative_time: None,
             search: None,
             llm_only: None,
+            include_match_highlights: Some(false),
         }
     }
 }
@@ -273,3 +281,117 @@ mod tests {
         assert_eq!(request.limit, Some(50));
     }
 }
+
+// API for listing function summaries with aggregate statistics
+#[derive(Debug, Clone, Serialize, Deserialize, TS)]
+#[serde(rename_all = "camelCase", default)]
+#[ts(export)]
+pub struct ListTraceFunctionSummariesRequest {
+    #[ts(type = "string")]
+    pub project_id: ProjectId,
+    /// Maximum number of functions to return. Defaults to 100 if not specified.
+    #[ts(optional)]
+    pub limit: Option<u32>,
+    /// Cursor for pagination: fetch functions starting after this function_name
+    #[ts(optional)]
+    pub starting_after: Option<String>,
+
+    // Time filters
+    #[ts(optional)]
+    pub relative_time: Option<RelativeTime>,
+    #[ts(type = "FilterExpression<number>", optional)]
+    pub start_time: Option<FilterExpression<EpochMsTimestamp>>,
+    #[ts(type = "FilterExpression<number>", optional)]
+    pub end_time: Option<FilterExpression<EpochMsTimestamp>>,
+
+    // Function filters
+    #[ts(optional)]
+    pub function_name: Option<FilterExpression<String>>,
+    #[ts(optional)]
+    pub function_id: Option<FilterExpression<String>>,
+    #[ts(optional)]
+    pub llm_only: Option<FilterExpression<bool>>,
+
+    // Status and other filters
+    #[ts(optional)]
+    pub status: Option<FilterExpression<FunctionCallStatus>>,
+    #[ts(optional)]
+    pub tag_filters: Option<Vec<TagFilter>>,
+    #[ts(optional)]
+    pub error_filters: Option<Vec<TagFilter>>,
+    #[ts(optional)]
+    pub search: Option<String>,
+}
+
+impl Default for ListTraceFunctionSummariesRequest {
+    fn default() -> Self {
+        Self {
+            project_id: ProjectId::new(),
+            limit: Some(100),
+            starting_after: None,
+            relative_time: None,
+            start_time: None,
+            end_time: None,
+            function_name: None,
+            function_id: None,
+            llm_only: None,
+            status: None,
+            tag_filters: None,
+            error_filters: None,
+            search: None,
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, TS)]
+#[ts(export)]
+pub struct FunctionSummary {
+    #[ts(optional)]
+    pub function_id: Option<ui_types::UiFunctionIdString>,
+    pub function_name: String,
+    pub function_type: String, // 'baml_llm' or 'native'
+    #[ts(type = "Record<string, unknown>")]
+    pub tags: serde_json::Map<String, serde_json::Value>,
+
+    // Aggregate statistics
+    #[ts(type = "number")]
+    pub total_traces: u64,
+    #[ts(type = "number")]
+    pub success_count: u64,
+    #[ts(type = "number")]
+    pub error_count: u64,
+    #[ts(type = "number")]
+    pub running_count: u64,
+
+    // Time range for this function's traces
+    #[ts(type = "number")]
+    pub first_trace_time: EpochMsTimestamp,
+    #[ts(type = "number")]
+    pub last_trace_time: EpochMsTimestamp,
+
+    // Optional cost aggregates (if available)
+    #[ts(type = "number", optional)]
+    pub total_cost: Option<f64>,
+    #[ts(type = "number", optional)]
+    pub avg_duration_ms: Option<f64>,
+}
+
+#[derive(Debug, Serialize, Deserialize, TS)]
+#[ts(export)]
+pub struct ListTraceFunctionSummariesResponse {
+    pub summaries: Vec<FunctionSummary>,
+    pub function_definitions: Vec<ui_types::UiFunctionDefinition>,
+    pub type_definitions: Vec<ui_types::UiTypeDefinition>,
+    pub has_more: bool,
+    #[ts(optional)]
+    pub next_cursor: Option<String>, // function_name for pagination
+}
+
+pub struct ListTraceFunctionSummaries;
+
+impl ApiEndpoint for ListTraceFunctionSummaries {
+    type Request<'a> = ListTraceFunctionSummariesRequest;
+    type Response<'a> = ListTraceFunctionSummariesResponse;
+
+    const PATH: &'static str = "/v1/traces/function-summaries";
+}