dataclaw/utils/process_grading.py

"""
Process-oriented grading metrics for DataClaw.

Provides fine-grained evaluation of agent execution trajectories
beyond outcome-only scoring.

Metrics implemented:
- Execution Efficiency: S_gold / S_agent
- Goal Progress Rate (GPR): LLM-Judge-based milestone evaluation
"""

from __future__ import annotations

import json
import logging
import math
import random
import re
from dataclasses import dataclass, field
from pathlib import Path
from typing import Any, Dict, List, Optional, Tuple

logger = logging.getLogger(__name__)

# ---------------------------------------------------------------------------
# Constants
# ---------------------------------------------------------------------------

NUMERIC_REL_TOL = 0.01      # 1% relative tolerance for candidate extraction
NUMERIC_ABS_TOL = 1e-6      # absolute tolerance for values near zero
SNIPPET_CONTEXT_CHARS = 300  # ~100 tokens context window around matches
SHORT_RESULT_TOKEN_THRESHOLD = 1000  # tool results <= this are included whole
HIGH_FREQ_THRESHOLD = 5             # value occurrences above this trigger key-proximity filter
MAX_SNIPPETS_WHEN_HIGH_FREQ = 5      # max snippets to randomly sample when high-freq filtered
CHARS_PER_TOKEN = 3                  # rough chars-per-token estimate for token counting
ARG_MAX_BYTES = 2 * 1024 * 1024     # Linux ARG_MAX ~2MB — prompt size guard before subprocess


# ---------------------------------------------------------------------------
# Numeric helpers
# ---------------------------------------------------------------------------

def _is_numeric(value: Any) -> bool:
    if isinstance(value, bool):
        return False
    return isinstance(value, (int, float))


def _numbers_match(expected: float, actual: float) -> bool:
    if math.isnan(expected) or math.isnan(actual):
        return False
    if expected == actual:
        return True
    if abs(expected) < NUMERIC_ABS_TOL:
        return abs(actual - expected) < NUMERIC_ABS_TOL
    return abs(actual - expected) / abs(expected) <= NUMERIC_REL_TOL


# ---------------------------------------------------------------------------
# Trajectory parsing
# ---------------------------------------------------------------------------

@dataclass
class AgentStep:
    """A single agent step, corresponding to one assistant turn."""
    index: int
    tool_calls: List[Dict[str, Any]]
    text: str
    tool_results: List[str] = field(default_factory=list)
    timestamp: Optional[str] = None

    @property
    def has_tool_call(self) -> bool:
        return len(self.tool_calls) > 0

    @property
    def tool_call_count(self) -> int:
        return len(self.tool_calls)

    @property
    def full_text(self) -> str:
        parts = []
        if self.text:
            parts.append(self.text)
        parts.extend(self.tool_results)
        return "\n".join(parts)


def parse_trajectory(transcript_path: Path) -> List[AgentStep]:
    """Parse chat.jsonl into a list of AgentSteps.

    Each assistant message is one step. Tool results following an
    assistant turn are attached to that step.
    """
    if not transcript_path.exists():
        logger.warning("Transcript not found: %s", transcript_path)
        return []

    messages: List[Dict[str, Any]] = []
    for line in transcript_path.read_text(encoding="utf-8").splitlines():
        line = line.strip()
        if not line:
            continue
        try:
            entry = json.loads(line)
        except json.JSONDecodeError:
            continue
        if entry.get("type") != "message":
            continue
        messages.append(entry)

    steps: List[AgentStep] = []
    current_step: Optional[AgentStep] = None
    step_index = 0

    for entry in messages:
        msg = entry.get("message", {})
        role = msg.get("role", "")

        if role == "assistant":
            content = msg.get("content", []) or []
            text_parts: List[str] = []
            tool_calls: List[Dict[str, Any]] = []

            for item in content:
                if item.get("type") == "text" and item.get("text"):
                    text_parts.append(item["text"])
                elif item.get("type") == "toolCall":
                    tool_calls.append({
                        "id": item.get("id", ""),
                        "name": item.get("name", ""),
                        "arguments": item.get("arguments", {}),
                    })

            step_index += 1
            current_step = AgentStep(
                index=step_index,
                tool_calls=tool_calls,
                text="\n".join(text_parts).strip(),
                timestamp=msg.get("timestamp") or entry.get("timestamp"),
            )
            steps.append(current_step)

        elif role == "toolResult" and current_step is not None:
            content = msg.get("content", []) or []
            for item in content:
                if item.get("type") == "text" and item.get("text"):
                    current_step.tool_results.append(item["text"])

        else:
            current_step = None

    return steps


