data/processed/RQ1/SocialMediaManager-H_A2A/evaluate_trajectory-mix.py

#!/usr/bin/env python3
"""
Trajectory evaluation script - SocialMediaManager-H_A2A.

Evaluates 6 trajectory metrics:
1. Exact match
2. In-order match
3. Any-order match
4. Precision
5. Recall
6. Single-tool use

A2A_mix hybrid-architecture notes:
- LangGraph (Topic Analysis): dynamic matching for batched tool execution
- CrewAI (Content Generation): tool-order permutation support
- AutoGen (Post Review): dynamic LLM/Tool pattern matching; filters create_agent and MCP spans
- Triple dynamic composition: LangGraph × CrewAI × AutoGen
"""

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 `execution_path.md` and extract the full execution trajectory."""

    def __init__(self, md_file_path: str, extract_types: List[str] = None):
        """
        Args:
            md_file_path: Path to `execution_path.md`
            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 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 fenced 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"):
            # Remove tree-drawing characters and keep node content
            clean_line = re.sub(r"^[│├└─\s]+", "", line).strip()
            if not clean_line:
                continue

            # Remove error marker
            clean_line = re.sub(r"^❌\s+", "", clean_line)

            # Remove 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)

            # Remove ERROR info (keep node type/name, drop the [ERROR: ...] payload)
            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 info from one line.

        Note: the input `line` should already have had error markers (), retry markers, and ERROR info removed.

        Returns:
            {'type': str, 'action': str} or None
        """
        # SPAN node: [SPAN] span_name [stats]
        # Use a tolerant match to handle any remaining special characters.
        span_match = re.match(r"\[SPAN\]\s+([^\[]+?)(?:\s+\[.*?\])*\s*$", line)
        if span_match:
            span_name = span_match.group(1).strip()
            # A2A_mix special-case: filter AutoGen MCP client/operation spans
            if span_name == "mcp client/operation" or span_name.startswith("mcp "):
                return None
            return {"type": "SPAN", "action": f"SPAN: {span_name}"}

        # Chain node: [Chain] chain_name [stats]
        # For Crew_xxx.kickoff format, use wildcard Crew***.kickoff
        chain_match = re.match(r"\[Chain\]\s+([^\[]+?)(?:\s+\[.*?\])*\s*$", line)
        if chain_match:
            chain_name = chain_match.group(1).strip()
            # Wildcard normalization: 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 [stats]
        # A2A_mix special-case: filter AutoGen create_agent; keep only invoke_agent
        agent_match = re.match(r"\[AGENT\]\s+([^\[]+?)(?:\s+\[.*?\])*\s*$", line)
        if agent_match:
            agent_name = agent_match.group(1).strip()
            # Filter create_agent (AutoGen-specific init, excluded from evaluation)
            if agent_name.startswith("create_agent"):
                return None
            # 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 implementing 6 evaluation metrics.

    A2A_mix: supports dynamic reference-trajectory selection.
    """

    def __init__(self, reference_trajectory: List[str]):
        """
        Args:
            reference_trajectory: Reference trajectory (ground truth)
        """
        self.reference = reference_trajectory

    @staticmethod
    def detect_langgraph_tools_pattern(predicted: List[str]) -> tuple:
        """Detect the LangGraph Topic Analysis `tools` grouping pattern and actual tool order.

        Returns:
            (pattern, actual_tools)
            - pattern: grouping pattern, e.g. [1,1] / [2]
            - actual_tools: tools observed in the trace (in order)
            If detection fails, returns ([], [])
        """
        # Locate Chain: LangGraph
        start_idx = -1
        for i, s in enumerate(predicted):
            if s == "Chain: LangGraph":
                start_idx = i
                break

        if start_idx == -1:
            return ([], [])

        # Count Chain: tools groups and collect actual tools
        group_counts = []
        actual_tools = []
        i = start_idx

        while i < len(predicted):
            s = predicted[i]

            # When hitting Chain: tools, count tools under it
            if s == "Chain: tools":
                count = 0
                i += 1
                # Count until the next Chain or AGENT
                while i < len(predicted):
                    if predicted[i].startswith("Chain: ") or predicted[i].startswith(
                        "AGENT: "
                    ):
                        break
                    if predicted[i].startswith("Tool: "):
                        actual_tools.append(predicted[i])
                        count += 1
                    i += 1

                if count > 0:
                    group_counts.append(count)
            # Chain: format_output indicates the end of LangGraph stage
            elif s == "Chain: format_output":
                break
            else:
                i += 1

        # Validate grouping pattern
        if not group_counts:
            return ([], [])

        total = sum(group_counts)
        # Topic Analysis has 2 tools
        if total != 2:
            return ([], [])

        # Validate allowed patterns
        allowed = {(1, 1), (2,)}

        if tuple(group_counts) not in allowed:
            return ([], [])

        return (group_counts, actual_tools)

    @staticmethod
    def build_langgraph_reference_variant(
        base_reference: List[str], pattern: List[int], tool_order: List[str] = None
    ) -> List[str]:
        """Build a reference trajectory variant for the Topic Analysis part based on the tools grouping pattern and tool order.

        Args:
            base_reference: Base reference trajectory
            pattern: tools grouping pattern, e.g. [1,1] or [2]
            tool_order: Tool order, default is ["Tool: keyword_extractor", "Tool: topic_complexity_analyzer"]

        Returns:
            Adjusted reference trajectory
        """
        try:
            # Find the start and end positions of the Topic Analysis stage
            start_idx = base_reference.index("Chain: LangGraph")

            # Find the position of Chain: format_output (end of Topic Analysis)
            end_idx = -1
            for i in range(start_idx, len(base_reference)):
                if base_reference[i] == "Chain: format_output":
                    end_idx = i
                    break

            if end_idx == -1:
                return base_reference

            # Separate the trajectory into three parts: before, Topic Analysis, and after
            before = base_reference[: start_idx + 1]  # includes Chain: LangGraph
            after = base_reference[end_idx:]  # from format_output onwards

            # Build the new Topic Analysis part
            topic_analysis_part = [
                "AGENT: agent",
                "LLM: *",
                "Chain: _should_continue",
            ]

            # Default tool order
            if tool_order is None:
                tools = ["Tool: keyword_extractor", "Tool: topic_complexity_analyzer"]
            else:
                tools = tool_order

            # Add Chain: tools and Tool based on the pattern
            tool_idx = 0
            for count in pattern:
                topic_analysis_part.append("Chain: tools")
                for _ in range(count):
                    if tool_idx < len(tools):
                        topic_analysis_part.append(tools[tool_idx])
                        tool_idx += 1

            # Add the second AGENT
            topic_analysis_part.extend(
                [
                    "AGENT: agent",
                    "LLM: *",
                    "Chain: _should_continue",
                ]
            )

            # Combine the full trajectory
            return before + topic_analysis_part + after

        except (ValueError, IndexError):
            # If parsing fails, return the original reference
            return base_reference

    @staticmethod
    def detect_autogen_tools(predicted: List[str]) -> List[str]:
        """Detect the tools used in the AutoGen Post Review stage.

        Returns:
            List of tool names (in order), or an empty list if not found
        """
        # Find the position of invoke_agent x_post_verifier
        start_idx = -1
        for i, s in enumerate(predicted):
            if s == "AGENT: invoke_agent x_post_verifier":
                start_idx = i
                break

        if start_idx == -1:
            return []

        # Extract the tools under invoke_agent
        tools = []
        i = start_idx + 1

        # Find the next SPAN (end of Post Review)
        while i < len(predicted):
            s = predicted[i]
            if s.startswith("SPAN: "):
                break

            if s.startswith("Tool: execute_tool "):
                tools.append(s)

            i += 1

        return tools

    @staticmethod
    def generate_autogen_llm_patterns(num_tools: int) -> List[List[int]]:
        """Generate all possible LLM insertion patterns for the AutoGen stage.

        Args:
            num_tools: Number of tools

        Returns:
            List of LLM insertion patterns, where each pattern is a list of 0/1 values
        """
        if num_tools < 2:
            return [[]]  # Less than 2 tools, no insertion needed

        # n tools have n-1 gaps
        num_gaps = num_tools - 1

        # Enumerate all 0/1 combinations: 2^(n-1) possibilities
        patterns = []
        for i in range(2**num_gaps):
            pattern = []
            for j in range(num_gaps):
                # Extract the j-th bit value (0 or 1)
                pattern.append((i >> j) & 1)
            patterns.append(pattern)

        return patterns

    @staticmethod
    def build_autogen_reference_variant(
        base_reference: List[str], llm_pattern: List[int], tool_order: List[str] = None
    ) -> List[str]:
        """Build a reference trajectory variant for the Post Review part based on the LLM insertion pattern and tool order.

        Args:
            base_reference: Base reference trajectory
            llm_pattern: LLM insertion pattern, e.g. [0,0,0,0] or [1,1,1,1]
            tool_order: Tool order, default is the order in the base reference

        Returns:
            Adjusted reference trajectory
        """
        try:
            # Find the position of invoke_agent x_post_verifier
            start_idx = base_reference.index("AGENT: invoke_agent x_post_verifier")

            # Find the end of this stage (next SPAN or end of list)
            end_idx = len(base_reference)
            for i in range(start_idx + 1, len(base_reference)):
                if base_reference[i].startswith("SPAN: "):
                    end_idx = i
                    break

            # Extract the tool list from the base reference (if tool_order is not specified)
            if tool_order is None:
                tools = []
                for i in range(start_idx + 1, end_idx):
                    if base_reference[i].startswith("Tool: execute_tool "):
                        tools.append(base_reference[i])
            else:
                tools = tool_order

            if not tools:
                return base_reference

            # Separate the trajectory into three parts: before, Post Review, and after
            before = base_reference[: start_idx + 1]  # includes AGENT
            after = base_reference[end_idx:]  # from next SPAN onwards

            # Build the Post Review part based on the LLM insertion pattern
            review_part = ["LLM: *"]  # starting LLM

            for i, tool in enumerate(tools):
                review_part.append(tool)

                # If not the last tool, check if LLM should be inserted
                if i < len(tools) - 1 and i < len(llm_pattern):
                    if llm_pattern[i] == 1:
                        review_part.append("LLM: *")

            review_part.append("LLM: *")  # ending LLM

            # Combine the full trajectory
            return before + review_part + after

        except (ValueError, IndexError):
            # If parsing fails, return the original reference
            return base_reference

    def _match_action(self, predicted_action: str, reference_action: str) -> bool:
        """
        Match two actions, supporting wildcards.

        Args:
            predicted_action: Actual action
            reference_action: Reference action (may contain wildcards)

        Returns:
            True if match, False otherwise
        """
        # Exact match
        if predicted_action == reference_action:
            return True

        # Wildcard match: LLM: * matches any LLM: <model_name>
        if reference_action == "LLM: *" and predicted_action.startswith("LLM: "):
            return True

        return False

    def exact_match(self, predicted: List[str]) -> int:
        """
        Exact match: predicted trajectory must match the reference trajectory exactly (supports wildcards).

        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 (supports wildcards).
        Allows extra actions, but core steps must appear in order.

        Returns:
            1 if in-order match, 0 otherwise
        """
        if not self.reference:
            return 1  # Empty reference trajectory always matches

        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

        # Check if all reference steps were found in order
        return 1 if ref_idx == len(self.reference) else 0

    def any_order_match(self, predicted: List[str]) -> int:
        """
        Any-order match: predicted trajectory must contain all necessary actions (supports wildcards).
        Does not care about order, allows extra actions.

        Returns:
            1 if any-order match, 0 otherwise
        """
        if not self.reference:
            return 1

        # Create a copy of the predicted actions for matching
        pred_remaining = predicted.copy()

        # For each reference action, try to find a match in the predicted actions
        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)  # Remove the matched action
                    matched = True
                    break

            if not matched:
                return 0  # Reference action not found

        return 1

    def precision(self, predicted: List[str]) -> float:
        """
        Precision: proportion of predicted actions that are correct according to the reference trajectory (supports wildcards).

        Precision = TP / (TP + FP)
        TP: number of correct tool calls in the predicted trajectory
        FP: number of incorrect or extra tool calls in the predicted trajectory

        Returns:
            precision value (0.0 - 1.0)
        """
        if not predicted:
            return 1.0  # No predicted actions, no incorrect predictions

        if not self.reference:
            return 0.0  # Reference is empty, but there are predicted actions, all incorrect

        # Create a copy of the 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 actions
            for i, ref_action in enumerate(ref_remaining):
                if self._match_action(pred_action, ref_action):
                    tp += 1
                    ref_remaining.pop(i)  # Remove the matched action
                    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: proportion of reference actions that are covered by the predicted trajectory (supports wildcards).

        Recall = TP / (TP + FN)
        TP: number of necessary actions covered by the predicted trajectory
        FN: number of necessary actions not covered by the predicted trajectory

        Returns:
            recall value (0.0 - 1.0)
        """
        if not self.reference:
            return 1.0  # Reference is empty, nothing to recall

        if not predicted:
            return 0.0  # No predicted actions, recall is 0

        # Create a copy of the 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 predicted actions
            for i, pred_action in enumerate(pred_remaining):
                if self._match_action(pred_action, ref_action):
                    tp += 1
                    pred_remaining.pop(i)  # Remove the matched action
                    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 if a specific tool is used in the trajectory (supports wildcards).

        Args:
            predicted: Predicted trajectory
            tool_name: Target tool name

        Returns:
            1 if tool is used, 0 otherwise
        """
        # Check if any action in the predicted trajectory matches the target tool
        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: List of tools to check for single-tool use

        Returns:
            Dictionary of all metric 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 metric - calculate overall usage rate (average across all 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: YAML config path containing reference-trajectory definitions
        """
        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", "SocialMediaManager-A2A")
        # Extraction types: default is Tool only; can be configured to include AGENT, SPAN, etc.
        self.extract_types = self.config.get("extract_types", ["Tool"])
        # Permutable tool-group configuration
        self.permutable_tool_groups = self.config.get("permutable_tool_groups", {})

    def _load_config(self) -> Dict:
        """Load YAML config."""
        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 permuted trajectories based on the permutable tool groups.

        Args:
            base_trajectory: Base reference trajectory

        Returns:
            List of all possible permuted trajectories (including the original)
        """
        if not self.permutable_tool_groups:
            # No permutable tool groups configured; return the base trajectory.
            return [base_trajectory]

        # Collect all 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 are found
            if len(positions) == len(tools):
                # Record positions and tools for this group
                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 permutable tool group found
            return [base_trajectory]

        # Generate all possible permutation combinations
        all_trajectories = []

        # Generate permutations per tool group
        group_permutations = []
        for positions, tools in tool_groups_positions:
            # Generate all permutations for this tool 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]]:
        """
        Select the best reference trajectory from multiple candidates (with early-stop optimization).

        Args:
            predicted: Predicted trajectory
            candidate_references: Candidate reference trajectories

        Returns:
            (best reference trajectory, matching metrics)
        """
        best_reference = candidate_references[0]
        best_score = -1
        best_metrics = {}

        for ref_trajectory in candidate_references:
            evaluator = TrajectoryEvaluator(ref_trajectory)

            # Compute the three key matching metrics
            exact = evaluator.exact_match(predicted)

            # Early stop: return immediately on an exact match
            if exact == 1:
                return ref_trajectory, {
                    "exact_match": 1,
                    "in_order_match": 1,
                    "any_order_match": 1,
                }

            in_order = evaluator.in_order_match(predicted)
            any_order = evaluator.any_order_match(predicted)

            # Composite score: exact_match has the highest weight, then in_order_match
            # Weighted sum: 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: RESULTS directory path

        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 over 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 extraction 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) -> Dict[str, float]:
        """
        Evaluate a single model across all samples (A2A_mix enhanced).

        Args:
            model_name: Model name
            base_dir: RESULTS directory path

        Returns:
            Dictionary of average metrics
        """
        model_dir = Path(base_dir) / model_name / self.project_name / "test_results"

        if not model_dir.exists():
            print(f"⚠️  No trajectory data found for model {model_name}")
            return {}

        # Accumulate metrics for all samples
        all_metrics = defaultdict(list)
        trajectories = []

        # Iterate over all sessions
        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
            parser = TrajectoryParser(
                str(exec_path_file), extract_types=self.extract_types
            )
            predicted = parser.parse()

            # Use the default reference trajectory as the base
            base_reference = self.reference_trajectory

            # ====== A2A_mix optimization: detect actual tool order ======
            # 1. Detect LangGraph tools grouping pattern and actual tool order
            langgraph_pattern, langgraph_actual_tools = (
                TrajectoryEvaluator.detect_langgraph_tools_pattern(predicted)
            )

            # 2. Only use the LangGraph tool order observed in this sample
            if langgraph_actual_tools:
                langgraph_tool_orders = [langgraph_actual_tools]  # observed order only
            else:
                langgraph_tool_orders = [None]

            # 3. Detect the AutoGen tool order observed in this sample
            autogen_actual_tools = TrajectoryEvaluator.detect_autogen_tools(predicted)
            num_autogen_tools = len(autogen_actual_tools)

            # 4. Generate AutoGen LLM insertion patterns (still enumerated; structural variability)
            autogen_llm_patterns = (
                TrajectoryEvaluator.generate_autogen_llm_patterns(num_autogen_tools)
                if num_autogen_tools > 0
                else [[]]
            )

            # 5. Only use the AutoGen tool order observed in this sample
            if autogen_actual_tools:
                autogen_tool_orders = [autogen_actual_tools]  # observed order only
            else:
                autogen_tool_orders = [None]

            # 6. Generate CrewAI tool permutations (still enumerated; order is genuinely variable)
            crewai_references = self._generate_permuted_trajectories(base_reference)

            # 7. Combine variants across all dimensions (reduced search space)
            # Now: 1 (LG order) × 16 (AG LLM) × 1 (AG order) × 120 (CA perm) = 1,920 candidates
            candidate_references = []

            # If a LangGraph pattern is detected, generate corresponding variants
            if langgraph_pattern:
                for crewai_ref in crewai_references:
                    for lg_tool_order in langgraph_tool_orders:
                        langgraph_ref = (
                            TrajectoryEvaluator.build_langgraph_reference_variant(
                                crewai_ref, langgraph_pattern, lg_tool_order
                            )
                        )

                        # For each LangGraph variant, generate all AutoGen combinations
                        for ag_llm_pattern in autogen_llm_patterns:
                            for ag_tool_order in autogen_tool_orders:
                                final_ref = (
                                    TrajectoryEvaluator.build_autogen_reference_variant(
                                        langgraph_ref, ag_llm_pattern, ag_tool_order
                                    )
                                )
                                candidate_references.append(final_ref)
            else:
                # If no LangGraph pattern is detected, combine CrewAI and AutoGen only
                for crewai_ref in crewai_references:
                    for ag_llm_pattern in autogen_llm_patterns:
                        for ag_tool_order in autogen_tool_orders:
                            final_ref = (
                                TrajectoryEvaluator.build_autogen_reference_variant(
                                    crewai_ref, ag_llm_pattern, ag_tool_order
                                )
                            )
                            candidate_references.append(final_ref)

            # If no candidates were generated, fall back to the base reference
            if not candidate_references:
                candidate_references = [base_reference]

            # Select the best reference trajectory from all candidates
            if len(candidate_references) > 1:
                reference, _ = self._find_best_reference_trajectory(
                    predicted, candidate_references
                )
            else:
                reference = candidate_references[0]

            # Create evaluator and evaluate (using the best reference trajectory)
            evaluator = TrajectoryEvaluator(reference)
            metrics = evaluator.evaluate_all(predicted, self.target_tools)

            for key, value in metrics.items():
                all_metrics[key].append(value)

            trajectories.append((session_dir.name, predicted))

        # 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) -> pd.DataFrame:
        """
        Evaluate all models and build a summary table.

        Args:
            base_dir: RESULTS directory path (default: two levels above this script)

        Returns:
            A DataFrame containing evaluation results for all models
        """
        if base_dir is None:
            # Default path: two levels above this script
            base_dir = Path(__file__).parent.parent.parent

        results = []

        for model_name in self.models:
            print(f"\n📊 Evaluating model: {model_name}")
            metrics = self.evaluate_model(model_name, str(base_dir))

            if metrics:
                metrics["model"] = model_name
                results.append(metrics)
                print(f"  ✅ Done. Samples: {metrics['num_samples']}")
            else:
                print("  ❌ Skipped (no data)")

        if not results:
            print("\n❌ No model data found")
            return pd.DataFrame()

        # Create DataFrame
        df = pd.DataFrame(results)

        # Reorder columns: model 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 main():
    """Entry point."""
    import argparse

    parser = argparse.ArgumentParser(
        description="Evaluate trajectory metrics for SocialMediaManager-H_A2A (hybrid architecture)"
    )
    parser.add_argument(
        "--config",
        type=str,
        default="reference_trajectory.yaml",
        help="Reference-trajectory config path (YAML)",
    )
    parser.add_argument(
        "--base-dir",
        type=str,
        default=None,
        help="RESULTS directory path (default: two levels above this script)",
    )
    parser.add_argument(
        "--output",
        type=str,
        default="evaluation_results.csv",
        help="Output CSV file path",
    )

    args = parser.parse_args()

    # If config is not an absolute path, resolve 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 - SocialMediaManager-H_A2A (Hybrid Architecture)")
    print("=" * 80)
    print(f"\n📁 Config: {config_path}")

    # Create evaluator
    evaluator = DatasetEvaluator(config_path)

    print(f"📋 Project: {evaluator.project_name}")
    print(f"🎯 Reference length: {len(evaluator.reference_trajectory)} steps")
    print(f"🔧 Target tools: {len(evaluator.target_tools)}")
    print(f"🤖 Models: {evaluator.models}")

    # Display A2A_mix dynamic-matching information
    print("\n🔀 A2A_mix dynamic matching: enabled")
    print(
        "   ✨ Optimization: detect the actual tool order per sample to avoid blind enumeration"
    )
    print(f"")
    print("   Supported dynamic dimensions:")
    print("   - LangGraph tools grouping: auto-detect [1,1] or [2]")
    print("   - LangGraph tool order: adapt to the sample's actual order")
    print("   - AutoGen LLM/Tool interleaving: enumerate 2^4 = 16 patterns")
    print("   - AutoGen tool order: adapt to the sample's actual order")

    # CrewAI tool permutations
    if evaluator.permutable_tool_groups:
        crewai_permutations = 1
        for group_name, tools in evaluator.permutable_tool_groups.items():
            num_perms = math.factorial(len(tools))
            crewai_permutations *= num_perms
            print(f"   - CrewAI {group_name}: enumerate {num_perms} permutations")
        actual_combinations = 1 * 16 * 1 * crewai_permutations
        print(f"")
        print(
            f"   Actual candidates: 1 (LG order) × 16 (AG interleave) × 1 (AG order) × {crewai_permutations} (CA perm) = {actual_combinations:,}"
        )
        print(
            f"   Theoretical max: 2 × 2 × 16 × 120 × {crewai_permutations} = {2 * 2 * 16 * 120 * crewai_permutations:,}"
        )
    else:
        print("   - CrewAI tool permutations: disabled")
        actual_combinations = 1 * 16 * 1
        print(f"")
        print(f"   Actual candidates: 1 × 16 × 1 = {actual_combinations:,}")
        print(f"   Theoretical max: 2 × 2 × 16 × 120 = {2 * 2 * 16 * 120:,}")

    print(f"")
    print("   📈 Performance:")
    print("   - Smart detection: only match the tool order actually used by the sample")
    print("   - Early stop: stop immediately when exact_match = 1")
    print("   - Scoring: exact×3 + in_order×2 + any_order×1")

    # Evaluate all models
    df = evaluator.evaluate_all_models(args.base_dir)

    if df.empty:
        print("\n❌ Evaluation failed: no data")
        return

    print("\n" + "=" * 80)
    print("📊 Summary")
    print("=" * 80)

    # Formatting for 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 (CSV only)
    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✅ CSV saved: {csv_file}")

    print("\n" + "=" * 80)
    print("✅ Done")
    print("=" * 80)


if __name__ == "__main__":
    main()