Method get_all_node_response_metadata

python/src/workflow/result.rs:227–375

Get complete workflow execution metadata Returns the full workflow-level schema containing: - workflow_id, workflow_name - start_time, end_time, duration_ms - user_input, final_output (from first/last nodes) - workflow_state: completed/failed/cancelled/paused - nodes: array of per-node metadata objects (each with executions array) - total_usage: aggregated token usage across all nodes - total_too

(&self, py: Python<'_>)

    /// # Returns
    /// Dictionary with the complete workflow-level metadata
    fn get_all_node_response_metadata(&self, py: Python<'_>) -> PyResult<PyObject> {
        // Collect node metadata entries (by node ID only, skip name duplicates)
        let mut nodes: Vec<serde_json::Value> = Vec::new();
        let mut seen_node_ids: std::collections::HashSet<String> = std::collections::HashSet::new();

        for (k, v) in self.inner.metadata.iter() {
            if let Some(node_id) = k.strip_prefix("node_response_") {
                // Skip if this is a name-based duplicate (node names are typically not UUIDs)
                // We include if the node_id is a UUID format or if the value has a node_id field matching
                if let Some(stored_node_id) = v.get("node_id").and_then(|v| v.as_str()) {
                    if seen_node_ids.contains(stored_node_id) {
                        continue;
                    }
                    seen_node_ids.insert(stored_node_id.to_string());
                } else if seen_node_ids.contains(node_id) {
                    continue;
                } else {
                    seen_node_ids.insert(node_id.to_string());
                }
                // Sanitize node: expose parameters_masked as parameters and output_masked as output
                // so the returned metadata does not leak real PII (executions, tool_calls, initial_response.tool_calls).
                let mut node = v.clone();
                sanitize_node_metadata(&mut node);
                nodes.push(node);
            }
        }

        // Sort nodes chronologically by start_time
        nodes.sort_by(|a, b| {
            let a_start = a.get("start_time").and_then(|v| v.as_str()).unwrap_or("");
            let b_start = b.get("start_time").and_then(|v| v.as_str()).unwrap_or("");
            a_start.cmp(b_start)
        });

        // Aggregate total_usage and total_tool_calls across all nodes
        let mut total_prompt_tokens: u64 = 0;
        let mut total_completion_tokens: u64 = 0;
        let mut total_tokens: u64 = 0;
        let mut total_cached_tokens: u64 = 0;
        let mut total_cache_creation_tokens: u64 = 0;
        let mut total_tool_calls: u64 = 0;

        for node in &nodes {
            if let Some(usage) = node.get("total_usage") {
                total_prompt_tokens += usage
                    .get("prompt_tokens")
                    .and_then(|v| v.as_u64())
                    .unwrap_or(0);
                total_completion_tokens += usage
                    .get("completion_tokens")
                    .and_then(|v| v.as_u64())
                    .unwrap_or(0);
                total_tokens += usage
                    .get("total_tokens")
                    .and_then(|v| v.as_u64())
                    .unwrap_or(0);
                if let Some(details) = usage.get("prompt_tokens_details") {
                    total_cached_tokens += details