# ---------------------------------------------------------------------------
# Execution Efficiency
# ---------------------------------------------------------------------------

@dataclass
class EfficiencyResult:
    s_agent: int
    s_gold: int
    efficiency: Optional[float]

    def to_dict(self) -> Dict[str, Any]:
        return {
            "s_agent": self.s_agent,
            "s_gold": self.s_gold,
            "efficiency": self.efficiency,
        }


def compute_efficiency(steps: List[AgentStep], s_gold: int) -> EfficiencyResult:
    """Compute Execution Efficiency = S_gold / S_agent."""
    s_agent = len(steps)
    if s_agent == 0:
        return EfficiencyResult(s_agent=0, s_gold=s_gold, efficiency=None)
    return EfficiencyResult(
        s_agent=s_agent,
        s_gold=s_gold,
        efficiency=round(s_gold / s_agent, 4),
    )


# ---------------------------------------------------------------------------
# GPR: Candidate snippet extraction
# ---------------------------------------------------------------------------

@dataclass
class CandidateSnippet:
    """A context snippet from a tool result containing milestone candidate values."""
    snippet: str
    milestone_matches: List[Tuple[str, float, float]]  # (key, expected, matched)
    tool_result_index: int


def _extract_candidates_for_step(
    step: AgentStep,
    numeric_milestones: Dict[str, float],
    context_chars: int = SNIPPET_CONTEXT_CHARS,
) -> List[CandidateSnippet]:
    """Extract context snippets around numeric milestone matches in tool results.

    Short tool results (≤ SHORT_RESULT_TOKEN_THRESHOLD tokens) are included whole.

    For long tool results, windows are extracted per milestone.  If a milestone
    value appears more than HIGH_FREQ_THRESHOLD times (likely a raw data column),
    only snippets that contain at least one component of the milestone key name
    are kept, and at most MAX_SNIPPETS_WHEN_HIGH_FREQ are randomly sampled.
    If none survive the key-proximity filter, the milestone is skipped for that
    tool result entirely.
    """
    snippets: List[CandidateSnippet] = []

    for tr_idx, tr_text in enumerate(step.tool_results):
        approx_tokens = len(tr_text) // CHARS_PER_TOKEN

        if approx_tokens <= SHORT_RESULT_TOKEN_THRESHOLD:
            # Short result: include whole text, annotate with all matching milestones
            matched: List[Tuple[str, float, float]] = []
            seen_keys: set = set()
            for num_match in re.finditer(r'-?\d+(?:\.\d+)?', tr_text):
                try:
                    num_val = float(num_match.group())
                except ValueError:
                    continue
                for key, expected in numeric_milestones.items():
                    if key not in seen_keys and _numbers_match(expected, num_val):
                        matched.append((key, expected, num_val))
                        seen_keys.add(key)
            if matched:
                snippets.append(CandidateSnippet(
                    snippet=tr_text,
                    milestone_matches=matched,
                    tool_result_index=tr_idx,
                ))
            continue

        # Long result: per-milestone window extraction + frequency-based filtering
        for key, expected in numeric_milestones.items():
            # Collect all positions where this milestone value appears
            match_positions: List[Tuple[int, int, float]] = []
            for num_match in re.finditer(r'-?\d+(?:\.\d+)?', tr_text):
                try:
                    num_val = float(num_match.group())
                except ValueError:
                    continue
                if _numbers_match(expected, num_val):
                    match_positions.append((num_match.start(), num_match.end(), num_val))

            if not match_positions:
                continue

            value_freq = len(match_positions)

            # Build and merge overlapping windows
            raw_windows = [
                (max(0, start - context_chars), min(len(tr_text), end + context_chars), val)
                for start, end, val in match_positions
            ]
            raw_windows.sort()
            cur_start, cur_end, cur_val = raw_windows[0]
            merged_windows: List[Tuple[int, int, float]] = []
            for start, end, val in raw_windows[1:]:
                if start <= cur_end:
                    cur_end = max(cur_end, end)
                else:
                    merged_windows.append((cur_start, cur_end, cur_val))
                    cur_start, cur_end, cur_val = start, end, val
            merged_windows.append((cur_start, cur_end, cur_val))

            candidate_texts: List[Tuple[str, float]] = [
                (tr_text[s:e], v) for s, e, v in merged_windows
            ]

            if value_freq > HIGH_FREQ_THRESHOLD:
                # High-frequency value: require key component in snippet
                key_parts = [p.lower() for p in key.split('_') if p]
                filtered = [
                    (s, v) for s, v in candidate_texts
                    if any(part in s.lower() for part in key_parts)
                ]
                if not filtered:
                    continue  # no reliable evidence for this milestone in this tool result
                candidate_texts = random.sample(
                    filtered, min(MAX_SNIPPETS_WHEN_HIGH_FREQ, len(filtered))
                )

            for snippet_text, matched_val in candidate_texts:
                snippets.append(CandidateSnippet(
                    snippet=snippet_text,
                    milestone_matches=[(key, expected, matched_val)],
                    tool_result_index=tr_idx,
                ))

    return snippets


