From 177025ba21600002e12e17d4a139a1a3aabb9581 Mon Sep 17 00:00:00 2001 From: Peter Tomko Date: Mon, 5 Oct 2026 22:04:12 +0200 Subject: [PATCH 1/4] feat(gooddata-eval): populate best_run_latency_s for agentic evaluators ItemReport.best_run_latency_s has only ever been set on the single-shot path (_run_one_item times each of its K attempts directly and keeps the best one's own latency). The agentic path drives its K runs and best-of-K selection inside each evaluator, so the runner never had a per-run latency to read -- every agentic kind reported best_run_latency_s: null, which is why tools consuming it (e.g. the Latency Explorer's tool-calls-vs-run-time panel) have always been empty for agentic_*/vis_agentic. Adds AgenticEvalOutcome.best_run_latency_s (and the matching bare annotation on AgenticAssertionError/JudgeResponseError, same pattern already used for timings) and wires it through all 11 agentic evaluators: - general_question, metric_skill, dashboard_skill already track per-run PhaseTimings; best_run_latency_s is derived from the rank-selected run's own timings via the new run_latency_s() helper (excludes langfuse_s, which is deliberately off the critical path). - The other 8 (guardrail, search_tool, alert_skill, anomaly_detection, kda_skill, visualization, what_if, conversation) had no per-run wall-clock at all; each gets a new run_latency_s field on its per-run result, measured the same way _run_one_item already does (time.monotonic() bracketing the whole run). agentic_runner.py copies it onto the ItemReport via a new _apply_best_run_latency(), mirroring the existing _apply_timings(). Verified: full gooddata-eval suite (1382 tests), ruff lint/format, and ty type-check all pass. Added focused tests for the new run_latency_s() helper, _apply_best_run_latency()'s three paths (success/failure/absent), and end-to-end value assertions for general_question and metric_skill (the two kinds with fully deterministic mocked clocks). Co-Authored-By: Claude Sonnet 5 --- .../src/gooddata_eval/cli/agentic_runner.py | 15 ++++++ .../gooddata_eval/core/agentic/alert_skill.py | 6 ++- .../core/agentic/anomaly_detection.py | 7 ++- .../core/agentic/conversation.py | 9 +++- .../core/agentic/dashboard_skill.py | 4 +- .../core/agentic/general_question.py | 13 +++-- .../gooddata_eval/core/agentic/guardrail.py | 14 ++++-- .../gooddata_eval/core/agentic/kda_skill.py | 7 ++- .../core/agentic/metric_skill.py | 4 +- .../gooddata_eval/core/agentic/search_tool.py | 5 +- .../core/agentic/visualization.py | 6 ++- .../src/gooddata_eval/core/agentic/what_if.py | 7 ++- .../core/evaluators/_llm_judge.py | 1 + .../src/gooddata_eval/core/models.py | 7 +++ .../src/gooddata_eval/core/timing.py | 10 ++++ .../tests/test_agentic_general_question.py | 4 ++ .../tests/test_agentic_metric_skill.py | 1 + .../tests/test_agentic_runner.py | 48 +++++++++++++++++++ packages/gooddata-eval/tests/test_timing.py | 8 ++++ 19 files changed, 160 insertions(+), 16 deletions(-) diff --git a/packages/gooddata-eval/src/gooddata_eval/cli/agentic_runner.py b/packages/gooddata-eval/src/gooddata_eval/cli/agentic_runner.py index e8feb992e..6a430db88 100644 --- a/packages/gooddata-eval/src/gooddata_eval/cli/agentic_runner.py +++ b/packages/gooddata-eval/src/gooddata_eval/cli/agentic_runner.py @@ -404,6 +404,18 @@ def _apply_timings(item_report: ItemReport, timings: Any) -> None: item_report.simulated_user_latency_s = timings.simulated_user_s +def _apply_best_run_latency(item_report: ItemReport, source: Any) -> None: + """Copy the rank-selected run's own wall time, mirroring the single-shot path's + ``ItemReport.best_run_latency_s`` (see ``core/runner.py``'s ``_run_one_item``). + + Kinds not yet wired to measure it pass None and keep the field at its own None + default rather than reporting an invented number. + """ + best_run_latency_s = getattr(source, "best_run_latency_s", None) + if best_run_latency_s is not None: + item_report.best_run_latency_s = best_run_latency_s + + def run_agentic_items( items: list[DatasetItem], host: str, @@ -501,6 +513,7 @@ def _process_item(index: int, item: DatasetItem) -> ItemReport: item_report.response_id = response_id item_report.best_detail = detail or {} _apply_timings(item_report, getattr(outcome, "timings", None)) + _apply_best_run_latency(item_report, outcome) _apply_run_counts(item_report, outcome) _apply_failed_runs(item_report, outcome) _apply_run_latencies(item_report, outcome) @@ -512,6 +525,7 @@ def _process_item(index: int, item: DatasetItem) -> ItemReport: item_report.response_id = getattr(exc, "response_id", None) item_report.best_detail = getattr(exc, "detail", None) or {} _apply_timings(item_report, getattr(exc, "timings", None)) + _apply_best_run_latency(item_report, exc) _apply_run_counts(item_report, exc) _apply_failed_runs(item_report, exc) _apply_run_latencies(item_report, exc) @@ -555,6 +569,7 @@ def _process_item(index: int, item: DatasetItem) -> ItemReport: # runs and then raised would otherwise show up in the per-response table and not in # the per-conversation one. traces.discard() + _apply_best_run_latency(item_report, exc) finally: item_report.latency_s = time.perf_counter() - t0 item_report.trace_latencies_s = traces.stop() diff --git a/packages/gooddata-eval/src/gooddata_eval/core/agentic/alert_skill.py b/packages/gooddata-eval/src/gooddata_eval/core/agentic/alert_skill.py index 6c5a55d67..d27cf0bee 100644 --- a/packages/gooddata-eval/src/gooddata_eval/core/agentic/alert_skill.py +++ b/packages/gooddata-eval/src/gooddata_eval/core/agentic/alert_skill.py @@ -700,7 +700,8 @@ class AlertRunResult: # also report operator/threshold/metric/recipients as False. exit_reason: LoopExit = LoopExit.BUDGET_EXHAUSTED turns_used: int = 0 - # This run's own wall time, from just before its chat call to the end of its scoring. + # This run's own wall time, across all its turns -- mirrors the single-shot + # path's best_run_latency_s (see core/runner.py's _run_one_item). run_latency_s: float = 0.0 @@ -975,6 +976,7 @@ def run_agentic_alert_skill( def _run_once(conv_id: str) -> AlertRunResult: alert_id_to_delete: str | None = None + run_started = time.monotonic() try: alert_id: str | None = None actual_args: dict = {} @@ -1286,6 +1288,7 @@ def _write_scores(ctx: RunTraceContext) -> None: exc.runs_effective = runs_effective exc.failed_runs = failed_runs exc.run_latencies_s = [r.run_latency_s for r in summary.run_results] + exc.best_run_latency_s = best.run_latency_s raise exc return AgenticEvalOutcome( runs_passed=runs_passed, @@ -1298,4 +1301,5 @@ def _write_scores(ctx: RunTraceContext) -> None: # 1/3 item reports success while two of its runs failed for reasons worth reading. failed_runs=failed_runs, run_latencies_s=[r.run_latency_s for r in summary.run_results], + best_run_latency_s=best.run_latency_s, ) diff --git a/packages/gooddata-eval/src/gooddata_eval/core/agentic/anomaly_detection.py b/packages/gooddata-eval/src/gooddata_eval/core/agentic/anomaly_detection.py index 1a4238983..b97f5009b 100644 --- a/packages/gooddata-eval/src/gooddata_eval/core/agentic/anomaly_detection.py +++ b/packages/gooddata-eval/src/gooddata_eval/core/agentic/anomaly_detection.py @@ -285,7 +285,9 @@ class AnomalyRunResult: response_id: str | None = None tool_call_events: list[ToolCallEvent] = field(default_factory=list) reasoning_step_events: list[ReasoningStepEvent] = field(default_factory=list) - # This run's own wall time, from just before its chat call to the end of its scoring. + # This run's own wall time, across all its turns -- mirrors the single-shot + # path's best_run_latency_s (see core/runner.py's _run_one_item). Distinct from + # turn_wall_clock_sec above, which is only the final triggering turn. run_latency_s: float = 0.0 @@ -371,6 +373,7 @@ def run_agentic_anomaly_detection( ) def _run_once(conv_id: str) -> AnomalyRunResult: + run_started = time.monotonic() viz_args: dict | None = None execute_result: dict | None = None turn_wall_clock_sec: float | None = None @@ -657,6 +660,7 @@ def _write_scores(ctx: RunTraceContext) -> None: exc.runs_effective = len(summary.run_results) exc.failed_runs = failed_runs exc.run_latencies_s = [r.run_latency_s for r in summary.run_results] + exc.best_run_latency_s = best.run_latency_s raise exc return AgenticEvalOutcome( @@ -668,4 +672,5 @@ def _write_scores(ctx: RunTraceContext) -> None: detail=detail, failed_runs=failed_runs, run_latencies_s=[r.run_latency_s for r in summary.run_results], + best_run_latency_s=best.run_latency_s, ) diff --git a/packages/gooddata-eval/src/gooddata_eval/core/agentic/conversation.py b/packages/gooddata-eval/src/gooddata_eval/core/agentic/conversation.py index e980958bc..94846fcf2 100644 --- a/packages/gooddata-eval/src/gooddata_eval/core/agentic/conversation.py +++ b/packages/gooddata-eval/src/gooddata_eval/core/agentic/conversation.py @@ -729,8 +729,10 @@ class ConversationResult: stalled_turns: int = 0 mode: ConversationMode = "legacy" judge_model: str | None = None - # The whole conversation's wall time, from just before its first message to the end of its - # last turn's scoring; conversation create/delete is not part of it. + # This conversation's own wall time, across every turn -- mirrors the single-shot + # path's best_run_latency_s (see core/runner.py's _run_one_item). There is no + # K-of-N selection for this kind (see run_agentic_conversation's docstring), so + # this is simply the one conversation's own time, not a "best of" pick. run_latency_s: float = 0.0 @@ -857,6 +859,7 @@ def run_agentic_conversation( A fixture with ``expects_clarification`` needs ``context`` mode: legacy mode neither sends ``clarifying_answers`` nor lets the clarification checks fail the item, so it raises ``ValueError``. """ + run_started = time.monotonic() resolved_mode = resolve_conversation_mode(mode) graded = [t.turn_id for t in fixture.turns if t.expects_clarification is not None] if resolved_mode == "legacy" and graded: @@ -1518,6 +1521,7 @@ def _write_scores(ctx: RunTraceContext) -> None: exc.runs_passed = 0 exc.runs_effective = 1 exc.run_latencies_s = [result.run_latency_s] + exc.best_run_latency_s = result.run_latency_s raise exc return AgenticEvalOutcome( reasoning_steps=result.reasoning_steps, @@ -1527,4 +1531,5 @@ def _write_scores(ctx: RunTraceContext) -> None: runs_passed=1, runs_effective=1, run_latencies_s=[result.run_latency_s], + best_run_latency_s=result.run_latency_s, ) diff --git a/packages/gooddata-eval/src/gooddata_eval/core/agentic/dashboard_skill.py b/packages/gooddata-eval/src/gooddata_eval/core/agentic/dashboard_skill.py index fdb797c09..b14919661 100644 --- a/packages/gooddata-eval/src/gooddata_eval/core/agentic/dashboard_skill.py +++ b/packages/gooddata-eval/src/gooddata_eval/core/agentic/dashboard_skill.py @@ -41,7 +41,7 @@ shift_and_index_events, ) from gooddata_eval.core.scoring import AAC_VISUALIZATION_TYPES, same_viz_type -from gooddata_eval.core.timing import PhaseTimings, log_timer, sum_timings +from gooddata_eval.core.timing import PhaseTimings, log_timer, run_latency_s, sum_timings _DEFAULT_K = 1 # Matches kda_skill and visualization. The reply this loop sends is built from the expectation @@ -2041,6 +2041,7 @@ def _write_scores(ctx: RunTraceContext) -> None: exc.conversation_id = best.conversation_id exc.response_id = best.response_id exc.timings = item_timings + exc.best_run_latency_s = run_latency_s(best.timings) exc.detail = detail exc.runs_passed = runs_passed exc.runs_effective = runs_effective @@ -2057,4 +2058,5 @@ def _write_scores(ctx: RunTraceContext) -> None: timings=item_timings, failed_runs=failed_runs, run_latencies_s=[r.run_latency_s for r in summary.run_results], + best_run_latency_s=run_latency_s(best.timings), ) diff --git a/packages/gooddata-eval/src/gooddata_eval/core/agentic/general_question.py b/packages/gooddata-eval/src/gooddata_eval/core/agentic/general_question.py index 5de9512d5..aec78763c 100644 --- a/packages/gooddata-eval/src/gooddata_eval/core/agentic/general_question.py +++ b/packages/gooddata-eval/src/gooddata_eval/core/agentic/general_question.py @@ -37,7 +37,7 @@ ToolCallEvent, build_latency_breakdown, ) -from gooddata_eval.core.timing import PhaseTimings, log_timer, sum_timings +from gooddata_eval.core.timing import PhaseTimings, log_timer, run_latency_s, sum_timings _DEFAULT_K = 1 @@ -230,6 +230,7 @@ def _attach_diagnostics( runs_passed: int, runs_effective: int, run_latencies_s: list[float], + best_run_latency_s: float | None, ) -> None: """Hang the report payload on a raised error, whichever error it is. @@ -245,6 +246,7 @@ def _attach_diagnostics( error.runs_effective = runs_effective error.failed_runs = failed_runs error.run_latencies_s = run_latencies_s + error.best_run_latency_s = best_run_latency_s def _run_detail(run: GeneralQuestionResult) -> dict: @@ -397,7 +399,9 @@ def _write_scores(ctx: RunTraceContext) -> None: f"judge returned no readable verdict for any of the {len(summary.run_results)} run(s): " + " | ".join(unscored) ) - _attach_diagnostics(error, best, detail, failed_runs, runs_passed, runs_effective, run_latencies_s) + _attach_diagnostics( + error, best, detail, failed_runs, runs_passed, runs_effective, run_latencies_s, run_latency_s(best.timings) + ) error.timings = item_timings raise error @@ -406,7 +410,9 @@ def _write_scores(ctx: RunTraceContext) -> None: exc = GeneralQuestionAssertionError( f"General question assertion failed. {gate_note} passed={best.passed}. Reasoning: {best.reasoning}" ) - _attach_diagnostics(exc, best, detail, failed_runs, runs_passed, runs_effective, run_latencies_s) + _attach_diagnostics( + exc, best, detail, failed_runs, runs_passed, runs_effective, run_latencies_s, run_latency_s(best.timings) + ) exc.timings = item_timings raise exc return AgenticEvalOutcome( @@ -421,4 +427,5 @@ def _write_scores(ctx: RunTraceContext) -> None: # 1/3 item reports success while two of its runs failed for reasons worth reading. failed_runs=failed_runs, run_latencies_s=run_latencies_s, + best_run_latency_s=run_latency_s(best.timings), ) diff --git a/packages/gooddata-eval/src/gooddata_eval/core/agentic/guardrail.py b/packages/gooddata-eval/src/gooddata_eval/core/agentic/guardrail.py index 81f9cb1ad..2996fca33 100644 --- a/packages/gooddata-eval/src/gooddata_eval/core/agentic/guardrail.py +++ b/packages/gooddata-eval/src/gooddata_eval/core/agentic/guardrail.py @@ -87,7 +87,8 @@ class GuardrailResult: # Set when the judge returned something unreadable for THIS run. Excluded from pass@K # and from Langfuse scoring rather than counted as a failure -- see score_run. judge_error: str | None = None - # This run's own wall time, from just before its chat call to the end of its scoring. + # This run's own wall time (agent call + its grading) -- mirrors the single-shot + # path's best_run_latency_s (see core/runner.py's _run_one_item). run_latency_s: float = 0.0 @@ -211,6 +212,7 @@ def _attach_diagnostics( runs_passed: int, runs_effective: int, run_latencies_s: list[float], + best_run_latency_s: float | None, ) -> None: """Hang the report payload on a raised error, whichever error it is. @@ -226,6 +228,7 @@ def _attach_diagnostics( error.runs_effective = runs_effective error.failed_runs = failed_runs error.run_latencies_s = run_latencies_s + error.best_run_latency_s = best_run_latency_s def _run_detail(run: GuardrailResult) -> dict: @@ -375,7 +378,9 @@ def _write_scores(ctx: RunTraceContext) -> None: f"judge returned no readable verdict for any of the {len(summary.run_results)} run(s): " + " | ".join(unscored) ) - _attach_diagnostics(error, best, detail, failed_runs, runs_passed, runs_effective, run_latencies_s) + _attach_diagnostics( + error, best, detail, failed_runs, runs_passed, runs_effective, run_latencies_s, best.run_latency_s + ) raise error if not gate_passed(gate, pass_at_k=summary.pass_at_k, pass_power_k=summary.pass_power_k): @@ -383,7 +388,9 @@ def _write_scores(ctx: RunTraceContext) -> None: exc = GuardrailAssertionError( f"Guardrail assertion failed. {gate_note} passed={best.passed}. Reasoning: {best.reasoning}" ) - _attach_diagnostics(exc, best, detail, failed_runs, runs_passed, runs_effective, run_latencies_s) + _attach_diagnostics( + exc, best, detail, failed_runs, runs_passed, runs_effective, run_latencies_s, best.run_latency_s + ) raise exc return AgenticEvalOutcome( runs_passed=runs_passed, @@ -396,4 +403,5 @@ def _write_scores(ctx: RunTraceContext) -> None: # 1/3 item reports success while two of its runs failed for reasons worth reading. failed_runs=failed_runs, run_latencies_s=run_latencies_s, + best_run_latency_s=best.run_latency_s, ) diff --git a/packages/gooddata-eval/src/gooddata_eval/core/agentic/kda_skill.py b/packages/gooddata-eval/src/gooddata_eval/core/agentic/kda_skill.py index 7ab93c40a..57c97b4b2 100644 --- a/packages/gooddata-eval/src/gooddata_eval/core/agentic/kda_skill.py +++ b/packages/gooddata-eval/src/gooddata_eval/core/agentic/kda_skill.py @@ -201,7 +201,9 @@ class KdaRunResult: # separate a refusal from a run that hit max_iterations while still on track. exit_reason: LoopExit = LoopExit.BUDGET_EXHAUSTED turns_used: int = 0 - # This run's own wall time, from just before its chat call to the end of its scoring. + # This run's own wall time, across all its turns -- mirrors the single-shot + # path's best_run_latency_s (see core/runner.py's _run_one_item). Distinct from + # turn_wall_clock_sec above, which is only the final create-triggering turn. run_latency_s: float = 0.0 @@ -271,6 +273,7 @@ def run_agentic_kda_skill( ) def _run_once(conv_id: str) -> KdaRunResult: + run_started = time.monotonic() create_args: dict | None = None execute_result: dict | None = None turn_wall_clock_sec: float | None = None @@ -591,6 +594,7 @@ def _write_scores(ctx: RunTraceContext) -> None: exc.runs_effective = runs_effective exc.failed_runs = failed_runs exc.run_latencies_s = [r.run_latency_s for r in summary.run_results] + exc.best_run_latency_s = best.run_latency_s raise exc return AgenticEvalOutcome( runs_passed=runs_passed, @@ -603,4 +607,5 @@ def _write_scores(ctx: RunTraceContext) -> None: # 1/3 item reports success while two of its runs failed for reasons worth reading. failed_runs=failed_runs, run_latencies_s=[r.run_latency_s for r in summary.run_results], + best_run_latency_s=best.run_latency_s, ) diff --git a/packages/gooddata-eval/src/gooddata_eval/core/agentic/metric_skill.py b/packages/gooddata-eval/src/gooddata_eval/core/agentic/metric_skill.py index 464cf592e..f5996da86 100644 --- a/packages/gooddata-eval/src/gooddata_eval/core/agentic/metric_skill.py +++ b/packages/gooddata-eval/src/gooddata_eval/core/agentic/metric_skill.py @@ -44,7 +44,7 @@ shift_and_index_events, timeline_detail, ) -from gooddata_eval.core.timing import PhaseTimings, log_timer, sum_timings +from gooddata_eval.core.timing import PhaseTimings, log_timer, run_latency_s, sum_timings try: from openai import OpenAI as _OpenAI @@ -654,6 +654,7 @@ def _run_detail(run: MetricRunResult) -> dict: exc.conversation_id = best.conversation_id exc.response_id = best.response_id exc.timings = item_timings + exc.best_run_latency_s = run_latency_s(best.timings) exc.detail = detail exc.runs_passed = runs_passed exc.runs_effective = runs_effective @@ -672,4 +673,5 @@ def _run_detail(run: MetricRunResult) -> dict: # 1/3 item reports success while two of its runs failed for reasons worth reading. failed_runs=failed_runs, run_latencies_s=run_latencies_s, + best_run_latency_s=run_latency_s(best.timings), ) diff --git a/packages/gooddata-eval/src/gooddata_eval/core/agentic/search_tool.py b/packages/gooddata-eval/src/gooddata_eval/core/agentic/search_tool.py index 1d19c2e89..94de1935f 100644 --- a/packages/gooddata-eval/src/gooddata_eval/core/agentic/search_tool.py +++ b/packages/gooddata-eval/src/gooddata_eval/core/agentic/search_tool.py @@ -78,7 +78,8 @@ class SearchResult: response_id: str | None = None tool_call_events: list[ToolCallEvent] = field(default_factory=list) reasoning_step_events: list[ReasoningStepEvent] = field(default_factory=list) - # This run's own wall time, from just before its chat call to the end of its scoring. + # This run's own wall time -- mirrors the single-shot path's best_run_latency_s + # (see core/runner.py's _run_one_item). run_latency_s: float = 0.0 @@ -314,6 +315,7 @@ def _write_scores(ctx: RunTraceContext) -> None: exc.runs_effective = runs_effective exc.failed_runs = failed_runs exc.run_latencies_s = [r.run_latency_s for r in summary.run_results] + exc.best_run_latency_s = best.run_latency_s raise exc return AgenticEvalOutcome( runs_passed=runs_passed, @@ -326,4 +328,5 @@ def _write_scores(ctx: RunTraceContext) -> None: # 1/3 item reports success while two of its runs failed for reasons worth reading. failed_runs=failed_runs, run_latencies_s=[r.run_latency_s for r in summary.run_results], + best_run_latency_s=best.run_latency_s, ) diff --git a/packages/gooddata-eval/src/gooddata_eval/core/agentic/visualization.py b/packages/gooddata-eval/src/gooddata_eval/core/agentic/visualization.py index 6b1523ae2..792b87d4a 100644 --- a/packages/gooddata-eval/src/gooddata_eval/core/agentic/visualization.py +++ b/packages/gooddata-eval/src/gooddata_eval/core/agentic/visualization.py @@ -77,7 +77,8 @@ class RunResult: # Why the simulated-user loop stopped. visualization_created=False alone cannot separate # a refusal from a run that hit max_iterations while still on track -- see LoopExit. exit_reason: LoopExit = LoopExit.BUDGET_EXHAUSTED - # This run's own wall time, from just before its first chat call to the end of its scoring. + # This run's own wall time, across all its turns -- mirrors the single-shot + # path's best_run_latency_s (see core/runner.py's _run_one_item). run_latency_s: float = 0.0 # Everything the final turn said, which the answer patterns are matched against. answer_text: str = "" @@ -208,6 +209,7 @@ def _execute_single_run( one_turn = not options.expects_visualization or options.visualization_optional if one_turn: max_iterations = min(max_iterations, 1) + run_started = time.monotonic() total_turns = 0 total_steps = 0 all_tool_call_events: list[ToolCallEvent] = [] @@ -709,6 +711,7 @@ def _write_scores(ctx: RunTraceContext) -> None: exc.runs_effective = runs_effective exc.failed_runs = failed_runs exc.run_latencies_s = run_latencies_s + exc.best_run_latency_s = best.run_latency_s raise exc return AgenticEvalOutcome( runs_passed=runs_passed, @@ -721,4 +724,5 @@ def _write_scores(ctx: RunTraceContext) -> None: # 1/3 item reports success while two of its runs failed for reasons worth reading. failed_runs=failed_runs, run_latencies_s=run_latencies_s, + best_run_latency_s=best.run_latency_s, ) diff --git a/packages/gooddata-eval/src/gooddata_eval/core/agentic/what_if.py b/packages/gooddata-eval/src/gooddata_eval/core/agentic/what_if.py index baaeb201d..a7d9ebdb4 100644 --- a/packages/gooddata-eval/src/gooddata_eval/core/agentic/what_if.py +++ b/packages/gooddata-eval/src/gooddata_eval/core/agentic/what_if.py @@ -212,7 +212,9 @@ class WhatIfRunResult: response_id: str | None = None tool_call_events: list[ToolCallEvent] = field(default_factory=list) reasoning_step_events: list[ReasoningStepEvent] = field(default_factory=list) - # This run's own wall time, from just before its chat call to the end of its scoring. + # This run's own wall time, across all its turns -- mirrors the single-shot + # path's best_run_latency_s (see core/runner.py's _run_one_item). Distinct from + # turn_wall_clock_sec above, which is only the scenario-execution turn. run_latency_s: float = 0.0 @@ -328,6 +330,7 @@ def run_agentic_what_if( ) def _run_once(conv_id: str) -> WhatIfRunResult: + run_started = time.monotonic() create_args: dict | None = None execute_result: dict | None = None turn_wall_clock_sec: float | None = None @@ -622,6 +625,7 @@ def _write_scores(ctx: RunTraceContext) -> None: exc.runs_effective = len(summary.run_results) exc.failed_runs = failed_runs exc.run_latencies_s = [r.run_latency_s for r in summary.run_results] + exc.best_run_latency_s = best.run_latency_s raise exc return AgenticEvalOutcome( @@ -633,4 +637,5 @@ def _write_scores(ctx: RunTraceContext) -> None: detail=detail, failed_runs=failed_runs, run_latencies_s=[r.run_latency_s for r in summary.run_results], + best_run_latency_s=best.run_latency_s, ) diff --git a/packages/gooddata-eval/src/gooddata_eval/core/evaluators/_llm_judge.py b/packages/gooddata-eval/src/gooddata_eval/core/evaluators/_llm_judge.py index c32cb3f40..6bb4b9e62 100644 --- a/packages/gooddata-eval/src/gooddata_eval/core/evaluators/_llm_judge.py +++ b/packages/gooddata-eval/src/gooddata_eval/core/evaluators/_llm_judge.py @@ -62,6 +62,7 @@ class JudgeResponseError(RuntimeError): runs_effective: int failed_runs: list[dict] run_latencies_s: list[float] + best_run_latency_s: float | None def _message_content(response: Any) -> str | None: diff --git a/packages/gooddata-eval/src/gooddata_eval/core/models.py b/packages/gooddata-eval/src/gooddata_eval/core/models.py index 85f92e74c..435ac811a 100644 --- a/packages/gooddata-eval/src/gooddata_eval/core/models.py +++ b/packages/gooddata-eval/src/gooddata_eval/core/models.py @@ -434,6 +434,7 @@ class AgenticAssertionError(AssertionError): runs_effective: int failed_runs: list[dict] run_latencies_s: list[float] + best_run_latency_s: float | None class AgenticEvalOutcome(BaseModel): @@ -470,6 +471,12 @@ class AgenticEvalOutcome(BaseModel): # needs one per run. Empty means the kind recorded none, which the report reads as "no # sample", not as zero-second runs. run_latencies_s: list[float] = Field(default_factory=list) + # The rank-selected run's own wall time -- mirrors the single-shot path's + # ItemReport.best_run_latency_s (see core/runner.py's _run_one_item), which the + # agentic path never populated because its K runs happen inside the evaluator, + # not in a loop the runner itself can time. None for a kind that has not yet been + # wired to measure it (see AgenticAssertionError.best_run_latency_s, same default). + best_run_latency_s: float | None = None class SummaryInput(BaseModel): diff --git a/packages/gooddata-eval/src/gooddata_eval/core/timing.py b/packages/gooddata-eval/src/gooddata_eval/core/timing.py index b2d203d7b..2c7b9992f 100644 --- a/packages/gooddata-eval/src/gooddata_eval/core/timing.py +++ b/packages/gooddata-eval/src/gooddata_eval/core/timing.py @@ -182,3 +182,13 @@ def note_trace_latency(seconds: float | None) -> None: sink = _trace_latencies.get() if sink is not None and seconds is not None: sink.append(seconds) + + +def run_latency_s(timings: PhaseTimings) -> float: + """One run's own wall time, for a single run's ``PhaseTimings``. + + Excludes ``langfuse_s`` (deliberately off the critical path -- see + ``PhaseTimings.langfuse_s``) so this stays comparable to the single-shot path's + ``best_run_latency_s``, which times only the agent call and its grading. + """ + return timings.agent_s + timings.judge_s + timings.simulated_user_s diff --git a/packages/gooddata-eval/tests/test_agentic_general_question.py b/packages/gooddata-eval/tests/test_agentic_general_question.py index cdfc683b8..ba30b602c 100644 --- a/packages/gooddata-eval/tests/test_agentic_general_question.py +++ b/packages/gooddata-eval/tests/test_agentic_general_question.py @@ -407,6 +407,9 @@ def test_evaluate_general_question_aggregates_timings_across_k_runs(): assert outcome.timings.judge_s == 1.5 # 1.0 + 0.5 # Each run's own span, agent and judge both inside it -- not their sum across runs. assert outcome.run_latencies_s == [3.0, 3.5] + # best_run_latency_s is the rank-selected run's own time (agent_s=2.0 + judge_s=1.0 + # from the first, tied-best run), not the item total above (both runs summed). + assert outcome.best_run_latency_s == 3.0 def test_evaluate_general_question_attaches_timings_to_the_failure_exception(): @@ -430,6 +433,7 @@ def test_evaluate_general_question_attaches_timings_to_the_failure_exception(): assert exc_info.value.timings.agent_s == 4.0 assert exc_info.value.timings.judge_s == 2.0 + assert exc_info.value.best_run_latency_s == 6.0 def test_trace_link_window_is_pinned_at_submit_time_not_when_the_task_runs(): diff --git a/packages/gooddata-eval/tests/test_agentic_metric_skill.py b/packages/gooddata-eval/tests/test_agentic_metric_skill.py index a86a2e9c3..5efcbb0bb 100644 --- a/packages/gooddata-eval/tests/test_agentic_metric_skill.py +++ b/packages/gooddata-eval/tests/test_agentic_metric_skill.py @@ -855,6 +855,7 @@ def test_evaluate_metric_skill_surfaces_timings_on_the_outcome(): assert outcome.timings.agent_s == 3.0 assert outcome.timings.simulated_user_s == 0.0 + assert outcome.best_run_latency_s == 3.0 def test_no_timer_output_by_default(monkeypatch, capsys): diff --git a/packages/gooddata-eval/tests/test_agentic_runner.py b/packages/gooddata-eval/tests/test_agentic_runner.py index f28c0fae6..b779361d1 100644 --- a/packages/gooddata-eval/tests/test_agentic_runner.py +++ b/packages/gooddata-eval/tests/test_agentic_runner.py @@ -405,6 +405,54 @@ def test_run_agentic_items_records_phase_timings_when_the_item_fails(): assert report.items[0].judge_latency_s == 2.0 +def test_run_agentic_items_records_best_run_latency_on_success(): + # best_run_latency_s was never populated on the agentic path -- the K-run loop and + # best-of-K selection happen inside the evaluator, not in a loop the runner itself + # times (unlike _run_one_item on the single-shot path). + outcome = AgenticEvalOutcome( + conversation_id="c1", + detail={"alert_created": True}, + best_run_latency_s=4.25, + ) + with patch("gooddata_eval.cli.agentic_runner.evaluate_agentic_alert_skill", return_value=outcome): + report = run_agentic_items( + [_timed_item()], + host="http://host", + token="tok", + workspace_id="ws1", + run_ts="2026-01-01", + ) + + assert report.items[0].best_run_latency_s == 4.25 + + +def test_run_agentic_items_records_best_run_latency_when_the_item_fails(): + exc = AlertSkillAssertionError("nope") + exc.detail = {"alert_created": False} + exc.best_run_latency_s = 9.5 + + with patch("gooddata_eval.cli.agentic_runner.evaluate_agentic_alert_skill", side_effect=exc): + report = run_agentic_items( + [_timed_item()], + host="http://host", + token="tok", + workspace_id="ws1", + run_ts="2026-01-01", + ) + + assert report.items[0].pass_at_k is False + assert report.items[0].best_run_latency_s == 9.5 + + +def test_an_errored_item_without_best_run_latency_keeps_the_none_default(): + # Kinds not yet wired to measure it (or any exception with no such attribute) must + # not report an invented number -- None stays None, not 0.0. + with patch("gooddata_eval.cli.agentic_runner.evaluate_agentic_alert_skill", side_effect=RuntimeError("boom")): + report = run_agentic_items([_timed_item()], host="h", token="t", workspace_id="ws1", run_ts="2026-01-01") + + assert report.items[0].best_run_latency_s is None + + def test_a_pending_trace_link_does_not_block_the_next_item(): """The overlap claim, proved by construction rather than by a stopwatch. diff --git a/packages/gooddata-eval/tests/test_timing.py b/packages/gooddata-eval/tests/test_timing.py index b2de2e19b..527ce7be5 100644 --- a/packages/gooddata-eval/tests/test_timing.py +++ b/packages/gooddata-eval/tests/test_timing.py @@ -15,6 +15,7 @@ log_timer, note_trace_latency, percentile, + run_latency_s, sum_timings, timers_enabled, trimmed_mean, @@ -268,3 +269,10 @@ def item(base: float) -> list[float]: results = list(pool.map(item, [0.0, 100.0, 200.0, 300.0])) assert results == [[b + s for s in range(5)] for b in (0.0, 100.0, 200.0, 300.0)] + + +def test_run_latency_s_excludes_langfuse(): + # langfuse_s is deliberately off the critical path (see PhaseTimings docstring), so a + # trace-link slowdown must not inflate the run latency a worst-case table sorts on. + timings = PhaseTimings(agent_s=2.0, judge_s=1.0, simulated_user_s=0.5, langfuse_s=100.0) + assert run_latency_s(timings) == 3.5 From 887c536a79aa55d9c9210b3e7f89f579f3b034c3 Mon Sep 17 00:00:00 2001 From: Peter Tomko Date: Mon, 5 Oct 2026 22:46:40 +0200 Subject: [PATCH 2/4] refactor(gooddata-eval): centralize agentic outcome fields; fix exit_reason and tool_calls gaps (#1846) Comprehensive analysis of the 11 agentic evaluators (alert_skill, anomaly_detection, conversation, dashboard_skill, general_question, guardrail, kda_skill, metric_skill, search_tool, visualization, what_if) found the same unfinished-rollout pattern that caused best_run_latency_s (#1845) recurring twice more, live in production data: 1. exit_reason (LoopExit) -- invented specifically so a run that hit max_iterations stops looking identical to a genuine refusal -- was wired into 5 of 8 multi-turn kinds. Missing from anomaly_detection, dashboard_skill, what_if. All three now track it through every break point in their run loop (SUCCESS/AGENT_SILENT/ CHAT_ERROR/SIMULATED_USER_FAILED/BUDGET_EXHAUSTED default), mirroring the exact pattern already proven in kda_skill.py/alert_skill.py. 2. detail's tool_calls key -- timeline_detail() builds both latency_breakdown and tool_calls from the same events so they stay index-aligned, but roughly half the evaluators called build_latency_breakdown() directly and silently never got a tool_calls key. Every evaluator's detail dict now goes through one shared `agentic_detail()` call, so this can't happen again by omission. 3. The root cause of 1 and 2 (and best_run_latency_s before them): every evaluator hand-wrote the same ~7-10 line block copying reasoning_steps/conversation_id/ response_id/detail/runs_passed/runs_effective/(timings)/best_run_latency_s either onto a raised exception or into the returned AgenticEvalOutcome -- 11 independent copies of the same logic, so a new universal field needed 11 edits, and nothing failed loudly when one was missed (AgenticAssertionError's own docstring already documents this happening once before, to `.timings`). New core/agentic/_outcome.py centralizes it: `agentic_detail()` for the detail dict, `raise_agentic_failure()`/`agentic_success()` for the common fields. All 11 evaluators now call these instead of hand-rolling. Per-evaluator duplicate field assignments: ~85 lines total before, 3 after (the 2 remaining are general_question's and guardrail's "no judge verdict at all" branches, which raise a bare JudgeResponseError -- not an AgenticAssertionError subclass, so they can't route through raise_agentic_failure; left as direct attribute sets, same as before). Explicitly NOT addressed here (see PR description for why): - agentic_dashboard_summary not existing on master at all -- it's part of a much larger (2000+ line) unmerged integration branch with its own in-flight PRs; porting it here would duplicate/conflict with that separate effort. - A ~9% gap in agentic_guardrail's .reasoning.json sidecar capture for runs that did have reasoning steps -- traced as far as ruling out config differences and SSE-level field divergence (reasoningSteps/reasoningStepEvents are built from the same accumulator list, so they can't diverge there), but the remaining cause needs a live repro with real reasoning content, not static source reading. Verified: full gooddata-eval suite (1382 passed), ruff lint/format, and ty type-check all clean. New/extended tests assert real exit_reason values (not just that nothing broke) for every break point added, plus tool_calls presence, across all three newly-covered kinds. Co-authored-by: Claude Sonnet 5 --- .../gooddata_eval/core/agentic/_outcome.py | 123 ++++++++++++++++++ .../gooddata_eval/core/agentic/alert_skill.py | 62 ++++++--- .../core/agentic/anomaly_detection.py | 82 +++++++----- .../core/agentic/conversation.py | 57 ++++---- .../core/agentic/dashboard_skill.py | 61 ++++++--- .../core/agentic/general_question.py | 41 +++--- .../gooddata_eval/core/agentic/guardrail.py | 37 ++++-- .../gooddata_eval/core/agentic/kda_skill.py | 51 +++++--- .../core/agentic/metric_skill.py | 53 ++++---- .../gooddata_eval/core/agentic/search_tool.py | 41 +++--- .../core/agentic/visualization.py | 46 ++++--- .../src/gooddata_eval/core/agentic/what_if.py | 84 +++++++----- .../tests/test_agentic_anomaly_detection.py | 12 +- .../tests/test_agentic_dashboard_skill.py | 7 +- .../tests/test_agentic_general_question.py | 2 + .../tests/test_agentic_kda_skill.py | 2 + .../tests/test_agentic_runner.py | 20 ++- .../tests/test_agentic_search_tool.py | 2 + .../tests/test_agentic_what_if.py | 14 +- 19 files changed, 550 insertions(+), 247 deletions(-) create mode 100644 packages/gooddata-eval/src/gooddata_eval/core/agentic/_outcome.py diff --git a/packages/gooddata-eval/src/gooddata_eval/core/agentic/_outcome.py b/packages/gooddata-eval/src/gooddata_eval/core/agentic/_outcome.py new file mode 100644 index 000000000..576aee838 --- /dev/null +++ b/packages/gooddata-eval/src/gooddata_eval/core/agentic/_outcome.py @@ -0,0 +1,123 @@ +# (C) 2026 GoodData Corporation +"""The common tail of every ``evaluate_agentic_*`` function. + +Before this module, each of the agentic evaluators hand-wrote the same block: copy +``reasoning_steps``/``conversation_id``/``response_id``/``detail``/``runs_passed``/ +``runs_effective``/``best_run_latency_s`` (and sometimes ``timings``) either onto a +raised exception or into the returned ``AgenticEvalOutcome``. Eleven independent copies +of the same ~7 lines meant a new universal field needed eleven edits, not one, and +nothing failed loudly when a copy was missed -- exactly what happened to ``timings`` +(see ``AgenticAssertionError``'s docstring: "while it lived in eight copies, two +declared timings and six did not") and again to ``best_run_latency_s`` (every agentic +kind silently reported it as ``null`` until this was noticed and fixed kind-by-kind). + +``agentic_detail`` has the same motivation for the ``detail`` dict's timeline fields: +``timeline_detail`` builds both ``latency_breakdown`` and ``tool_calls`` from the same +events so they stay index-aligned, but roughly half the evaluators called +``build_latency_breakdown`` directly and silently never got a ``tool_calls`` key. +""" + +from __future__ import annotations + +from typing import Any, NoReturn + +from gooddata_eval.core.models import ( + AgenticAssertionError, + AgenticEvalOutcome, + ReasoningStepEvent, + ToolCallEvent, + timeline_detail, +) +from gooddata_eval.core.timing import PhaseTimings + +__all__ = ["agentic_detail", "agentic_success", "raise_agentic_failure"] + + +def agentic_detail( + tool_call_events: list[ToolCallEvent], + reasoning_step_events: list[ReasoningStepEvent] | None, + **kind_specific: Any, +) -> dict: + """A kind's full ``detail`` dict: its own fields plus the universal timeline ones. + + ``kind_specific`` comes first in the merge so a kind can never accidentally shadow + ``latency_breakdown``/``tool_calls`` with a same-named field of its own. + """ + return {**kind_specific, **timeline_detail(tool_call_events, reasoning_step_events)} + + +def raise_agentic_failure( + exception_cls: type[AgenticAssertionError], + message: str, + *, + reasoning_steps: list[str], + conversation_id: str, + response_id: str | None, + detail: dict, + runs_passed: int, + runs_effective: int, + best_run_latency_s: float | None, + timings: PhaseTimings | None = None, + failed_runs: list[dict] | None = None, + run_latencies_s: list[float] | None = None, +) -> NoReturn: + """Build ``exception_cls(message)`` with every common field attached, and raise it. + + ``exception_cls`` must be an ``AgenticAssertionError`` subclass -- that base class is + what declares these fields as legal targets (see its docstring). A kind whose own + "no verdict at all" branch raises a bare ``JudgeResponseError`` instead (not a subclass) + does not go through this helper for that branch. + + ``timings`` stays optional: only the three kinds that track per-run ``PhaseTimings`` + (general_question, metric_skill, dashboard_skill) pass one -- the rest keep their + own ``PhaseTimings()`` zero default, same as before this helper existed. ``failed_runs`` + and ``run_latencies_s`` are likewise optional: not every kind has built them by the + time it raises. + """ + exc = exception_cls(message) + exc.reasoning_steps = reasoning_steps + exc.conversation_id = conversation_id + exc.response_id = response_id + exc.detail = detail + exc.runs_passed = runs_passed + exc.runs_effective = runs_effective + exc.best_run_latency_s = best_run_latency_s + if timings is not None: + exc.timings = timings + if failed_runs is not None: + exc.failed_runs = failed_runs + if run_latencies_s is not None: + exc.run_latencies_s = run_latencies_s + raise exc + + +def agentic_success( + *, + reasoning_steps: list[str], + conversation_id: str | None, + response_id: str | None, + detail: dict, + runs_passed: int, + runs_effective: int, + best_run_latency_s: float | None, + timings: PhaseTimings | None = None, + failed_runs: list[dict] | None = None, + run_latencies_s: list[float] | None = None, +) -> AgenticEvalOutcome: + """The success-path mirror of ``raise_agentic_failure`` -- same fields, same shape.""" + kwargs: dict[str, Any] = { + "reasoning_steps": reasoning_steps, + "conversation_id": conversation_id, + "response_id": response_id, + "detail": detail, + "runs_passed": runs_passed, + "runs_effective": runs_effective, + "best_run_latency_s": best_run_latency_s, + } + if timings is not None: + kwargs["timings"] = timings + if failed_runs is not None: + kwargs["failed_runs"] = failed_runs + if run_latencies_s is not None: + kwargs["run_latencies_s"] = run_latencies_s + return AgenticEvalOutcome(**kwargs) diff --git a/packages/gooddata-eval/src/gooddata_eval/core/agentic/alert_skill.py b/packages/gooddata-eval/src/gooddata_eval/core/agentic/alert_skill.py index d27cf0bee..f1f532af3 100644 --- a/packages/gooddata-eval/src/gooddata_eval/core/agentic/alert_skill.py +++ b/packages/gooddata-eval/src/gooddata_eval/core/agentic/alert_skill.py @@ -23,6 +23,7 @@ log_gate_scores, stamp_gate_metadata, ) +from gooddata_eval.core.agentic._outcome import agentic_detail, agentic_success, raise_agentic_failure from gooddata_eval.core.agentic._trace_linker import ( RunIdentity, RunTraceContext, @@ -1262,9 +1263,25 @@ def _write_scores(ctx: RunTraceContext) -> None: best = summary.best ev = best.eval - # max_iterations is the same for every run, so it stays at the item level rather than - # being repeated into each failing run's detail. - detail = {**_run_detail(best), "max_iterations": max_iterations} + detail = agentic_detail( + best.tool_call_events, + best.reasoning_step_events, + alert_created=ev.alert_created, + operator_correct=ev.operator_correct, + threshold_correct=ev.threshold_correct, + trigger_correct=ev.trigger_correct, + filters_correct=ev.filters_correct, + metric_correct=ev.metric_correct, + recipients_correct=ev.recipients_correct, + attributes_correct=ev.attributes_correct, + granularity_correct=ev.granularity_correct, + actual_alert_arguments=best.actual_alert_arguments, + # Why the loop stopped. alert_created=False alone cannot tell a refusal from a run + # that hit max_iterations while still on track -- see LoopExit. + exit_reason=best.exit_reason.value, + turns_used=best.turns_used, + max_iterations=max_iterations, + ) # Same predicate runs_passed is taken over, so an item's failed_runs and its counts # cannot disagree about which runs failed. failed_runs = build_failed_runs( @@ -1275,30 +1292,33 @@ def _write_scores(ctx: RunTraceContext) -> None: if not gate_passed(gate, pass_at_k=summary.pass_at_k, pass_power_k=summary.pass_power_k): gate_note = gate_failure_note(gate, runs_passed, runs_effective) - exc = AlertSkillAssertionError( + raise_agentic_failure( + AlertSkillAssertionError, f"Alert skill assertion failed. {gate_note} strict_pass={ev.strict_pass}. " - + ", ".join(f"{name}={value}" for name, value in ev.checks().items()) - + f". Actual args: {best.actual_alert_arguments}" + f"alert_created={ev.alert_created}, operator_correct={ev.operator_correct}, " + f"threshold_correct={ev.threshold_correct}, trigger_correct={ev.trigger_correct}, " + f"filters_correct={ev.filters_correct}, metric_correct={ev.metric_correct}, " + f"recipients_correct={ev.recipients_correct}, " + f"attributes_correct={ev.attributes_correct}, " + f"granularity_correct={ev.granularity_correct}. " + f"Actual args: {best.actual_alert_arguments}", + reasoning_steps=best.reasoning_steps, + conversation_id=best.conversation_id, + response_id=best.response_id, + detail=detail, + runs_passed=runs_passed, + runs_effective=runs_effective, + failed_runs=failed_runs, + run_latencies_s=[r.run_latency_s for r in summary.run_results], + best_run_latency_s=best.run_latency_s, ) - exc.reasoning_steps = best.reasoning_steps - exc.conversation_id = best.conversation_id - exc.response_id = best.response_id - exc.detail = detail - exc.runs_passed = runs_passed - exc.runs_effective = runs_effective - exc.failed_runs = failed_runs - exc.run_latencies_s = [r.run_latency_s for r in summary.run_results] - exc.best_run_latency_s = best.run_latency_s - raise exc - return AgenticEvalOutcome( - runs_passed=runs_passed, - runs_effective=runs_effective, + return agentic_success( reasoning_steps=best.reasoning_steps, conversation_id=best.conversation_id, response_id=best.response_id, detail=detail, - # Also on the success path: pass@K clears the gate with one passing run, so a - # 1/3 item reports success while two of its runs failed for reasons worth reading. + runs_passed=runs_passed, + runs_effective=runs_effective, failed_runs=failed_runs, run_latencies_s=[r.run_latency_s for r in summary.run_results], best_run_latency_s=best.run_latency_s, diff --git a/packages/gooddata-eval/src/gooddata_eval/core/agentic/anomaly_detection.py b/packages/gooddata-eval/src/gooddata_eval/core/agentic/anomaly_detection.py index b97f5009b..25f2281a0 100644 --- a/packages/gooddata-eval/src/gooddata_eval/core/agentic/anomaly_detection.py +++ b/packages/gooddata-eval/src/gooddata_eval/core/agentic/anomaly_detection.py @@ -41,6 +41,7 @@ log_gate_scores, stamp_gate_metadata, ) +from gooddata_eval.core.agentic._outcome import agentic_detail, agentic_success, raise_agentic_failure from gooddata_eval.core.agentic._trace_linker import ( RunIdentity, RunTraceContext, @@ -58,9 +59,9 @@ AgenticAssertionError, AgenticEvalOutcome, ChatResult, + LoopExit, ReasoningStepEvent, ToolCallEvent, - build_latency_breakdown, shift_and_index_events, ) @@ -289,6 +290,10 @@ class AnomalyRunResult: # path's best_run_latency_s (see core/runner.py's _run_one_item). Distinct from # turn_wall_clock_sec above, which is only the final triggering turn. run_latency_s: float = 0.0 + # Why the simulated-user loop stopped -- see LoopExit. `triggered=False` alone cannot + # separate a refusal from a run that hit max_iterations while still on track (matches + # kda_skill.py/alert_skill.py). + exit_reason: LoopExit = LoopExit.BUDGET_EXHAUSTED @dataclass @@ -400,6 +405,10 @@ def _accumulate(result: ChatResult) -> None: all_reasoning_step_events.extend(result.reasoning_step_events or []) run_started = time.monotonic() + # Defaults to BUDGET_EXHAUSTED: every other exit assigns explicitly, so a loop that + # simply runs out of range() is labelled correctly with no trailing else. + exit_reason = LoopExit.BUDGET_EXHAUSTED + for iteration in range(max_iterations): try: chat_result = client.send_message(conv_id, current_question) @@ -412,6 +421,7 @@ def _accumulate(result: ChatResult) -> None: _accumulate(partial) viz_args, execute_result = _extract_anomaly_calls(all_tool_call_events) turn_completed = False + exit_reason = LoopExit.CHAT_ERROR break reasoning_steps.extend(chat_result.reasoning_steps or []) response_id = chat_result.response_id or response_id @@ -425,8 +435,10 @@ def _accumulate(result: ChatResult) -> None: if execute_result is not None: # The turn that ran the detection, not an earlier disambiguation turn. turn_wall_clock_sec = chat_result.turn_wall_clock_sec + exit_reason = LoopExit.SUCCESS break if not response_text: + exit_reason = LoopExit.AGENT_SILENT break if iteration >= max_iterations - 1: break @@ -435,6 +447,7 @@ def _accumulate(result: ChatResult) -> None: disambiguated = True except Exception as exc: # noqa: BLE001 -- harness-side fault; end only this run _log.warning("Simulated anomaly user reply failed for conversation %s: %s", conv_id, exc) + exit_reason = LoopExit.SIMULATED_USER_FAILED break return AnomalyRunResult( @@ -443,6 +456,7 @@ def _accumulate(result: ChatResult) -> None: actual_visualization=viz_args, actual_execute_result=execute_result, turn_wall_clock_sec=turn_wall_clock_sec, + exit_reason=exit_reason, reasoning_steps=reasoning_steps, response_id=response_id, tool_call_events=all_tool_call_events, @@ -496,25 +510,29 @@ class AnomalyDetectionAssertionError(AgenticAssertionError): def _detail(best: AnomalyRunResult) -> dict[str, Any]: ev = best.evaluation - return { - "triggered": ev.triggered, - "executed": ev.executed, - "success": ev.success, - "turn_completed": ev.turn_completed, - "metric_correct": ev.metric_correct, - "granularity_correct": ev.granularity_correct, + return agentic_detail( + best.tool_call_events, + best.reasoning_step_events, + triggered=ev.triggered, + executed=ev.executed, + success=ev.success, + turn_completed=ev.turn_completed, + metric_correct=ev.metric_correct, + granularity_correct=ev.granularity_correct, # Which content checks the fixture pinned -- without it a run that verified nothing # reads the same as one where everything matched. - "asserted": ev.asserted, - "disambiguated": ev.disambiguated, - "actual_metrics": sorted(_metric_uris(best.actual_visualization)), - "actual_granularity": _inferred_granularity(best.actual_visualization), + asserted=ev.asserted, + disambiguated=ev.disambiguated, + actual_metrics=sorted(_metric_uris(best.actual_visualization)), + actual_granularity=_inferred_granularity(best.actual_visualization), # Reported, never asserted: whether a real series contains anomalies is a property # of the data, so a fixture demanding some would fail on the next warehouse refresh. - "anomaly_point_count": _point_count(best.actual_execute_result), - "actual_execute_result": best.actual_execute_result, - "latency_breakdown": build_latency_breakdown(best.tool_call_events, best.reasoning_step_events), - } + anomaly_point_count=_point_count(best.actual_execute_result), + actual_execute_result=best.actual_execute_result, + # Why the loop stopped. triggered=False alone cannot tell a refusal from a run + # that hit max_iterations while still on track -- see LoopExit. + exit_reason=best.exit_reason.value, + ) def evaluate_agentic_anomaly_detection( @@ -651,25 +669,27 @@ def _write_scores(ctx: RunTraceContext) -> None: f"Analysed {detail['actual_metrics']} at {detail['actual_granularity']}. " f"Actual execute result: {best.actual_execute_result}." ) - exc = AnomalyDetectionAssertionError(message) - exc.reasoning_steps = best.reasoning_steps - exc.conversation_id = best.conversation_id - exc.response_id = best.response_id - exc.detail = detail - exc.runs_passed = runs_passed - exc.runs_effective = len(summary.run_results) - exc.failed_runs = failed_runs - exc.run_latencies_s = [r.run_latency_s for r in summary.run_results] - exc.best_run_latency_s = best.run_latency_s - raise exc - - return AgenticEvalOutcome( - runs_passed=runs_passed, - runs_effective=len(summary.run_results), + raise_agentic_failure( + AnomalyDetectionAssertionError, + message, + reasoning_steps=best.reasoning_steps, + conversation_id=best.conversation_id, + response_id=best.response_id, + detail=detail, + runs_passed=runs_passed, + runs_effective=len(summary.run_results), + failed_runs=failed_runs, + run_latencies_s=[r.run_latency_s for r in summary.run_results], + best_run_latency_s=best.run_latency_s, + ) + + return agentic_success( reasoning_steps=best.reasoning_steps, conversation_id=best.conversation_id, response_id=best.response_id, detail=detail, + runs_passed=runs_passed, + runs_effective=len(summary.run_results), failed_runs=failed_runs, run_latencies_s=[r.run_latency_s for r in summary.run_results], best_run_latency_s=best.run_latency_s, diff --git a/packages/gooddata-eval/src/gooddata_eval/core/agentic/conversation.py b/packages/gooddata-eval/src/gooddata_eval/core/agentic/conversation.py index 94846fcf2..92f106340 100644 --- a/packages/gooddata-eval/src/gooddata_eval/core/agentic/conversation.py +++ b/packages/gooddata-eval/src/gooddata_eval/core/agentic/conversation.py @@ -56,6 +56,7 @@ summarize_visualizations, ) from gooddata_eval.core.agentic._gate import log_gate_scores +from gooddata_eval.core.agentic._outcome import agentic_detail, agentic_success, raise_agentic_failure from gooddata_eval.core.agentic._trace_linker import ( RunIdentity, RunTraceContext, @@ -82,7 +83,6 @@ ReasoningStepEvent, ToolCallEvent, shift_and_index_events, - timeline_detail, ) from gooddata_eval.core.scoring import ( check_filters, @@ -1310,21 +1310,22 @@ def run_agentic_conversation( def _conversation_detail(result: ConversationResult) -> dict: - return { - "mode": result.mode, - "full_skill_coverage": result.full_skill_coverage, - "conversation_success": result.conversation_success, - "context_success": result.context_success, - "context_kept_rate": result.context_kept_rate, - "turns_before_first_break": result.turns_before_first_break, - "lost_context_clarifications": result.lost_context_clarifications, - "stalled_turns": result.stalled_turns, - "total_clarification_turns": result.total_clarification_turns, - "max_clarification_turns": result.max_clarification_turns, - "judge_model": result.judge_model, - "turns": [tr.detail() for tr in result.turn_results], - **timeline_detail(result.tool_call_events, result.reasoning_step_events), - } + return agentic_detail( + result.tool_call_events, + result.reasoning_step_events, + mode=result.mode, + full_skill_coverage=result.full_skill_coverage, + conversation_success=result.conversation_success, + context_success=result.context_success, + context_kept_rate=result.context_kept_rate, + turns_before_first_break=result.turns_before_first_break, + lost_context_clarifications=result.lost_context_clarifications, + stalled_turns=result.stalled_turns, + total_clarification_turns=result.total_clarification_turns, + max_clarification_turns=result.max_clarification_turns, + judge_model=result.judge_model, + turns=[tr.detail() for tr in result.turn_results], + ) class ConversationAssertionError(AgenticAssertionError): @@ -1511,19 +1512,21 @@ def _write_scores(ctx: RunTraceContext) -> None: f"full_skill_coverage={result.full_skill_coverage}. " f"Failed turns: {legacy_failed}" ) - exc = ConversationAssertionError(message) - exc.reasoning_steps = result.reasoning_steps - exc.conversation_id = result.conversation_id - exc.response_id = result.response_id - exc.detail = detail # This kind takes no k and drives its fixture exactly once, whatever --runs asks # for. Saying so explicitly stops the report claiming K runs that never happened. - exc.runs_passed = 0 - exc.runs_effective = 1 - exc.run_latencies_s = [result.run_latency_s] - exc.best_run_latency_s = result.run_latency_s - raise exc - return AgenticEvalOutcome( + raise_agentic_failure( + ConversationAssertionError, + message, + reasoning_steps=result.reasoning_steps, + conversation_id=result.conversation_id, + response_id=result.response_id, + detail=detail, + runs_passed=0, + runs_effective=1, + run_latencies_s=[result.run_latency_s], + best_run_latency_s=result.run_latency_s, + ) + return agentic_success( reasoning_steps=result.reasoning_steps, conversation_id=result.conversation_id, response_id=result.response_id, diff --git a/packages/gooddata-eval/src/gooddata_eval/core/agentic/dashboard_skill.py b/packages/gooddata-eval/src/gooddata_eval/core/agentic/dashboard_skill.py index b14919661..2327c182b 100644 --- a/packages/gooddata-eval/src/gooddata_eval/core/agentic/dashboard_skill.py +++ b/packages/gooddata-eval/src/gooddata_eval/core/agentic/dashboard_skill.py @@ -18,6 +18,7 @@ log_gate_scores, stamp_gate_metadata, ) +from gooddata_eval.core.agentic._outcome import agentic_detail, agentic_success, raise_agentic_failure from gooddata_eval.core.agentic._trace_linker import ( RunIdentity, RunTraceContext, @@ -35,6 +36,7 @@ AgenticAssertionError, AgenticEvalOutcome, ChatResult, + LoopExit, ReasoningStepEvent, ToolCallEvent, build_latency_breakdown, @@ -1492,6 +1494,11 @@ class DashboardRunResult: timings: PhaseTimings = field(default_factory=PhaseTimings) # This run's own wall time, from just before its chat call to the end of its scoring. run_latency_s: float = 0.0 + # Why the loop stopped -- see LoopExit. A dashboard not produced alone cannot tell a + # refusal from a run that hit max_iterations while still on track (matches + # kda_skill.py/alert_skill.py). No CHAT_ERROR/SIMULATED_USER_FAILED member here: this + # loop has neither a send_message try/except nor a simulated-user call to fail. + exit_reason: LoopExit = LoopExit.BUDGET_EXHAUSTED @dataclass @@ -1738,6 +1745,11 @@ def _execute_single_dashboard_run( turn_offset = 0.0 tool_index_offset = 0 reasoning_index_offset = 0 + # Defaults to BUDGET_EXHAUSTED: every other exit assigns explicitly, so a loop that + # simply runs out of range() (or the is_edit "no reply of its own" branch below, which + # is the same shape of outcome -- the agent answered, just not with the dashboard tool) + # is labelled correctly with no trailing else. + exit_reason = LoopExit.BUDGET_EXHAUSTED run_started = time.monotonic() for iteration in range(max_iterations): @@ -1778,10 +1790,12 @@ def _execute_single_dashboard_run( dashboard_part = _extract_dashboard_part(chat_result, "dashboard") if is_edit: patch_part = _extract_dashboard_part(chat_result, _PATCH_TYPE) + exit_reason = LoopExit.SUCCESS break response_text = (chat_result.text_response or "").strip() or render_answer_text(chat_result) if not response_text and not chat_result.tool_call_events: + exit_reason = LoopExit.AGENT_SILENT break if iteration >= max_iterations - 1: break @@ -1817,6 +1831,7 @@ def _execute_single_dashboard_run( reasoning_step_events=all_reasoning_step_events, timings=timings, run_latency_s=time.monotonic() - run_started, + exit_reason=exit_reason, ) @@ -2003,7 +2018,17 @@ def _write_scores(ctx: RunTraceContext) -> None: runs_effective = len(summary.run_results) best = summary.best - detail: dict[str, Any] = _run_detail(best) + detail: dict[str, Any] = agentic_detail( + best.tool_call_events, + best.reasoning_step_events, + **best.evaluation.strict_checks, + **best.evaluation.diagnostics, + failures=best.evaluation.failures, + notes=best.evaluation.notes, + # Why the loop stopped. A dashboard not produced alone cannot tell a refusal from + # a run that hit max_iterations while still on track -- see LoopExit. + exit_reason=best.exit_reason.value, + ) # Same predicate runs_passed is taken over, so an item's failed_runs and its counts # cannot disagree about which runs failed. failed_runs = build_failed_runs( @@ -2031,32 +2056,32 @@ def _write_scores(ctx: RunTraceContext) -> None: " one feature flag registers both, so check that before the model." ) notes = "; ".join(best.evaluation.notes) - exc = DashboardSkillAssertionError( + raise_agentic_failure( + DashboardSkillAssertionError, f"Dashboard skill assertion failed. {gate_note}{skill_note} " f"Checks: {best.evaluation.strict_checks}. " f"Failures: {'; '.join(best.evaluation.failures) or 'none reported'}." - + (f" Notes (not scored): {notes}." if notes else "") + + (f" Notes (not scored): {notes}." if notes else ""), + reasoning_steps=best.reasoning_steps, + conversation_id=best.conversation_id, + response_id=best.response_id, + detail=detail, + runs_passed=runs_passed, + runs_effective=runs_effective, + best_run_latency_s=run_latency_s(best.timings), + timings=item_timings, + failed_runs=failed_runs, + run_latencies_s=[r.run_latency_s for r in summary.run_results], ) - exc.reasoning_steps = best.reasoning_steps - exc.conversation_id = best.conversation_id - exc.response_id = best.response_id - exc.timings = item_timings - exc.best_run_latency_s = run_latency_s(best.timings) - exc.detail = detail - exc.runs_passed = runs_passed - exc.runs_effective = runs_effective - exc.failed_runs = failed_runs - exc.run_latencies_s = [r.run_latency_s for r in summary.run_results] - raise exc - return AgenticEvalOutcome( - runs_passed=runs_passed, - runs_effective=runs_effective, + return agentic_success( reasoning_steps=best.reasoning_steps, conversation_id=best.conversation_id, response_id=best.response_id, detail=detail, - timings=item_timings, + runs_passed=runs_passed, + runs_effective=runs_effective, failed_runs=failed_runs, run_latencies_s=[r.run_latency_s for r in summary.run_results], best_run_latency_s=run_latency_s(best.timings), + timings=item_timings, ) diff --git a/packages/gooddata-eval/src/gooddata_eval/core/agentic/general_question.py b/packages/gooddata-eval/src/gooddata_eval/core/agentic/general_question.py index aec78763c..3190d7754 100644 --- a/packages/gooddata-eval/src/gooddata_eval/core/agentic/general_question.py +++ b/packages/gooddata-eval/src/gooddata_eval/core/agentic/general_question.py @@ -15,6 +15,7 @@ log_gate_scores, stamp_gate_metadata, ) +from gooddata_eval.core.agentic._outcome import agentic_detail, agentic_success, raise_agentic_failure from gooddata_eval.core.agentic._trace_linker import ( RunIdentity, RunTraceContext, @@ -375,13 +376,17 @@ def _write_scores(ctx: RunTraceContext) -> None: run_latencies_s = [r.run_latency_s for r in summary.run_results] best = summary.best - detail = { - **_run_detail(best), + detail = agentic_detail( + best.tool_call_events, + best.reasoning_step_events, + judge_passed=best.passed, + judge_reasoning=best.reasoning, + actual_output=best.actual_output, # Only present when it happened, so the usual JSON shape is unchanged. A # pass@K computed over fewer runs than --runs asked for is a weaker result and # the report has to say so. **({"unscored_runs": len(unscored), "judge_errors": unscored} if unscored else {}), - } + ) # An ungraded run has no verdict, so `r.passed` is not a claim about it -- treat it as # non-passing here so it is recorded with its judge_error rather than silently dropped. failed_runs = build_failed_runs( @@ -407,25 +412,29 @@ def _write_scores(ctx: RunTraceContext) -> None: if not gate_passed(gate, pass_at_k=summary.pass_at_k, pass_power_k=summary.pass_power_k): gate_note = gate_failure_note(gate, runs_passed, runs_effective, len(unscored)) - exc = GeneralQuestionAssertionError( - f"General question assertion failed. {gate_note} passed={best.passed}. Reasoning: {best.reasoning}" + raise_agentic_failure( + GeneralQuestionAssertionError, + f"General question assertion failed. {gate_note} passed={best.passed}. Reasoning: {best.reasoning}", + reasoning_steps=best.reasoning_steps, + conversation_id=best.conversation_id, + response_id=best.response_id, + detail=detail, + runs_passed=runs_passed, + runs_effective=runs_effective, + failed_runs=failed_runs, + run_latencies_s=run_latencies_s, + best_run_latency_s=run_latency_s(best.timings), + timings=item_timings, ) - _attach_diagnostics( - exc, best, detail, failed_runs, runs_passed, runs_effective, run_latencies_s, run_latency_s(best.timings) - ) - exc.timings = item_timings - raise exc - return AgenticEvalOutcome( - runs_passed=runs_passed, - runs_effective=runs_effective, + return agentic_success( reasoning_steps=best.reasoning_steps, conversation_id=best.conversation_id, response_id=best.response_id, detail=detail, - timings=item_timings, - # Also on the success path: pass@K clears the gate with one passing run, so a - # 1/3 item reports success while two of its runs failed for reasons worth reading. + runs_passed=runs_passed, + runs_effective=runs_effective, failed_runs=failed_runs, run_latencies_s=run_latencies_s, best_run_latency_s=run_latency_s(best.timings), + timings=item_timings, ) diff --git a/packages/gooddata-eval/src/gooddata_eval/core/agentic/guardrail.py b/packages/gooddata-eval/src/gooddata_eval/core/agentic/guardrail.py index 2996fca33..f9e281c2d 100644 --- a/packages/gooddata-eval/src/gooddata_eval/core/agentic/guardrail.py +++ b/packages/gooddata-eval/src/gooddata_eval/core/agentic/guardrail.py @@ -15,6 +15,7 @@ log_gate_scores, stamp_gate_metadata, ) +from gooddata_eval.core.agentic._outcome import agentic_detail, agentic_success, raise_agentic_failure from gooddata_eval.core.agentic._trace_linker import ( RunIdentity, RunTraceContext, @@ -357,12 +358,16 @@ def _write_scores(ctx: RunTraceContext) -> None: run_latencies_s = [r.run_latency_s for r in summary.run_results] best = summary.best - detail = { - **_run_detail(best), + detail = agentic_detail( + best.tool_call_events, + best.reasoning_step_events, + judge_passed=best.passed, + judge_reasoning=best.reasoning, + actual_output=best.actual_output, # Only present when it happened, so the usual JSON shape is unchanged. A # pass@K over fewer runs than --runs asked for is a weaker result. **({"unscored_runs": len(unscored), "judge_errors": unscored} if unscored else {}), - } + ) # An ungraded run has no verdict, so `r.passed` is not a claim about it -- treat it as # non-passing here so it is recorded with its judge_error rather than silently dropped. failed_runs = build_failed_runs( @@ -385,22 +390,26 @@ def _write_scores(ctx: RunTraceContext) -> None: if not gate_passed(gate, pass_at_k=summary.pass_at_k, pass_power_k=summary.pass_power_k): gate_note = gate_failure_note(gate, runs_passed, runs_effective, len(unscored)) - exc = GuardrailAssertionError( - f"Guardrail assertion failed. {gate_note} passed={best.passed}. Reasoning: {best.reasoning}" - ) - _attach_diagnostics( - exc, best, detail, failed_runs, runs_passed, runs_effective, run_latencies_s, best.run_latency_s + raise_agentic_failure( + GuardrailAssertionError, + f"Guardrail assertion failed. {gate_note} passed={best.passed}. Reasoning: {best.reasoning}", + reasoning_steps=best.reasoning_steps, + conversation_id=best.conversation_id, + response_id=best.response_id, + detail=detail, + runs_passed=runs_passed, + runs_effective=runs_effective, + failed_runs=failed_runs, + run_latencies_s=run_latencies_s, + best_run_latency_s=best.run_latency_s, ) - raise exc - return AgenticEvalOutcome( - runs_passed=runs_passed, - runs_effective=runs_effective, + return agentic_success( reasoning_steps=best.reasoning_steps, conversation_id=best.conversation_id, response_id=best.response_id, detail=detail, - # Also on the success path: pass@K clears the gate with one passing run, so a - # 1/3 item reports success while two of its runs failed for reasons worth reading. + runs_passed=runs_passed, + runs_effective=runs_effective, failed_runs=failed_runs, run_latencies_s=run_latencies_s, best_run_latency_s=best.run_latency_s, diff --git a/packages/gooddata-eval/src/gooddata_eval/core/agentic/kda_skill.py b/packages/gooddata-eval/src/gooddata_eval/core/agentic/kda_skill.py index 57c97b4b2..683f8d42d 100644 --- a/packages/gooddata-eval/src/gooddata_eval/core/agentic/kda_skill.py +++ b/packages/gooddata-eval/src/gooddata_eval/core/agentic/kda_skill.py @@ -19,6 +19,7 @@ log_gate_scores, stamp_gate_metadata, ) +from gooddata_eval.core.agentic._outcome import agentic_detail, agentic_success, raise_agentic_failure from gooddata_eval.core.agentic._trace_linker import ( RunIdentity, RunTraceContext, @@ -565,9 +566,21 @@ def _write_scores(ctx: RunTraceContext) -> None: best = summary.best ev = best.evaluation - # max_iterations is the same for every run, so it stays at the item level rather than - # being repeated into each failing run's detail. - detail = {**_run_detail(best), "max_iterations": max_iterations} + detail = agentic_detail( + best.tool_call_events, + best.reasoning_step_events, + triggered=ev.triggered, + executed=ev.executed, + success=ev.success, + turn_completed=ev.turn_completed, + disambiguated=ev.disambiguated, + actual_create_args=best.actual_create_args, + actual_execute_result=best.actual_execute_result, + # Why the loop stopped -- see LoopExit. + exit_reason=best.exit_reason.value, + turns_used=best.turns_used, + max_iterations=max_iterations, + ) # Same predicate runs_passed is taken over, so an item's failed_runs and its counts # cannot disagree about which runs failed. failed_runs = build_failed_runs( @@ -585,26 +598,26 @@ def _write_scores(ctx: RunTraceContext) -> None: f"Actual create args: {best.actual_create_args}. " f"Actual execute result: {best.actual_execute_result}." ) - exc = KdaSkillAssertionError(message) - exc.reasoning_steps = best.reasoning_steps - exc.conversation_id = best.conversation_id - exc.response_id = best.response_id - exc.detail = detail - exc.runs_passed = runs_passed - exc.runs_effective = runs_effective - exc.failed_runs = failed_runs - exc.run_latencies_s = [r.run_latency_s for r in summary.run_results] - exc.best_run_latency_s = best.run_latency_s - raise exc - return AgenticEvalOutcome( - runs_passed=runs_passed, - runs_effective=runs_effective, + raise_agentic_failure( + KdaSkillAssertionError, + message, + reasoning_steps=best.reasoning_steps, + conversation_id=best.conversation_id, + response_id=best.response_id, + detail=detail, + runs_passed=runs_passed, + runs_effective=runs_effective, + failed_runs=failed_runs, + run_latencies_s=[r.run_latency_s for r in summary.run_results], + best_run_latency_s=best.run_latency_s, + ) + return agentic_success( reasoning_steps=best.reasoning_steps, conversation_id=best.conversation_id, response_id=best.response_id, detail=detail, - # Also on the success path: pass@K clears the gate with one passing run, so a - # 1/3 item reports success while two of its runs failed for reasons worth reading. + runs_passed=runs_passed, + runs_effective=runs_effective, failed_runs=failed_runs, run_latencies_s=[r.run_latency_s for r in summary.run_results], best_run_latency_s=best.run_latency_s, diff --git a/packages/gooddata-eval/src/gooddata_eval/core/agentic/metric_skill.py b/packages/gooddata-eval/src/gooddata_eval/core/agentic/metric_skill.py index f5996da86..f662b205b 100644 --- a/packages/gooddata-eval/src/gooddata_eval/core/agentic/metric_skill.py +++ b/packages/gooddata-eval/src/gooddata_eval/core/agentic/metric_skill.py @@ -21,6 +21,7 @@ log_gate_scores, stamp_gate_metadata, ) +from gooddata_eval.core.agentic._outcome import agentic_detail, agentic_success, raise_agentic_failure from gooddata_eval.core.agentic._trace_linker import ( RunIdentity, RunTraceContext, @@ -630,9 +631,19 @@ def _run_detail(run: MetricRunResult) -> dict: **timeline_detail(run.tool_call_events, run.reasoning_step_events), } - # max_iterations is the same for every run, so it stays at the item level rather than - # being repeated into each failing run's detail. - detail = {**_run_detail(best), "max_iterations": max_iterations} + detail = agentic_detail( + best.tool_call_events, + best.reasoning_step_events, + metric_created=best.metric_created, + maql_correct=best.maql_correct, + expected_maql_candidates=[c.get("maql", "") for c in expected_outputs_list], + actual_maql=best.actual_maql, + # Why the loop stopped. metric_created=False alone cannot tell a refusal from a run + # that hit max_iterations while still on track -- see LoopExit. + exit_reason=best.exit_reason.value, + turns_used=best.turns_used, + max_iterations=max_iterations, + ) # Same predicate runs_passed is taken over, so an item's failed_runs and its counts # cannot disagree about which runs failed. failed_runs = build_failed_runs( @@ -644,34 +655,32 @@ def _run_detail(run: MetricRunResult) -> dict: if not gate_passed(gate, pass_at_k=summary.pass_at_k, pass_power_k=summary.pass_power_k): gate_note = gate_failure_note(gate, runs_passed, runs_effective) candidates_str = "; ".join(repr(c.get("maql", "")) for c in expected_outputs_list) - exc = MetricSkillAssertionError( + raise_agentic_failure( + MetricSkillAssertionError, f"Metric skill assertion failed. {gate_note} " f"metric_created={best.metric_created}, maql_correct={best.maql_correct}. " f"Expected MAQL (candidates): {candidates_str}. " - f"Actual MAQL: {best.actual_maql}." + f"Actual MAQL: {best.actual_maql}.", + reasoning_steps=best.reasoning_steps, + conversation_id=best.conversation_id, + response_id=best.response_id, + detail=detail, + runs_passed=runs_passed, + runs_effective=runs_effective, + best_run_latency_s=run_latency_s(best.timings), + timings=item_timings, + failed_runs=failed_runs, + run_latencies_s=run_latencies_s, ) - exc.reasoning_steps = best.reasoning_steps - exc.conversation_id = best.conversation_id - exc.response_id = best.response_id - exc.timings = item_timings - exc.best_run_latency_s = run_latency_s(best.timings) - exc.detail = detail - exc.runs_passed = runs_passed - exc.runs_effective = runs_effective - exc.failed_runs = failed_runs - exc.run_latencies_s = run_latencies_s - raise exc - return AgenticEvalOutcome( - runs_passed=runs_passed, - runs_effective=runs_effective, + return agentic_success( reasoning_steps=best.reasoning_steps, conversation_id=best.conversation_id, response_id=best.response_id, detail=detail, - timings=item_timings, - # Also on the success path: pass@K clears the gate with one passing run, so a - # 1/3 item reports success while two of its runs failed for reasons worth reading. + runs_passed=runs_passed, + runs_effective=runs_effective, failed_runs=failed_runs, run_latencies_s=run_latencies_s, best_run_latency_s=run_latency_s(best.timings), + timings=item_timings, ) diff --git a/packages/gooddata-eval/src/gooddata_eval/core/agentic/search_tool.py b/packages/gooddata-eval/src/gooddata_eval/core/agentic/search_tool.py index 94de1935f..51100349a 100644 --- a/packages/gooddata-eval/src/gooddata_eval/core/agentic/search_tool.py +++ b/packages/gooddata-eval/src/gooddata_eval/core/agentic/search_tool.py @@ -15,6 +15,7 @@ log_gate_scores, stamp_gate_metadata, ) +from gooddata_eval.core.agentic._outcome import agentic_detail, agentic_success, raise_agentic_failure from gooddata_eval.core.agentic._trace_linker import ( RunIdentity, RunTraceContext, @@ -291,7 +292,13 @@ def _write_scores(ctx: RunTraceContext) -> None: runs_effective = len(summary.run_results) best = summary.best - detail = _run_detail(best) + detail = agentic_detail( + best.tool_call_events, + best.reasoning_step_events, + tool_selected=best.tool_selected, + tool_correct=best.tool_correct, + tool_call_names=best.tool_call_names, + ) # Same predicate pass@K and runs_passed are taken over, so an item's failed_runs and its # counts cannot disagree about which runs failed. failed_runs = build_failed_runs( @@ -302,30 +309,28 @@ def _write_scores(ctx: RunTraceContext) -> None: if not gate_passed(gate, pass_at_k=summary.pass_at_k, pass_power_k=summary.pass_power_k): gate_note = gate_failure_note(gate, runs_passed, runs_effective) - exc = SearchToolAssertionError( + raise_agentic_failure( + SearchToolAssertionError, f"Search tool assertion failed. {gate_note} " f"tool_selected={best.tool_selected}, tool_correct={best.tool_correct}. " - f"Tool calls made: {best.tool_call_names}" + f"Tool calls made: {best.tool_call_names}", + reasoning_steps=best.reasoning_steps, + conversation_id=best.conversation_id, + response_id=best.response_id, + detail=detail, + runs_passed=runs_passed, + runs_effective=runs_effective, + best_run_latency_s=best.run_latency_s, + failed_runs=failed_runs, + run_latencies_s=[r.run_latency_s for r in summary.run_results], ) - exc.reasoning_steps = best.reasoning_steps - exc.conversation_id = best.conversation_id - exc.response_id = best.response_id - exc.detail = detail - exc.runs_passed = runs_passed - exc.runs_effective = runs_effective - exc.failed_runs = failed_runs - exc.run_latencies_s = [r.run_latency_s for r in summary.run_results] - exc.best_run_latency_s = best.run_latency_s - raise exc - return AgenticEvalOutcome( - runs_passed=runs_passed, - runs_effective=runs_effective, + return agentic_success( reasoning_steps=best.reasoning_steps, conversation_id=best.conversation_id, response_id=best.response_id, detail=detail, - # Also on the success path: pass@K clears the gate with one passing run, so a - # 1/3 item reports success while two of its runs failed for reasons worth reading. + runs_passed=runs_passed, + runs_effective=runs_effective, failed_runs=failed_runs, run_latencies_s=[r.run_latency_s for r in summary.run_results], best_run_latency_s=best.run_latency_s, diff --git a/packages/gooddata-eval/src/gooddata_eval/core/agentic/visualization.py b/packages/gooddata-eval/src/gooddata_eval/core/agentic/visualization.py index 792b87d4a..b06821452 100644 --- a/packages/gooddata-eval/src/gooddata_eval/core/agentic/visualization.py +++ b/packages/gooddata-eval/src/gooddata_eval/core/agentic/visualization.py @@ -20,6 +20,7 @@ log_gate_scores, stamp_gate_metadata, ) +from gooddata_eval.core.agentic._outcome import agentic_detail, agentic_success, raise_agentic_failure from gooddata_eval.core.agentic._trace_linker import ( RunIdentity, RunTraceContext, @@ -645,9 +646,16 @@ def _write_scores(ctx: RunTraceContext) -> None: best = summary.best ev = best.eval_result - # max_iterations is the same for every run, so it stays at the item level rather than - # being repeated into each failing run's detail. - detail = {**_run_detail(best), "max_iterations": max_iterations} + detail = agentic_detail( + best.tool_call_events, + best.reasoning_step_events, + **evaluation_result_detail(ev), + # Why the loop stopped -- see LoopExit. total_turns is already the turn count for + # this run, so it doubles as turns_used. + exit_reason=best.exit_reason.value, + turns_used=int(best.total_turns), + max_iterations=max_iterations, + ) # Same predicate runs_passed is taken over, so an item's failed_runs and its counts # cannot disagree about which runs failed. Every failing run keeps its own # expected/actual check breakdown -- for this kind that is the whole diagnosis, and @@ -669,7 +677,8 @@ def _write_scores(ctx: RunTraceContext) -> None: else {"expects_visualization": False} ) actual_dump = best.actual_output.model_dump(exclude_none=True) if best.actual_output else None - exc = VisualizationAssertionError( + raise_agentic_failure( + VisualizationAssertionError, "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n" "Agentic Visualization Assertion Failed! (Critical Mode)\n" f"{gate_note}\n" @@ -701,27 +710,24 @@ def _write_scores(ctx: RunTraceContext) -> None: f" Executed : {ev.executed}{' (required)' if ev.requires_execution else ''}\n" f"{_options_lines(ev, best.answer_text)}" f" Stated Value Matches : {ev.stated_value_matches} (reported only)\n" - "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n" + "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n", + reasoning_steps=best.reasoning_steps, + conversation_id=best.conversation_id, + response_id=best.response_id, + detail=detail, + runs_passed=runs_passed, + runs_effective=runs_effective, + failed_runs=failed_runs, + run_latencies_s=run_latencies_s, + best_run_latency_s=best.run_latency_s, ) - exc.reasoning_steps = best.reasoning_steps - exc.conversation_id = best.conversation_id - exc.response_id = best.response_id - exc.detail = detail - exc.runs_passed = runs_passed - exc.runs_effective = runs_effective - exc.failed_runs = failed_runs - exc.run_latencies_s = run_latencies_s - exc.best_run_latency_s = best.run_latency_s - raise exc - return AgenticEvalOutcome( - runs_passed=runs_passed, - runs_effective=runs_effective, + return agentic_success( reasoning_steps=best.reasoning_steps, conversation_id=best.conversation_id, response_id=best.response_id, detail=detail, - # Also on the success path: pass@K clears the gate with one passing run, so a - # 1/3 item reports success while two of its runs failed for reasons worth reading. + runs_passed=runs_passed, + runs_effective=runs_effective, failed_runs=failed_runs, run_latencies_s=run_latencies_s, best_run_latency_s=best.run_latency_s, diff --git a/packages/gooddata-eval/src/gooddata_eval/core/agentic/what_if.py b/packages/gooddata-eval/src/gooddata_eval/core/agentic/what_if.py index a7d9ebdb4..de124ceed 100644 --- a/packages/gooddata-eval/src/gooddata_eval/core/agentic/what_if.py +++ b/packages/gooddata-eval/src/gooddata_eval/core/agentic/what_if.py @@ -35,6 +35,7 @@ log_gate_scores, stamp_gate_metadata, ) +from gooddata_eval.core.agentic._outcome import agentic_detail, agentic_success, raise_agentic_failure from gooddata_eval.core.agentic._trace_linker import ( RunIdentity, RunTraceContext, @@ -53,9 +54,9 @@ AgenticAssertionError, AgenticEvalOutcome, ChatResult, + LoopExit, ReasoningStepEvent, ToolCallEvent, - build_latency_breakdown, shift_and_index_events, ) @@ -216,6 +217,10 @@ class WhatIfRunResult: # path's best_run_latency_s (see core/runner.py's _run_one_item). Distinct from # turn_wall_clock_sec above, which is only the scenario-execution turn. run_latency_s: float = 0.0 + # Why the simulated-user loop stopped -- see LoopExit. `triggered=False` alone cannot + # separate a refusal from a run that hit max_iterations while still on track (matches + # kda_skill.py/alert_skill.py). + exit_reason: LoopExit = LoopExit.BUDGET_EXHAUSTED @dataclass @@ -357,6 +362,10 @@ def _accumulate(result: ChatResult) -> None: all_reasoning_step_events.extend(result.reasoning_step_events or []) run_started = time.monotonic() + # Defaults to BUDGET_EXHAUSTED: every other exit assigns explicitly, so a loop that + # simply runs out of range() is labelled correctly with no trailing else. + exit_reason = LoopExit.BUDGET_EXHAUSTED + for iteration in range(max_iterations): try: chat_result = client.send_message(conv_id, current_question) @@ -369,6 +378,7 @@ def _accumulate(result: ChatResult) -> None: _accumulate(partial) create_args, execute_result = _extract_what_if_calls(all_tool_call_events) turn_completed = False + exit_reason = LoopExit.CHAT_ERROR break reasoning_steps.extend(chat_result.reasoning_steps or []) response_id = chat_result.response_id or response_id @@ -382,8 +392,10 @@ def _accumulate(result: ChatResult) -> None: if execute_result is not None: # The turn that ran the scenario, not an earlier disambiguation turn. turn_wall_clock_sec = chat_result.turn_wall_clock_sec + exit_reason = LoopExit.SUCCESS break if not response_text: + exit_reason = LoopExit.AGENT_SILENT break if iteration >= max_iterations - 1: break @@ -392,6 +404,7 @@ def _accumulate(result: ChatResult) -> None: disambiguated = True except Exception as exc: # noqa: BLE001 -- harness-side fault; end only this run _log.warning("Simulated what-if user reply failed for conversation %s: %s", conv_id, exc) + exit_reason = LoopExit.SIMULATED_USER_FAILED break return WhatIfRunResult( @@ -399,6 +412,7 @@ def _accumulate(result: ChatResult) -> None: evaluation=_evaluate_run(create_args, execute_result, expected_output, turn_completed, disambiguated), actual_create_args=create_args, actual_execute_result=execute_result, + exit_reason=exit_reason, turn_wall_clock_sec=turn_wall_clock_sec, reasoning_steps=reasoning_steps, response_id=response_id, @@ -456,26 +470,30 @@ class WhatIfAssertionError(AgenticAssertionError): def _detail(best: WhatIfRunResult) -> dict[str, Any]: ev = best.evaluation adjustments = _adjustments(best.actual_create_args) - return { - "triggered": ev.triggered, - "executed": ev.executed, - "success": ev.success, - "turn_completed": ev.turn_completed, - "metric_correct": ev.metric_correct, - "maql_correct": ev.maql_correct, - "scenario_count_correct": ev.scenario_count_correct, - "baseline_correct": ev.baseline_correct, + return agentic_detail( + best.tool_call_events, + best.reasoning_step_events, + triggered=ev.triggered, + executed=ev.executed, + success=ev.success, + turn_completed=ev.turn_completed, + metric_correct=ev.metric_correct, + maql_correct=ev.maql_correct, + scenario_count_correct=ev.scenario_count_correct, + baseline_correct=ev.baseline_correct, # Which content checks the fixture pinned -- without it a run that verified nothing # reads the same as one where everything matched. - "asserted": ev.asserted, - "disambiguated": ev.disambiguated, - "actual_adjustments": adjustments, - "actual_scenario_labels": [ + asserted=ev.asserted, + disambiguated=ev.disambiguated, + actual_adjustments=adjustments, + actual_scenario_labels=[ s.get("label") for s in ((best.actual_create_args or {}).get("scenarios") or []) if isinstance(s, dict) ], - "actual_execute_result": best.actual_execute_result, - "latency_breakdown": build_latency_breakdown(best.tool_call_events, best.reasoning_step_events), - } + actual_execute_result=best.actual_execute_result, + # Why the loop stopped. triggered=False alone cannot tell a refusal from a run + # that hit max_iterations while still on track -- see LoopExit. + exit_reason=best.exit_reason.value, + ) def evaluate_agentic_what_if( @@ -616,25 +634,27 @@ def _write_scores(ctx: RunTraceContext) -> None: f"Actual adjustments: {detail['actual_adjustments']}. " f"Actual execute result: {best.actual_execute_result}." ) - exc = WhatIfAssertionError(message) - exc.reasoning_steps = best.reasoning_steps - exc.conversation_id = best.conversation_id - exc.response_id = best.response_id - exc.detail = detail - exc.runs_passed = runs_passed - exc.runs_effective = len(summary.run_results) - exc.failed_runs = failed_runs - exc.run_latencies_s = [r.run_latency_s for r in summary.run_results] - exc.best_run_latency_s = best.run_latency_s - raise exc - - return AgenticEvalOutcome( - runs_passed=runs_passed, - runs_effective=len(summary.run_results), + raise_agentic_failure( + WhatIfAssertionError, + message, + reasoning_steps=best.reasoning_steps, + conversation_id=best.conversation_id, + response_id=best.response_id, + detail=detail, + runs_passed=runs_passed, + runs_effective=len(summary.run_results), + failed_runs=failed_runs, + run_latencies_s=[r.run_latency_s for r in summary.run_results], + best_run_latency_s=best.run_latency_s, + ) + + return agentic_success( reasoning_steps=best.reasoning_steps, conversation_id=best.conversation_id, response_id=best.response_id, detail=detail, + runs_passed=runs_passed, + runs_effective=len(summary.run_results), failed_runs=failed_runs, run_latencies_s=[r.run_latency_s for r in summary.run_results], best_run_latency_s=best.run_latency_s, diff --git a/packages/gooddata-eval/tests/test_agentic_anomaly_detection.py b/packages/gooddata-eval/tests/test_agentic_anomaly_detection.py index d7fef2965..5c1e25d8b 100644 --- a/packages/gooddata-eval/tests/test_agentic_anomaly_detection.py +++ b/packages/gooddata-eval/tests/test_agentic_anomaly_detection.py @@ -16,7 +16,7 @@ evaluate_agentic_anomaly_detection, run_agentic_anomaly_detection, ) -from gooddata_eval.core.models import ChatResult +from gooddata_eval.core.models import ChatResult, LoopExit _MODULE = "gooddata_eval.core.agentic.anomaly_detection" @@ -254,18 +254,22 @@ def test_a_single_turn_detection_passes(): summary = _run([_chat(_pair())]) assert summary.pass_at_k is True assert summary.best.evaluation.disambiguated is False + assert summary.best.exit_reason is LoopExit.SUCCESS def test_a_clarifying_question_is_answered_and_the_run_continues(): summary = _run([_chat([], text="Which Spend metric did you mean?"), _chat(_pair())]) assert summary.pass_at_k is True assert summary.best.evaluation.disambiguated is True + assert summary.best.exit_reason is LoopExit.SUCCESS def test_the_loop_stops_at_max_iterations_without_a_detection(): + # executed=False alone cannot tell this apart from a refusal -- exit_reason can. summary = _run([_chat([], text="Still thinking")] * 4, max_iterations=4) assert summary.pass_at_k is False assert summary.best.evaluation.executed is False + assert summary.best.exit_reason is LoopExit.BUDGET_EXHAUSTED def test_an_empty_response_ends_the_run_immediately(): @@ -276,17 +280,19 @@ def test_an_empty_response_ends_the_run_immediately(): patch(f"{_MODULE}.ChatClient", return_value=client), patch(f"{_MODULE}.generate_simulated_anomaly_response") as sim, ): - run_agentic_anomaly_detection( + summary = run_agentic_anomaly_detection( host="http://h", token="tok", workspace_id="ws1", question="q", expected_output=_EXPECTED ) assert client.send_message.call_count == 1 sim.assert_not_called() + assert summary.best.exit_reason is LoopExit.AGENT_SILENT def test_a_chat_error_on_a_later_run_does_not_discard_the_earlier_one(): summary = _run([_chat(_pair()), RuntimeError("boom")], k=2) assert len(summary.run_results) == 2 assert summary.pass_at_k is True + assert summary.run_results[1].exit_reason is LoopExit.CHAT_ERROR def test_k_must_be_at_least_one(): @@ -318,6 +324,8 @@ def test_detail_reports_the_series_analysed_and_the_flag_count(): assert outcome.detail["anomaly_point_count"] == 0 assert outcome.detail["asserted"] == ["metric", "granularity"] assert "latency_breakdown" in outcome.detail + assert "tool_calls" in outcome.detail + assert outcome.detail["exit_reason"] == "success" assert outcome.runs_passed == 1 assert len(outcome.run_latencies_s) == outcome.runs_effective == 1 assert all(latency >= 0 for latency in outcome.run_latencies_s) diff --git a/packages/gooddata-eval/tests/test_agentic_dashboard_skill.py b/packages/gooddata-eval/tests/test_agentic_dashboard_skill.py index 94a39a970..0fec05102 100644 --- a/packages/gooddata-eval/tests/test_agentic_dashboard_skill.py +++ b/packages/gooddata-eval/tests/test_agentic_dashboard_skill.py @@ -17,7 +17,7 @@ evaluate_dashboard_response, run_agentic_dashboard_skill, ) -from gooddata_eval.core.models import ChatResult, ToolCallEvent +from gooddata_eval.core.models import ChatResult, LoopExit, ToolCallEvent # Ids and titles are the ones the eval layout seeds; shapes are trimmed from real runs of # `agent_dashboard_skill` against ecommerce_demo. @@ -2343,6 +2343,8 @@ def test_the_loop_is_capped(self): assert client.send_message.call_count == 2 assert not summary.pass_at_k assert not summary.best.evaluation.drafted + # drafted=False alone cannot tell this apart from a refusal -- exit_reason can. + assert summary.best.exit_reason is LoopExit.BUDGET_EXHAUSTED def test_an_empty_turn_stops_the_loop(self): client = MagicMock() @@ -2350,6 +2352,7 @@ def test_an_empty_turn_stops_the_loop(self): summary = _run_with(client, _DC05_EXPECTED, max_iterations=5) assert client.send_message.call_count == 1 assert not summary.pass_at_k + assert summary.best.exit_reason is LoopExit.AGENT_SILENT def test_a_caller_supplied_conversation_is_not_deleted(self): client = MagicMock() @@ -2421,6 +2424,8 @@ def test_a_passing_run_returns_the_outcome(self): assert outcome.detail["charts_matched"] is True assert len(outcome.run_latencies_s) == outcome.runs_effective assert all(latency >= 0 for latency in outcome.run_latencies_s) + assert outcome.detail["exit_reason"] == "success" + assert "tool_calls" in outcome.detail def _as_events(raw: list[dict]) -> list[ToolCallEvent]: diff --git a/packages/gooddata-eval/tests/test_agentic_general_question.py b/packages/gooddata-eval/tests/test_agentic_general_question.py index ba30b602c..64fca9012 100644 --- a/packages/gooddata-eval/tests/test_agentic_general_question.py +++ b/packages/gooddata-eval/tests/test_agentic_general_question.py @@ -257,6 +257,7 @@ def test_evaluate_agentic_general_question_returns_reasoning_steps_on_pass(): "judge_reasoning": "Correct answer", "actual_output": "42", "latency_breakdown": [], + "tool_calls": [], } # One wall-clock sample per run, passing runs included -- the latency distribution is over # these, and a kind that forgot to report them would silently drop out of it. @@ -288,6 +289,7 @@ def test_evaluate_agentic_general_question_attaches_reasoning_steps_to_exception "judge_reasoning": "Wrong answer", "actual_output": "I don't know", "latency_breakdown": [], + "tool_calls": [], } assert len(exc_info.value.run_latencies_s) == exc_info.value.runs_effective == 1 diff --git a/packages/gooddata-eval/tests/test_agentic_kda_skill.py b/packages/gooddata-eval/tests/test_agentic_kda_skill.py index 07f8bcb64..6a1690ebb 100644 --- a/packages/gooddata-eval/tests/test_agentic_kda_skill.py +++ b/packages/gooddata-eval/tests/test_agentic_kda_skill.py @@ -1134,6 +1134,7 @@ def test_evaluate_agentic_kda_skill_returns_reasoning_steps_on_pass(): "turns_used": 1, "max_iterations": 1, "latency_breakdown": [], + "tool_calls": [], } assert len(outcome.run_latencies_s) == outcome.runs_effective == 1 assert all(latency >= 0 for latency in outcome.run_latencies_s) @@ -1174,6 +1175,7 @@ def test_evaluate_agentic_kda_skill_attaches_reasoning_steps_to_exception_on_fai "turns_used": 1, "max_iterations": 1, "latency_breakdown": [], + "tool_calls": [], } assert len(exc_info.value.run_latencies_s) == exc_info.value.runs_effective == 1 diff --git a/packages/gooddata-eval/tests/test_agentic_runner.py b/packages/gooddata-eval/tests/test_agentic_runner.py index b779361d1..67d3513b0 100644 --- a/packages/gooddata-eval/tests/test_agentic_runner.py +++ b/packages/gooddata-eval/tests/test_agentic_runner.py @@ -1039,9 +1039,15 @@ def test_every_multi_run_kind_s_evaluator_builds_failed_runs(kind, expected_outp pytest.skip(f"{kind} runs its fixture once; no K to fail within") assert "build_failed_runs(" in source, f"{module.__name__} never builds per-run failure records" assert "failed_runs=failed_runs" in source, f"{module.__name__} never returns them on the success path" - # Either set directly on the raised error, or via the kind's own _attach_diagnostics - # helper -- the judge-based kinds raise from two places and set the payload in one. - attaches = "failed_runs = failed_runs" in source or "_attach_diagnostics(" in source + # Either set directly on the raised error, via the kind's own _attach_diagnostics + # helper (the judge-based kinds raise from two places and set the payload in one), or + # passed to raise_agentic_failure -- the shared tail every other kind's failure raise + # goes through, alongside its agentic_success mirror, so the keyword appears twice. + attaches = ( + "failed_runs = failed_runs" in source + or "_attach_diagnostics(" in source + or ("raise_agentic_failure(" in source and source.count("failed_runs=failed_runs") >= 2) + ) assert attaches, f"{module.__name__} never attaches them to its failure" @@ -1183,7 +1189,13 @@ def test_every_evaluator_hands_out_its_run_latencies(kind, expected_output, targ module = importlib.import_module(getattr(agentic_runner, target).__module__) source = inspect.getsource(module) assert "run_latencies_s=" in source, f"{module.__name__} never returns its run latencies on the success path" - assert ".run_latencies_s = " in source, f"{module.__name__} never attaches them to its failure" + # Either set directly on the raised error (the two judge-based kinds' all-ungraded + # path), or passed to raise_agentic_failure alongside its agentic_success mirror, so + # the keyword appears at least twice. + attaches = ".run_latencies_s = " in source or ( + "raise_agentic_failure(" in source and source.count("run_latencies_s=") >= 2 + ) + assert attaches, f"{module.__name__} never attaches them to its failure" @pytest.mark.parametrize(("kind", "expected_output", "target"), _ALL_AGENTIC_KIND_CASES) diff --git a/packages/gooddata-eval/tests/test_agentic_search_tool.py b/packages/gooddata-eval/tests/test_agentic_search_tool.py index e188e7b99..d103fb389 100644 --- a/packages/gooddata-eval/tests/test_agentic_search_tool.py +++ b/packages/gooddata-eval/tests/test_agentic_search_tool.py @@ -208,6 +208,7 @@ def test_evaluate_agentic_search_tool_returns_reasoning_steps_on_pass(): "tool_correct": True, "tool_call_names": ["search_objects"], "latency_breakdown": [], + "tool_calls": [], } # One wall-clock sample per run, passing runs included -- the latency distribution is over # these, and a kind that forgot to report them would silently drop out of it. @@ -248,5 +249,6 @@ def test_evaluate_agentic_search_tool_attaches_reasoning_steps_to_exception_on_f "tool_correct": False, "tool_call_names": [], "latency_breakdown": [], + "tool_calls": [], } assert len(exc_info.value.run_latencies_s) == exc_info.value.runs_effective == 1 diff --git a/packages/gooddata-eval/tests/test_agentic_what_if.py b/packages/gooddata-eval/tests/test_agentic_what_if.py index 67a3cc84c..38b04ebf3 100644 --- a/packages/gooddata-eval/tests/test_agentic_what_if.py +++ b/packages/gooddata-eval/tests/test_agentic_what_if.py @@ -13,7 +13,7 @@ evaluate_agentic_what_if, run_agentic_what_if, ) -from gooddata_eval.core.models import ChatResult +from gooddata_eval.core.models import ChatResult, LoopExit _MODULE = "gooddata_eval.core.agentic.what_if" @@ -215,6 +215,7 @@ def test_a_single_turn_scenario_passes(): summary = _run([_chat(_pair())]) assert summary.pass_at_k is True assert summary.best.evaluation.disambiguated is False + assert summary.best.exit_reason is LoopExit.SUCCESS def test_a_clarifying_question_is_answered_and_the_run_continues(): @@ -222,12 +223,15 @@ def test_a_clarifying_question_is_answered_and_the_run_continues(): summary = _run([_chat([], text="Which Spend metric did you mean?"), _chat(_pair())]) assert summary.pass_at_k is True assert summary.best.evaluation.disambiguated is True + assert summary.best.exit_reason is LoopExit.SUCCESS def test_the_loop_stops_at_max_iterations_without_a_scenario(): + # triggered=False alone cannot tell this apart from a refusal -- exit_reason can. summary = _run([_chat([], text="Still thinking")] * 4, max_iterations=4) assert summary.pass_at_k is False assert summary.best.evaluation.triggered is False + assert summary.best.exit_reason is LoopExit.BUDGET_EXHAUSTED def test_an_empty_response_ends_the_run_immediately(): @@ -238,15 +242,19 @@ def test_an_empty_response_ends_the_run_immediately(): patch(f"{_MODULE}.ChatClient", return_value=client), patch(f"{_MODULE}.generate_simulated_what_if_response") as sim, ): - run_agentic_what_if(host="http://h", token="tok", workspace_id="ws1", question="q", expected_output=_EXPECTED) + summary = run_agentic_what_if( + host="http://h", token="tok", workspace_id="ws1", question="q", expected_output=_EXPECTED + ) assert client.send_message.call_count == 1 sim.assert_not_called() + assert summary.best.exit_reason is LoopExit.AGENT_SILENT def test_a_chat_error_on_a_later_run_does_not_discard_the_earlier_one(): summary = _run([_chat(_pair()), RuntimeError("boom")], k=2) assert len(summary.run_results) == 2 assert summary.pass_at_k is True + assert summary.run_results[1].exit_reason is LoopExit.CHAT_ERROR def test_k_must_be_at_least_one(): @@ -277,6 +285,8 @@ def test_detail_reports_the_adjustments_the_agent_asked_for(): assert outcome.detail["actual_scenario_labels"] == ["Scenario A"] assert outcome.detail["asserted"] == ["metric_id", "scenario_maql"] assert "latency_breakdown" in outcome.detail + assert "tool_calls" in outcome.detail + assert outcome.detail["exit_reason"] == "success" assert outcome.runs_passed == 1 assert len(outcome.run_latencies_s) == outcome.runs_effective == 1 assert all(latency >= 0 for latency in outcome.run_latencies_s) From 92cd8ea233683432680042274a6d6dcb327a279a Mon Sep 17 00:00:00 2001 From: Peter Tomko Date: Wed, 7 Oct 2026 23:14:39 +0200 Subject: [PATCH 3/4] fix(gooddata-eval): record a dashboard chat fault instead of letting it escape ChatClient.send_message can raise ChatError, and the dashboard loop was the only one that let it through. Escaping run_agentic_dashboard_skill discarded every K-run already completed along with this one's exit_reason, so the item surfaced as a bare error with no per-run diagnosis -- exactly what the shared LoopExit contract exists to prevent. metric_skill.py and conversation.py already record it; this matches them. A bare catch would have discarded ChatError.partial_result. What the stream delivered before it died is still the turn's work, so its reasoning, tool calls and step count are merged -- shifted and indexed the way a completed turn is, since left raw a late turn's call_ts restarts near zero and timeline_detail would report it as overlapping the first. DashboardRunResult's comment claimed CHAT_ERROR was unreachable here because the loop had no try/except. That had it backwards: the missing try/except was the bug, not a reason the fault could not occur. SIMULATED_USER_FAILED really is unreachable -- the follow-up is built by build_simulated_reply with no judge call to fail -- and the comment now says so. Three tests, each verified to fail without the fix. Co-Authored-By: Claude Opus 5 --- .../core/agentic/dashboard_skill.py | 35 +++++++++++-- .../tests/test_agentic_dashboard_skill.py | 49 +++++++++++++++++++ 2 files changed, 80 insertions(+), 4 deletions(-) diff --git a/packages/gooddata-eval/src/gooddata_eval/core/agentic/dashboard_skill.py b/packages/gooddata-eval/src/gooddata_eval/core/agentic/dashboard_skill.py index 2327c182b..35de92558 100644 --- a/packages/gooddata-eval/src/gooddata_eval/core/agentic/dashboard_skill.py +++ b/packages/gooddata-eval/src/gooddata_eval/core/agentic/dashboard_skill.py @@ -29,7 +29,7 @@ utc_now, ) from gooddata_eval.core.chat.render import render_answer_text -from gooddata_eval.core.chat.sse_client import ChatClient +from gooddata_eval.core.chat.sse_client import ChatClient, ChatError from gooddata_eval.core.config import ReasoningEffort from gooddata_eval.core.langfuse.item_scope import item_scope from gooddata_eval.core.models import ( @@ -1496,8 +1496,9 @@ class DashboardRunResult: run_latency_s: float = 0.0 # Why the loop stopped -- see LoopExit. A dashboard not produced alone cannot tell a # refusal from a run that hit max_iterations while still on track (matches - # kda_skill.py/alert_skill.py). No CHAT_ERROR/SIMULATED_USER_FAILED member here: this - # loop has neither a send_message try/except nor a simulated-user call to fail. + # kda_skill.py/alert_skill.py). CHAT_ERROR is reachable; SIMULATED_USER_FAILED is not -- + # this loop's follow-up is built from the expectation by build_simulated_reply, with no + # judge call that could fail. exit_reason: LoopExit = LoopExit.BUDGET_EXHAUSTED @@ -1755,7 +1756,33 @@ def _execute_single_dashboard_run( for iteration in range(max_iterations): turns += 1 agent_started = time.monotonic() - chat_result = client.send_message(conversation_id, current_question) + try: + chat_result = client.send_message(conversation_id, current_question) + except ChatError as exc: + # Recorded rather than left to escape: this runs inside one of K runs, so an + # uncaught ChatError discarded every run already completed along with this one's + # exit_reason, and the item surfaced as a bare error with no per-run diagnosis. + # Matches metric_skill.py and conversation.py, which record it the same way. + timings.agent_s += time.monotonic() - agent_started + print(f"[CHAT] send_message failed for conversation {conversation_id}: {exc}") + partial = exc.partial_result + if partial is not None: + # Shifted and indexed exactly as a completed turn is, before anything reads + # the events: left raw, a late turn's call_ts restarts near zero and + # timeline_detail reports it as overlapping the first one. + reasoning_steps.extend(partial.reasoning_steps or []) + response_id = partial.response_id or response_id + turn_offset, tool_index_offset, reasoning_index_offset = shift_and_index_events( + partial, + turn_offset=turn_offset, + tool_index_offset=tool_index_offset, + reasoning_index_offset=reasoning_index_offset, + ) + all_tool_call_events.extend(partial.tool_call_events or []) + all_reasoning_step_events.extend(partial.reasoning_step_events or []) + steps += partial.reasoning_step_count + exit_reason = LoopExit.CHAT_ERROR + break agent_elapsed = time.monotonic() - agent_started timings.agent_s += agent_elapsed reasoning_steps.extend(chat_result.reasoning_steps or []) diff --git a/packages/gooddata-eval/tests/test_agentic_dashboard_skill.py b/packages/gooddata-eval/tests/test_agentic_dashboard_skill.py index 0fec05102..ea04e07e8 100644 --- a/packages/gooddata-eval/tests/test_agentic_dashboard_skill.py +++ b/packages/gooddata-eval/tests/test_agentic_dashboard_skill.py @@ -17,6 +17,7 @@ evaluate_dashboard_response, run_agentic_dashboard_skill, ) +from gooddata_eval.core.chat.sse_client import ChatError from gooddata_eval.core.models import ChatResult, LoopExit, ToolCallEvent # Ids and titles are the ones the eval layout seeds; shapes are trimmed from real runs of @@ -2361,6 +2362,54 @@ def test_a_caller_supplied_conversation_is_not_deleted(self): client.create_conversation.assert_not_called() client.delete_conversation.assert_not_called() + def test_a_chat_error_is_recorded_rather_than_left_to_escape(self): + """It used to escape run_agentic_dashboard_skill, taking every completed K-run with + it: no DashboardRunResult, no exit_reason, just a bare error on the item. Recorded + the way metric_skill.py and conversation.py record it, so an infrastructure fault + stays distinguishable from the agent failing to draft.""" + client = MagicMock() + client.send_message.side_effect = ChatError("gen-ai fell over") + + summary = _run_with(client, _DC05_EXPECTED) + + assert summary.run_results[0].exit_reason is LoopExit.CHAT_ERROR + assert summary.run_results[0].evaluation.strict_pass is False + assert summary.pass_at_k is False + + def test_a_chat_error_keeps_the_partial_turn_s_work(self): + """A bare catch would discard ChatError.partial_result. What the stream delivered + before it died is still this turn's work -- the steps were taken and the tools ran.""" + partial = _chat_result( + tool_calls=[{"functionName": "search_objects", "functionArguments": "{}", "callTs": 1, "durationMs": 10}], + text="Here is the draft.", + ) + partial.reasoning_steps = ["looked for the charts"] + partial.reasoning_step_count = 1 + client = MagicMock() + client.send_message.side_effect = ChatError("stream died mid-answer", partial_result=partial) + + summary = _run_with(client, _DC05_EXPECTED) + run = summary.run_results[0] + + assert run.exit_reason is LoopExit.CHAT_ERROR + assert run.reasoning_steps == ["looked for the charts"] + assert run.total_steps == 1 + assert [tc.function_name for tc in run.tool_call_events] == ["search_objects"] + + def test_a_chat_error_on_a_later_turn_keeps_the_earlier_ones(self): + """The whole point of recording it: turns already completed survive the fault.""" + client = MagicMock() + client.send_message.side_effect = [ + _chat_result(text="Which charts did you have in mind?"), + ChatError("gen-ai fell over"), + ] + + summary = _run_with(client, _DC05_EXPECTED) + run = summary.run_results[0] + + assert run.exit_reason is LoopExit.CHAT_ERROR + assert run.total_turns == 2 + class TestEvaluateEntryPoint: def test_a_failing_run_raises_with_the_failures_attached(self): From 84e33ecd1e6ed2159085b5f8e0421a57caf9b000 Mon Sep 17 00:00:00 2001 From: Peter Tomko Date: Mon, 12 Oct 2026 21:44:26 +0200 Subject: [PATCH 4/4] style(gooddata-eval): annotate the three ChatError tests AGENTS.md asks for a return annotation on every function; these three were added without one. 1735 passed, 1 skipped. Co-Authored-By: Claude Opus 5 --- .../gooddata-eval/tests/test_agentic_dashboard_skill.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/packages/gooddata-eval/tests/test_agentic_dashboard_skill.py b/packages/gooddata-eval/tests/test_agentic_dashboard_skill.py index ea04e07e8..c4cfb7e23 100644 --- a/packages/gooddata-eval/tests/test_agentic_dashboard_skill.py +++ b/packages/gooddata-eval/tests/test_agentic_dashboard_skill.py @@ -2362,7 +2362,7 @@ def test_a_caller_supplied_conversation_is_not_deleted(self): client.create_conversation.assert_not_called() client.delete_conversation.assert_not_called() - def test_a_chat_error_is_recorded_rather_than_left_to_escape(self): + def test_a_chat_error_is_recorded_rather_than_left_to_escape(self) -> None: """It used to escape run_agentic_dashboard_skill, taking every completed K-run with it: no DashboardRunResult, no exit_reason, just a bare error on the item. Recorded the way metric_skill.py and conversation.py record it, so an infrastructure fault @@ -2376,7 +2376,7 @@ def test_a_chat_error_is_recorded_rather_than_left_to_escape(self): assert summary.run_results[0].evaluation.strict_pass is False assert summary.pass_at_k is False - def test_a_chat_error_keeps_the_partial_turn_s_work(self): + def test_a_chat_error_keeps_the_partial_turn_s_work(self) -> None: """A bare catch would discard ChatError.partial_result. What the stream delivered before it died is still this turn's work -- the steps were taken and the tools ran.""" partial = _chat_result( @@ -2396,7 +2396,7 @@ def test_a_chat_error_keeps_the_partial_turn_s_work(self): assert run.total_steps == 1 assert [tc.function_name for tc in run.tool_call_events] == ["search_objects"] - def test_a_chat_error_on_a_later_turn_keeps_the_earlier_ones(self): + def test_a_chat_error_on_a_later_turn_keeps_the_earlier_ones(self) -> None: """The whole point of recording it: turns already completed survive the fault.""" client = MagicMock() client.send_message.side_effect = [