#!/usr/bin/env python3 """Trajectory evaluation script for the BookWriter-A2A project. This script evaluates 6 trajectory metrics: 1. Exact match 2. In-order match 3. Any-order match 4. Precision 5. Recall 6. Single-tool use """ import os import re import yaml from pathlib import Path from typing import List, Dict, Tuple, Set from collections import defaultdict import pandas as pd import math from itertools import permutations, product class TrajectoryParser: """Parse an execution_path.md file and extract the execution trajectory.""" def __init__(self, md_file_path: str, extract_types: List[str] = None): """ Args: md_file_path: Path to the execution_path.md file extract_types: Node types to extract. Default: ['Tool']. Options: 'SPAN', 'Chain', 'Tool', 'AGENT', 'LLM', 'Task Created', 'Crew Created' """ self.md_file_path = md_file_path self.extract_types = extract_types or ["Tool"] self.trajectory = [] def parse(self) -> List[str]: """Parse the file and return the execution trajectory sequence.""" if not os.path.exists(self.md_file_path): return [] with open(self.md_file_path, "r", encoding="utf-8") as f: content = f.read() # Extract the "Execution Path Tree" section (inside a code block) tree_match = re.search( r"## Execution Path Tree.*?```\n(.*?)```", content, re.DOTALL ) if not tree_match: return [] tree_content = tree_match.group(1) trajectory = [] for line in tree_content.split("\n"): # Strip tree-structure characters, keep node content clean_line = re.sub(r"^[│├└─\s]+", "", line).strip() if not clean_line: continue # Strip error marker clean_line = re.sub(r"^❌\s+", "", clean_line) # Strip retry markers: (retry N) and [RETRYN] clean_line = re.sub(r"\s*\(retry\s+\d+\)", "", clean_line) clean_line = re.sub(r"\s*\[RETRY\d+\]", "", clean_line) # Strip ERROR payloads (keep node type/name; remove [ERROR:...] segments) clean_line = re.sub(r"\s*\[ERROR:[^\]]*\]", "", clean_line) # Extract node info node_info = self._extract_node_info(clean_line) if node_info and node_info["type"] in self.extract_types: trajectory.append(node_info["action"]) self.trajectory = trajectory return trajectory def _extract_node_info(self, line: str) -> dict: """Extract node information from a line. Returns: {'type': str, 'action': str} or None """ # SPAN node: [SPAN] span_name [statistics] # A2A version: SPAN name may contain chapter title (e.g., a2a_call_chapter_writer_(chapter_title)) # Use wildcard matching: a2a_call_chapter_writer_(any chapter title) -> a2a_call_chapter_writer_* span_match = re.match(r"\[SPAN\]\s+([^\[]+?)(?:\s+\[.*?\])*\s*$", line) if span_match: span_name = span_match.group(1).strip() # Wildcard handling: a2a_call_chapter_writer_(any chapter title) -> a2a_call_chapter_writer_* span_name = re.sub( r"a2a_call_chapter_writer_\([^)]+\)", "a2a_call_chapter_writer_*", span_name, ) return {"type": "SPAN", "action": f"SPAN: {span_name}"} # Chain node: [Chain] chain_name [statistics] [optional extra info] # For Crew_xxx.kickoff format, use wildcard Crew***.kickoff # Note: A2A version may contain BATCH marker (e.g., BATCH1 (chapter title)) chain_match = re.match(r"\[Chain\]\s+([^\[\s]+(?:\.[^\[\s]+)?)", line) if chain_match: chain_name = chain_match.group(1).strip() # Wildcard handling: Crew_UUID.kickoff -> Crew***.kickoff chain_name = re.sub( r"Crew_[a-f0-9\-]+\.kickoff", "Crew***.kickoff", chain_name ) return {"type": "Chain", "action": f"Chain: {chain_name}"} # Agent node: [AGENT] agent_name._execute_core [statistics] agent_match = re.match(r"\[AGENT\]\s+([^\[]+?)(?:\s+\[.*?\])*\s*$", line) if agent_match: agent_name = agent_match.group(1).strip() # Remove ._execute_core suffix agent_name = re.sub(r"\._execute_core$", "", agent_name) return {"type": "Agent", "action": f"Agent: {agent_name}"} # Tool node: [Tool] tool_name._use [time] tool_match = re.match( r"\[Tool\]\s+([^\[\]]+?)(?:\s+\[[\d.]+(?:ms|s)\])?(?:\s*@@@)?\s*$", line ) if tool_match: tool_name = tool_match.group(1).strip() # Remove ._use suffix tool_name = re.sub(r"\._use$", "", tool_name) return {"type": "Tool", "action": f"Tool: {tool_name}"} # LLM node: [LLM] model_name (tokens) [time] llm_match = re.match(r"\[LLM\]\s+([^\(\[]+)", line) if llm_match: model_name = llm_match.group(1).strip() return {"type": "LLM", "action": f"LLM: {model_name}"} # Task Created node: [Task Created] [time] task_match = re.match(r"\[Task Created\]", line) if task_match: return {"type": "Task Created", "action": "Task Created"} # Crew Created node: [Crew Created] [time] crew_match = re.match(r"\[Crew Created\]", line) if crew_match: return {"type": "Crew Created", "action": "Crew Created"} return None class TrajectoryEvaluator: """Trajectory evaluator (implements the 6 metrics).""" def __init__( self, reference_trajectory: List[str], repeatable_patterns: List[Dict] = None, actual_chapter_count: int = None, ): """ Args: reference_trajectory: Base reference trajectory (ground truth, includes single-chapter pattern) repeatable_patterns: Repeatable pattern definitions; each contains start, end, min, max actual_chapter_count: Actual executed chapter count. If provided, a reference trajectory will be generated dynamically for that count. """ self.base_reference = ( reference_trajectory # Keep the original base reference trajectory ) self.repeatable_patterns = repeatable_patterns or [] self.use_simple_matching = False # Build reference trajectory dynamically when chapter count is known if actual_chapter_count is not None and self.repeatable_patterns: self.reference = self._build_dynamic_reference(actual_chapter_count) # When using a dynamic reference, disable special repeatable-pattern matching logic, # because the dynamic reference already contains the correct number of chapters. self.use_simple_matching = True else: self.reference = reference_trajectory self.use_simple_matching = False @staticmethod def detect_chapter_count(predicted: List[str]) -> int: """ Detect the actual number of executed chapters. Heuristic: count the number of `Chain: Crew***.kickoff` entries inside the `SPAN: write_chapters` region. Args: predicted: The actual (predicted) trajectory Returns: Chapter count. If detection fails, return 4 by default. """ # Find the position of the write_chapters SPAN write_chapters_idx = -1 review_book_idx = -1 for i, step in enumerate(predicted): if step == "SPAN: write_chapters": write_chapters_idx = i elif step == "SPAN: review_book": review_book_idx = i break if write_chapters_idx == -1: # write_chapters SPAN not found; return default return 4 # Determine search range if review_book_idx != -1: search_end = review_book_idx else: search_end = len(predicted) # Count Chain: Crew***.kickoff occurrences chapter_count = 0 for i in range(write_chapters_idx + 1, search_end): if predicted[i] == "Chain: Crew***.kickoff": chapter_count += 1 # If detection fails (0 chapters), return default return chapter_count if chapter_count > 0 else 4 def _build_dynamic_reference(self, chapter_count: int) -> List[str]: """ Dynamically build the reference trajectory based on the actual chapter count. Args: chapter_count: Chapter count Returns: Dynamically generated reference trajectory """ if not self.repeatable_patterns: return self.base_reference pattern = self.repeatable_patterns[0] pattern_start = pattern["start"] pattern_end = pattern["end"] # Split the base reference trajectory before_pattern = self.base_reference[:pattern_start] pattern_steps = self.base_reference[pattern_start : pattern_end + 1] after_pattern = self.base_reference[pattern_end + 1 :] # Repeat the pattern based on chapter count # If chapter_count is not within 3-5, fall back to 4 if chapter_count < 3 or chapter_count > 5: repeat_count = 4 else: repeat_count = chapter_count # Build the dynamic reference trajectory dynamic_reference = before_pattern.copy() for _ in range(repeat_count): dynamic_reference.extend(pattern_steps) dynamic_reference.extend(after_pattern) return dynamic_reference def _match_action(self, predicted_action: str, reference_action: str) -> bool: """ Match two actions, supporting wildcards. Args: predicted_action: Action from the actual trajectory reference_action: Action from the reference trajectory (may contain wildcards) Returns: True if match, False otherwise """ # Exact match if predicted_action == reference_action: return True # Wildcard match: LLM: * matches any LLM: if reference_action == "LLM: *" and predicted_action.startswith("LLM: "): return True # Wildcard match: SPAN: a2a_call_chapter_writer_* matches any chapter title if ( reference_action == "SPAN: a2a_call_chapter_writer_*" and predicted_action.startswith("SPAN: a2a_call_chapter_writer_") ): return True return False def exact_match(self, predicted: List[str]) -> int: """ Exact match: predicted trajectory must be identical to the reference trajectory (wildcards supported). Returns: 1 if exact match, 0 otherwise """ if len(predicted) != len(self.reference): return 0 for i in range(len(predicted)): if not self._match_action(predicted[i], self.reference[i]): return 0 return 1 def in_order_match(self, predicted: List[str]) -> int: """ In-order match: reference trajectory must be a subsequence of the predicted trajectory (wildcards supported). Allows extra actions, but core steps must appear in order. Supports repeatable patterns (e.g., chapter repetition). Returns: 1 if in-order match, 0 otherwise """ if not self.reference: return 1 # Empty reference always matches # If using simple matching (dynamic reference already contains correct chapter count), use simple logic if self.use_simple_matching or not self.repeatable_patterns: ref_idx = 0 for pred_action in predicted: if ref_idx < len(self.reference) and self._match_action( pred_action, self.reference[ref_idx] ): ref_idx += 1 return 1 if ref_idx == len(self.reference) else 0 # Matching logic with repeatable patterns # Currently only a single repeatable pattern is supported pattern = self.repeatable_patterns[0] pattern_start = pattern["start"] pattern_end = pattern["end"] # Split reference into three parts before_pattern = self.reference[:pattern_start] pattern_steps = self.reference[pattern_start : pattern_end + 1] after_pattern = self.reference[pattern_end + 1 :] pred_idx = 0 # 1) Match the part before the pattern for ref_action in before_pattern: while pred_idx < len(predicted): if self._match_action(predicted[pred_idx], ref_action): pred_idx += 1 break pred_idx += 1 else: return 0 # No match found # 2) Match the repeatable pattern (at least min times, at most max times) pattern_matches = 0 while pattern_matches < pattern["max"]: # Try to match one full pattern pattern_idx = 0 start_pred_idx = pred_idx for pattern_action in pattern_steps: while pred_idx < len(predicted): if self._match_action(predicted[pred_idx], pattern_action): pred_idx += 1 pattern_idx += 1 break pred_idx += 1 else: # No match found break # Check whether one full pattern was matched if pattern_idx == len(pattern_steps): pattern_matches += 1 else: # Restore to the position before this attempt pred_idx = start_pred_idx break # Check whether the repeat count meets requirements if pattern_matches < pattern["min"]: return 0 # 3) Match the part after the pattern for ref_action in after_pattern: while pred_idx < len(predicted): if self._match_action(predicted[pred_idx], ref_action): pred_idx += 1 break pred_idx += 1 else: return 0 # No match found return 1 def diagnose_any_order_match_failure(self, predicted: List[str]) -> dict: """ Diagnose why any_order_match fails. Returns: { 'match': bool, 'failure_stage': str ('before_pattern', 'pattern', 'after_pattern', None), 'missing_steps': [str], 'missing_details': str } """ if not self.reference: return { "match": True, "failure_stage": None, "missing_steps": [], "missing_details": "", } # If using simple matching (dynamic reference already contains the correct chapter count), use simple logic if self.use_simple_matching or not self.repeatable_patterns: pred_remaining = predicted.copy() missing_steps = [] for ref_action in self.reference: matched = False for i, pred_action in enumerate(pred_remaining): if self._match_action(pred_action, ref_action): pred_remaining.pop(i) matched = True break if not matched: missing_steps.append(ref_action) if missing_steps: return { "match": False, "failure_stage": "simple_match", "missing_steps": missing_steps, "missing_details": f"Missing {len(missing_steps)} required steps", } return { "match": True, "failure_stage": None, "missing_steps": [], "missing_details": "", } # Logic for matching with repeatable patterns pattern = self.repeatable_patterns[0] pattern_start = pattern["start"] pattern_end = pattern["end"] before_pattern = self.reference[:pattern_start] pattern_steps = self.reference[pattern_start : pattern_end + 1] after_pattern = self.reference[pattern_end + 1 :] pred_remaining = predicted.copy() # 1) Check the part before the pattern missing_before = [] for ref_action in before_pattern: matched = False for i, pred_action in enumerate(pred_remaining): if self._match_action(pred_action, ref_action): pred_remaining.pop(i) matched = True break if not matched: missing_before.append(ref_action) if missing_before: return { "match": False, "failure_stage": "before_pattern", "missing_steps": missing_before, "missing_details": f"Missing {len(missing_before)} steps in the Outline stage", } # 2) Check the repeatable pattern part pattern_missing = [] for ref_action in pattern_steps: required_count = pattern["min"] found_count = 0 i = 0 while i < len(pred_remaining) and found_count < required_count: if self._match_action(pred_remaining[i], ref_action): pred_remaining.pop(i) found_count += 1 else: i += 1 if found_count < required_count: pattern_missing.append( f"{ref_action} (required {required_count}, found {found_count})" ) if pattern_missing: return { "match": False, "failure_stage": "pattern", "missing_steps": pattern_missing, "missing_details": f"Missing {len(pattern_missing)} steps in the chapter pattern (min {pattern['min']} per chapter)", } # 3) Check the part after the pattern missing_after = [] for ref_action in after_pattern: matched = False for i, pred_action in enumerate(pred_remaining): if self._match_action(pred_action, ref_action): pred_remaining.pop(i) matched = True break if not matched: missing_after.append(ref_action) if missing_after: return { "match": False, "failure_stage": "after_pattern", "missing_steps": missing_after, "missing_details": f"Missing {len(missing_after)} steps in the Review stage", } return { "match": True, "failure_stage": None, "missing_steps": [], "missing_details": "", } def any_order_match(self, predicted: List[str]) -> int: """ Any-order match: the predicted trajectory must contain all required actions (wildcards supported). Order is ignored and extra actions are allowed. Supports repeatable patterns (e.g., chapter repetition). Returns: 1 if any-order match, 0 otherwise """ diagnosis = self.diagnose_any_order_match_failure(predicted) return 1 if diagnosis["match"] else 0 def precision(self, predicted: List[str]) -> float: """ Precision: fraction of predicted actions that are considered correct by the reference (wildcards supported). Precision = TP / (TP + FP) TP: number of correct actions in the prediction FP: number of incorrect/extra actions in the prediction Returns: precision value (0.0 - 1.0) """ if not predicted: return 1.0 # No prediction -> no incorrect prediction if not self.reference: return 0.0 # Reference is empty but prediction exists -> all incorrect # Create a copy of reference actions for matching ref_remaining = self.reference.copy() tp = 0 # True Positives for pred_action in predicted: # Try to find a match in the reference for i, ref_action in enumerate(ref_remaining): if self._match_action(pred_action, ref_action): tp += 1 ref_remaining.pop(i) # Remove matched entry break fp = len(predicted) - tp # False Positives return tp / (tp + fp) if (tp + fp) > 0 else 0.0 def recall(self, predicted: List[str]) -> float: """ Recall: fraction of the reference trajectory covered by the predicted trajectory (wildcards supported). Recall = TP / (TP + FN) TP: number of required actions covered by the prediction FN: number of required actions missed by the prediction Returns: recall value (0.0 - 1.0) """ if not self.reference: return 1.0 # Empty reference -> nothing to recall if not predicted: return 0.0 # No prediction -> recall is 0 # Create a copy of predicted actions for matching pred_remaining = predicted.copy() tp = 0 # True Positives for ref_action in self.reference: # Try to find a match in the prediction for i, pred_action in enumerate(pred_remaining): if self._match_action(pred_action, ref_action): tp += 1 pred_remaining.pop(i) # Remove matched entry break fn = len(self.reference) - tp # False Negatives return tp / (tp + fn) if (tp + fn) > 0 else 0.0 def single_tool_use(self, predicted: List[str], tool_name: str) -> int: """ Single-tool use: check whether a specific tool/action appears in the trajectory (wildcards supported). Args: predicted: Predicted trajectory tool_name: Target tool/action name Returns: 1 if tool is used, 0 otherwise """ # Check whether any action matches the target for pred_action in predicted: if self._match_action(pred_action, tool_name): return 1 return 0 def evaluate_all( self, predicted: List[str], target_tools: List[str] = None ) -> Dict[str, float]: """ Evaluate all metrics. Args: predicted: Predicted trajectory target_tools: Tools/actions to check for single-tool use Returns: Dictionary of evaluation results """ results = { "exact_match": self.exact_match(predicted), "in_order_match": self.in_order_match(predicted), "any_order_match": self.any_order_match(predicted), "precision": self.precision(predicted), "recall": self.recall(predicted), } # Single-tool use: overall usage rate (average across all target tools) if target_tools: tool_usage_count = sum( self.single_tool_use(predicted, tool) for tool in target_tools ) results["single_tool_use"] = ( tool_usage_count / len(target_tools) if target_tools else 0.0 ) return results class DatasetEvaluator: """Dataset-level evaluator.""" def __init__(self, config_file: str): """ Args: config_file: Path to the YAML config file that defines the reference trajectory """ self.config_file = config_file self.config = self._load_config() self.reference_trajectory = self.config.get("reference_trajectory", []) self.target_tools = self.config.get("target_tools", []) self.models = self.config.get("models", []) self.project_name = self.config.get("project_name", "BookWriter-A2A") # Trajectory extraction types: default is Tool-only; can be configured to include other node types self.extract_types = self.config.get("extract_types", ["Tool"]) # Repeatable pattern configuration (e.g., for varying chapter counts) self.repeatable_patterns = self.config.get("repeatable_patterns", []) # Permutable tool groups configuration (for generating alternative reference trajectories) self.permutable_tool_groups = self.config.get("permutable_tool_groups", {}) def _load_config(self) -> Dict: """Load the YAML config file.""" if not os.path.exists(self.config_file): print(f"⚠️ Config file not found: {self.config_file}") return {} with open(self.config_file, "r", encoding="utf-8") as f: return yaml.safe_load(f) def _generate_permuted_trajectories( self, base_trajectory: List[str] ) -> List[List[str]]: """ Generate all possible tool-order permutations according to permutable_tool_groups. Args: base_trajectory: Base reference trajectory Returns: List of permuted trajectories (including the original) """ if not self.permutable_tool_groups: # No permutation groups configured return [base_trajectory] # Collect permutable tool groups and their positions in the trajectory tool_groups_positions = [] for group_name, tools in self.permutable_tool_groups.items(): # Find positions of this tool group in the trajectory positions = [] tool_indices = {} for i, action in enumerate(base_trajectory): for tool in tools: if action == tool: positions.append(i) tool_indices[i] = tool break # Only permute if all tools in the group are found if len(positions) == len(tools): # Record positions and tools tools_at_positions = [tool_indices[pos] for pos in positions] tool_groups_positions.append((positions, tools_at_positions)) if not tool_groups_positions: # No complete group found return [base_trajectory] # Generate all possible permutation combinations all_trajectories = [] # Generate permutations for each tool group group_permutations = [] for positions, tools in tool_groups_positions: # Generate all permutations for this group perms = list(permutations(tools)) group_permutations.append([(positions, perm) for perm in perms]) # Cartesian product: combine permutations across tool groups all_group_combinations = list(product(*group_permutations)) # Build a new trajectory for each combination for combination in all_group_combinations: new_trajectory = base_trajectory.copy() # Apply tool permutations for this combination for positions, perm in combination: for pos, tool in zip(positions, perm): new_trajectory[pos] = tool all_trajectories.append(new_trajectory) return all_trajectories def _find_best_reference_trajectory( self, predicted: List[str], candidate_references: List[List[str]] ) -> Tuple[List[str], Dict[str, float]]: """ Choose the best reference trajectory among candidates. Strategy: compute a match score for each candidate vs. the predicted trajectory using a weighted sum: exact_match * 3 + in_order_match * 2 + any_order_match * 1. Args: predicted: Predicted trajectory candidate_references: Candidate reference trajectories Returns: (best_reference_trajectory, best_match_metrics) """ best_reference = candidate_references[0] best_score = -1 best_metrics = {} for ref_trajectory in candidate_references: evaluator = TrajectoryEvaluator(ref_trajectory) # Calculate three key matching metrics exact = evaluator.exact_match(predicted) in_order = evaluator.in_order_match(predicted) any_order = evaluator.any_order_match(predicted) # Weighted score: exact_match has the highest weight, then in_order_match # score = exact*3 + in_order*2 + any_order*1 score = exact * 3 + in_order * 2 + any_order * 1 if score > best_score: best_score = score best_reference = ref_trajectory best_metrics = { "exact_match": exact, "in_order_match": in_order, "any_order_match": any_order, } return best_reference, best_metrics def collect_execution_paths( self, model_name: str, base_dir: str ) -> List[Tuple[str, List[str]]]: """ Collect and parse all execution_path.md files for a given model. Args: model_name: Model name base_dir: Path to RESULTS directory Returns: List of (session_id, trajectory) """ model_dir = Path(base_dir) / model_name / self.project_name / "test_results" if not model_dir.exists(): print(f"⚠️ Model directory not found: {model_dir}") return [] results = [] # Iterate all session subdirectories for session_dir in sorted(model_dir.iterdir()): if not session_dir.is_dir(): continue exec_path_file = session_dir / "execution_path.md" if not exec_path_file.exists(): continue # Parse trajectory using configured extract types parser = TrajectoryParser( str(exec_path_file), extract_types=self.extract_types ) trajectory = parser.parse() results.append((session_dir.name, trajectory)) return results def evaluate_model( self, model_name: str, base_dir: str, collect_failure_reasons: bool = False ) -> Dict[str, float]: """ Evaluate a single model over all samples. Args: model_name: Model name base_dir: Path to RESULTS directory collect_failure_reasons: Whether to collect any_order_match failure reasons Returns: Dictionary of averaged metrics """ trajectories = self.collect_execution_paths(model_name, base_dir) if not trajectories: print(f"⚠️ No trajectories found for model {model_name}") return {} # Accumulate metrics across samples all_metrics = defaultdict(list) # Store failure reasons (optional) if collect_failure_reasons: if not hasattr(self, "failure_reasons"): self.failure_reasons = [] for session_id, predicted in trajectories: # Detect chapter count for each sample and build evaluator chapter_count = TrajectoryEvaluator.detect_chapter_count(predicted) # Step 1: build dynamic reference trajectory based on chapter count base_evaluator = TrajectoryEvaluator( self.reference_trajectory, self.repeatable_patterns, actual_chapter_count=chapter_count, ) dynamic_reference = base_evaluator.reference # Step 2: generate all tool-order permutations of the reference candidate_references = self._generate_permuted_trajectories( dynamic_reference ) # Step 3: choose the best reference trajectory among candidates if len(candidate_references) > 1: best_reference, best_match_metrics = ( self._find_best_reference_trajectory( predicted, candidate_references ) ) else: # No permutations were generated best_reference = dynamic_reference # Step 4: create evaluator using the best reference evaluator = TrajectoryEvaluator( best_reference, # repeatable_patterns is not needed here because it has already been applied repeatable_patterns=None, actual_chapter_count=None, ) metrics = evaluator.evaluate_all(predicted, self.target_tools) for key, value in metrics.items(): all_metrics[key].append(value) # Collect any_order_match failure reasons if collect_failure_reasons and metrics["any_order_match"] == 0: diagnosis = evaluator.diagnose_any_order_match_failure(predicted) self.failure_reasons.append( { "model": model_name, "session": session_id, "chapter_count": chapter_count, "failure_stage": diagnosis["failure_stage"], "missing_steps_count": len(diagnosis["missing_steps"]), "missing_details": diagnosis["missing_details"], "first_missing_step": ( diagnosis["missing_steps"][0] if diagnosis["missing_steps"] else "N/A" ), } ) # Compute averages avg_metrics = {} for key, values in all_metrics.items(): avg_metrics[key] = sum(values) / len(values) if values else 0.0 num_samples = len(trajectories) if num_samples > 0: path_counter = defaultdict(int) for session_id, predicted in trajectories: path_key = tuple(predicted) path_counter[path_key] += 1 unique_paths = len(path_counter) unique_path_ratio = unique_paths / num_samples if num_samples > 0 else 0.0 probs = [count / num_samples for count in path_counter.values()] H = -sum(p * math.log(p) for p in probs if p > 0) if len(probs) > 1: path_entropy = H / math.log(len(probs)) else: path_entropy = 0.0 else: unique_path_ratio = 0.0 path_entropy = 0.0 avg_metrics["unique_path_ratio"] = unique_path_ratio avg_metrics["path_entropy"] = path_entropy # Add sample count avg_metrics["num_samples"] = num_samples return avg_metrics def evaluate_all_models( self, base_dir: str = None, collect_failure_reasons: bool = False ) -> pd.DataFrame: """ Evaluate all models and generate a summary table. Args: base_dir: RESULTS directory path. Defaults to two levels above this script. collect_failure_reasons: Whether to collect any_order_match failure reasons Returns: DataFrame with all model evaluation results """ if base_dir is None: # Default path: two levels above this script base_dir = Path(__file__).parent.parent.parent results = [] # Initialize failure reasons list if collect_failure_reasons: self.failure_reasons = [] for model_name in self.models: print(f"\n📊 Evaluating model: {model_name}") metrics = self.evaluate_model( model_name, str(base_dir), collect_failure_reasons ) if metrics: metrics["model"] = model_name results.append(metrics) print(f" ✅ Done, samples: {metrics['num_samples']}") else: print(f" ❌ Skipped (no data)") if not results: print("\n❌ No model data") return pd.DataFrame() # Create DataFrame df = pd.DataFrame(results) # Reorder columns: model name first cols = [ "model", "num_samples", "exact_match", "in_order_match", "any_order_match", "precision", "recall", "single_tool_use", "unique_path_ratio", "path_entropy", ] # Keep only existing columns cols = [col for col in cols if col in df.columns] df = df[cols] return df def save_failure_reasons(self, output_file: str = "any_order_match_failures.csv"): """ Save any_order_match failure reasons to a CSV file. Args: output_file: Output filename """ if not hasattr(self, "failure_reasons") or not self.failure_reasons: print("\n⚠️ No failure reasons were collected") return output_path = Path(__file__).parent / output_file # Create DataFrame df = pd.DataFrame(self.failure_reasons) # Save as CSV df.to_csv(output_path, index=False, encoding="utf-8") print(f"\n✅ Saved any_order_match failure reasons: {output_path}") # Print a short summary print(f"\n📊 Failure reason summary:") print(f" Total failures: {len(self.failure_reasons)}") # By model print(f"\n By model:") model_counts = df["model"].value_counts() for model, count in model_counts.items(): print(f" {model}: {count} failures") # By failure stage print(f"\n By failure stage:") stage_counts = df["failure_stage"].value_counts() for stage, count in stage_counts.items(): stage_name = { "before_pattern": "Outline stage", "pattern": "Chapter pattern stage", "after_pattern": "Review stage", "simple_match": "Simple match", }.get(stage, stage) print(f" {stage_name}: {count}") # Markdown generation is disabled; this function only writes CSV. def main(): """Main entry point.""" import argparse parser = argparse.ArgumentParser( description="Evaluate trajectory metrics for the BookWriter-A2A project" ) parser.add_argument( "--config", type=str, default="reference_trajectory.yaml", help="Path to the reference trajectory YAML config file", ) parser.add_argument( "--base-dir", type=str, default=None, help="Path to the RESULTS directory (defaults to two levels above this script)", ) parser.add_argument( "--output", type=str, default="evaluation_results.csv", help="Output CSV file path", ) parser.add_argument( "--diagnose-failures", action="store_true", help="Diagnose any_order_match failures and export a CSV report", ) args = parser.parse_args() # If config is a relative path, resolve it relative to this script config_path = args.config if not os.path.isabs(config_path): config_path = os.path.join(os.path.dirname(__file__), config_path) print("=" * 80) print("Trajectory Evaluation Tool - BookWriter-A2A") print("=" * 80) print(f"\n Config file: {config_path}") # Create evaluator evaluator = DatasetEvaluator(config_path) print(f" Project: {evaluator.project_name}") print(f" Reference trajectory: {evaluator.reference_trajectory}") print(f" Target tools: {evaluator.target_tools}") print(f" Models: {evaluator.models}") if args.diagnose_failures: print(" Failure diagnosis enabled") # Evaluate all models df = evaluator.evaluate_all_models( args.base_dir, collect_failure_reasons=args.diagnose_failures ) if df.empty: print("\n Evaluation failed: no data") return print("\n" + "=" * 80) print(" Evaluation Summary") print("=" * 80) # Format display pd.set_option("display.max_columns", None) pd.set_option("display.width", None) pd.set_option("display.float_format", lambda x: f"{x:.4f}") print("\n" + df.to_string(index=False)) # Save results output_dir = os.path.dirname(args.output) or "." os.makedirs(output_dir, exist_ok=True) csv_file = args.output df.to_csv(csv_file, index=False) print(f"\n Saved CSV: {csv_file}") # Save failure reasons (if enabled) if args.diagnose_failures: evaluator.save_failure_reasons() print("\n" + "=" * 80) print("✅ Evaluation completed") print("=" * 80) if __name__ == "__main__": main()