# ---------------------------------------------------------------------------
# GPR: Judge prompt construction
# ---------------------------------------------------------------------------

def build_gpr_judge_prompt(
    steps: List[AgentStep],
    milestones: Dict[str, Any],
    gold_steps: List[str],
    final_answer_correct: bool,
) -> str:
    """Build the LLM Judge prompt for GPR milestone evaluation.

    Constructs the prompt with:
    1. Gold reference steps and milestones
    2. Final answer correctness status
    3. Agent trajectory with assistant text + candidate snippets

    If the assembled prompt exceeds ARG_MAX_BYTES, falls back to a text-only
    trajectory (no tool-result snippets) to stay within the Linux ARG_MAX limit.
    """
    # --- Format gold steps ---
    steps_formatted = "\n".join(
        f"{i + 1}. {s}" for i, s in enumerate(gold_steps)
    )

    # --- Format milestones ---
    milestone_lines = []
    for i, (key, value) in enumerate(milestones.items()):
        milestone_lines.append(f"M{i + 1}. {key}: {value}")
    milestones_formatted = "\n".join(milestone_lines)

    # --- Extract numeric milestones for candidate search ---
    numeric_milestones = {
        k: float(v) for k, v in milestones.items() if _is_numeric(v)
    }

    # --- Final answer status ---
    final_answer_status = (
        "The agent's final answer is CORRECT."
        if final_answer_correct
        else "The agent's final answer is INCORRECT."
    )

    # --- Inner helpers ---
    def _format_trajectory(include_candidates: bool) -> str:
        parts: List[str] = []
        for step in steps:
            lines: List[str] = [f"### Step {step.index}"]

            if step.text:
                lines.append(f"Assistant: {step.text}")
            else:
                lines.append("Assistant: (no text)")

            if include_candidates:
                candidates = _extract_candidates_for_step(step, numeric_milestones)
                if candidates:
                    for c in candidates:
                        keys_str = ", ".join(
                            f"{k}≈{matched}" for k, _exp, matched in c.milestone_matches
                        )
                        lines.append(f"[Candidate: {keys_str}]")
                        lines.append(c.snippet)
                elif step.tool_results:
                    lines.append("(tool executed, no milestone candidates detected)")
            else:
                if step.tool_results:
                    lines.append("(tool executed, results omitted — prompt size limit)")

            parts.append("\n".join(lines))
        return "\n\n".join(parts)

    def _assemble(trajectory: str) -> str:
        return f"""\
You are a milestone evaluator for an AI agent benchmark. Your task is to determine \
which milestones an agent achieved during its execution trajectory.

## Reference Solution Path

The following ordered steps describe the gold-standard approach to solving this task. \
Milestones are key intermediate results that should be produced along this path.

### Gold Steps (in order)
{steps_formatted}

### Milestones to Evaluate
{milestones_formatted}

## Agent Execution Trajectory

Below is a reconstruction of the agent's work, organized by step (assistant turn). \
For each step, "Assistant" is the agent's own text output. "Candidate" sections are \
excerpts from tool execution outputs where milestone-relevant values were detected \
by numeric matching. These candidates may or may not be true milestone achievements — \
you must verify the semantic context.

{trajectory}

## Evaluation Rules

1. **Direct evidence**: A milestone is achieved if the trajectory clearly shows the \
agent computed or obtained the expected value (or a value within 1% relative error) \
in the CORRECT semantic context. A number appearing in an unrelated context \
(e.g., a value for Province A matching a milestone defined for Province B) does NOT count.

2. **Temporal coupling inference**: Milestones follow a logical dependency chain as \
defined in the Gold Steps. If a downstream milestone is correctly achieved, its \
upstream dependencies can be inferred as achieved — even if they were not explicitly \
output. For example, if the agent correctly computed "ratio = A/B", then milestones \
for computing A and B can be inferred as achieved.

3. **Chain-break identification**: If the final answer is INCORRECT, identify the \
earliest milestone in the logical chain that was NOT achieved — this is the \
"break point" where the agent's reasoning diverged from the correct path.

4. **Different-but-valid paths**: The agent may use a different method than the gold \
steps. Judge milestone achievement based on whether the agent obtained the correct \
intermediate values, regardless of method.

## Output Format

Respond with ONLY a JSON object. No markdown fences, no extra text.

{{"milestones": [{{"key": "milestone key", "achieved": true, "evidence_type": "direct", "first_step": 4, "reason": "brief justification"}}, ...], "break_point": null, "chain_summary": "one-sentence summary"}}

Where:
- "achieved": true or false
- "evidence_type": "direct" (found in trajectory), "inferred" (implied by downstream achievement), or "final_answer" (implied by correct final answer)
- "first_step": the agent Step number where this milestone was first achieved (integer), or null if not achieved. For "inferred" milestones, use the step of the downstream milestone that implies it. For "final_answer" milestones, use the step of the agent's final answer.
- "break_point": null if all achieved, otherwise 0-based index of first unachieved milestone
- "chain_summary": where and why the chain broke, or "All milestones achieved" if none broke"""

    # --- Assemble with candidates; fall back to text-only if prompt is too large ---
    prompt = _assemble(_format_trajectory(include_candidates=True))
    prompt_bytes = len(prompt.encode("utf-8"))
    if prompt_bytes > ARG_MAX_BYTES:
        logger.warning(
            "GPR judge prompt is %d bytes, exceeds ARG_MAX (%d bytes); "
            "falling back to text-only trajectory",
            prompt_bytes, ARG_MAX_BYTES,
        )
        prompt = _assemble(_format_trajectory(include_candidates=False))

    return prompt


# ---------------------------------------------------------------------------
# GPR: Judge response parsing
# ---------------------------------------------------------------------------

@dataclass
class MilestoneResult:
    """Evaluation result for a single milestone."""
    key: str
    expected: Any
    achieved: bool
    evidence_type: str = ""   # "direct" | "inferred" | "final_answer"
    reason: str = ""
    first_step: Optional[int] = None

    def to_dict(self) -> Dict[str, Any]:
        d: Dict[str, Any] = {
            "key": self.key,
            "expected": self.expected,
            "achieved": self.achieved,
            "evidence_type": self.evidence_type,
            "reason": self.reason,
        }
        if self.first_step is not None:
            d["first_step"] = self.first_step
        return d


@dataclass
class GPRResult:
    """Result of the Goal Progress Rate metric."""
    gpr: float
    milestones_total: int
    milestones_achieved: int
    break_point: Optional[int]
    chain_summary: str
    details: List[MilestoneResult]

    def to_dict(self) -> Dict[str, Any]:
        return {
            "gpr": self.gpr,
            "milestones_total": self.milestones_total,
            "milestones_achieved": self.milestones_achieved,
            "break_point": self.break_point,
            "chain_summary": self.chain_summary,
            "details": [d.to_dict() for d in self.details],
        }


def _parse_json_from_text(raw_text: str) -> Dict[str, Any]:
    """Extract a JSON object from free-form text (handles markdown fences, etc.)."""
    # Try code blocks first
    code_block = re.search(r"```(?:json)?\s*(.*?)\s*```", raw_text, re.DOTALL)
    if code_block:
        try:
            parsed = json.loads(code_block.group(1))
            if isinstance(parsed, dict):
                return parsed
        except json.JSONDecodeError:
            pass

    # Find balanced-brace JSON candidates
    candidates: List[str] = []
    depth = 0
    current: List[str] = []
    for char in raw_text:
        if char == "{":
            if depth == 0:
                current = []
            depth += 1
        if depth > 0:
            current.append(char)
        if char == "}":
            depth -= 1
            if depth == 0 and current:
                candidates.append("".join(current))

    # Prefer the one with "milestones" key
    for c in reversed(candidates):
        try:
            parsed = json.loads(c)
            if isinstance(parsed, dict) and "milestones" in parsed:
                return parsed
        except json.JSONDecodeError:
            continue
    # Fallback: any valid dict
    for c in reversed(candidates):
        try:
            parsed = json.loads(c)
            if isinstance(parsed, dict):
                return parsed
        except json.JSONDecodeError:
            continue

    return {}


def parse_gpr_judge_response(
    raw_text: str,
    milestones: Dict[str, Any],
) -> GPRResult:
    """Parse the LLM Judge response into a GPRResult.

    If parsing fails, returns a GPRResult with all milestones marked unachieved.
    """
    milestone_keys = list(milestones.keys())
    n = len(milestone_keys)

    if not raw_text.strip():
        logger.warning("Empty judge response for GPR")
        return _fallback_gpr_result(milestones)

    parsed = _parse_json_from_text(raw_text)
    if not parsed or "milestones" not in parsed:
        logger.warning("Failed to parse GPR judge response")
        return _fallback_gpr_result(milestones)

    judge_milestones = parsed["milestones"]
    if not isinstance(judge_milestones, list):
        logger.warning("Judge 'milestones' is not a list")
        return _fallback_gpr_result(milestones)

    # Build a lookup from judge response by key
    judge_lookup: Dict[str, Dict[str, Any]] = {}
    for item in judge_milestones:
        if isinstance(item, dict) and "key" in item:
            judge_lookup[item["key"]] = item

    # Match judge results to our milestones (by key or by position)
    details: List[MilestoneResult] = []
    for i, key in enumerate(milestone_keys):
        expected = milestones[key]

        # Try key-based match first, then positional fallback
        judge_item = judge_lookup.get(key)
        if judge_item is None and i < len(judge_milestones):
            judge_item = judge_milestones[i]

        if judge_item and isinstance(judge_item, dict):
            achieved = bool(judge_item.get("achieved", False))
            evidence_type = str(judge_item.get("evidence_type", ""))
            reason = str(judge_item.get("reason", ""))
            raw_step = judge_item.get("first_step")
            try:
                first_step = int(raw_step) if raw_step is not None else None
            except (TypeError, ValueError):
                first_step = None
        else:
            achieved = False
            evidence_type = ""
            reason = "Not found in judge response"
            first_step = None

        details.append(MilestoneResult(
            key=key,
            expected=expected,
            achieved=achieved,
            evidence_type=evidence_type,
            reason=reason,
            first_step=first_step,
        ))

    achieved_count = sum(1 for d in details if d.achieved)
    gpr = achieved_count / n if n > 0 else 0.0

    break_point = parsed.get("break_point")
    if break_point is not None:
        try:
            break_point = int(break_point)
        except (TypeError, ValueError):
            break_point = None
    chain_summary = str(parsed.get("chain_summary", ""))

    return GPRResult(
        gpr=round(gpr, 4),
        milestones_total=n,
        milestones_achieved=achieved_count,
        break_point=break_point,
        chain_summary=chain_summary,
        details=details,
    )


def _fallback_gpr_result(milestones: Dict[str, Any]) -> GPRResult:
    """Return a GPRResult with all milestones marked as unachieved."""
    details = [
        MilestoneResult(
            key=key,
            expected=value,
            achieved=False,
            reason="Judge response could not be parsed",
        )
        for key, value in milestones.items()
    ]
    return GPRResult(
        gpr=0.0,
        milestones_total=len(milestones),
        milestones_achieved=0,
        break_point=0,
        chain_summary="Judge response could not be parsed",
        details=details,
    )


# ---------------------------------------------------------------------------
# Temporal Goal Progress Rate (TGPR) and Temporal Progress Efficiency (TPE)
# ---------------------------------------------------------------------------

DEFAULT_GAMMA = 0.9  # exponential decay factor


@dataclass
class TGPRResult:
    """Result of the Temporal Goal Progress Rate (TGPR) and Temporal Progress
    Efficiency (TPE) metrics. Both share the same per-milestone decay table;
    TGPR normalises by total milestones, TPE by achieved milestones (eval.tex)."""
    tgpr: float
    tpe: float
    gpr: float
    gamma: float
    s_gold: int
    milestones_total: int
    milestones_achieved: int
    details: List[Dict[str, Any]]

    def to_dict(self) -> Dict[str, Any]:
        return {
            "tgpr": self.tgpr,
            "tpe": self.tpe,
            "gpr": self.gpr,
            "gamma": self.gamma,
            "s_gold": self.s_gold,
            "milestones_total": self.milestones_total,
            "milestones_achieved": self.milestones_achieved,
            "details": self.details,
        }


def compute_tgpr(
    gpr_result: GPRResult,
    s_gold: int,
    gamma: float = DEFAULT_GAMMA,
) -> TGPRResult:
    """Compute Temporal Goal Progress Rate (TGPR) and Temporal Progress
    Efficiency (TPE).

    TGPR = (1/n_total)    * sum_i  I(m_i) * gamma^max(t_i - S_gold, 0)
    TPE  = (1/n_achieved) * sum_i  I(m_i) * gamma^max(t_i - S_gold, 0)
                                                   (per eval.tex)

    Uses S_gold (total gold-path steps) as a global baseline:
    - If the agent achieves a milestone within S_gold steps, no penalty.
    - If it takes more than S_gold steps, exponential decay kicks in.

    For unachieved milestones, the contribution is 0.
    Raises ValueError when the Judge marks a milestone achieved but
    omits first_step — TPE has no defensible fallback for that case
    (a decay=1 default would silently inflate the score).

    TPE differs from TGPR only by the denominator: it averages decay over
    *achieved* milestones, isolating timing from coverage. TPE = 0 when no
    milestones were achieved.
    """
    n = gpr_result.milestones_total
    if n == 0:
        return TGPRResult(
            tgpr=0.0, tpe=0.0, gpr=0.0, gamma=gamma, s_gold=s_gold,
            milestones_total=0, milestones_achieved=0, details=[],
        )

    details: List[Dict[str, Any]] = []
    tgpr_sum = 0.0
    decay_sum = 0.0
    achieved_count = 0

    for milestone in gpr_result.details:
        entry: Dict[str, Any] = {
            "key": milestone.key,
            "achieved": milestone.achieved,
            "t_agent": milestone.first_step,
            "s_gold": s_gold,
            "delay": None,
            "decay": None,
            "contribution": 0.0,
        }

        if milestone.achieved and milestone.first_step is not None:
            delay = max(milestone.first_step - s_gold, 0)
            decay = gamma ** delay
            contribution = (1.0 / n) * decay
            entry["delay"] = delay
            entry["decay"] = round(decay, 6)
            entry["contribution"] = round(contribution, 6)
            tgpr_sum += contribution
            decay_sum += decay
            achieved_count += 1
        elif milestone.achieved and milestone.first_step is None:
            raise ValueError(
                f"Milestone {milestone.key!r} marked achieved but the judge "
                "did not report first_step; refusing to compute TPE/TGPR "
                "with a fabricated decay value."
            )

        details.append(entry)

    tpe_value = decay_sum / achieved_count if achieved_count > 0 else 0.0

    return TGPRResult(
        tgpr=round(tgpr_sum, 4),
        tpe=round(tpe_value, 4),
        gpr=gpr_result.gpr,
        gamma=gamma,
        s_gold=s_gold,
        milestones_total=n,
        milestones_achieved=achieved_count,
        details=details,
    )