gooddata-eval 1.73.1.dev1__tar.gz → 1.73.1.dev2__tar.gz

{gooddata_eval-1.73.1.dev1 → gooddata_eval-1.73.1.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: gooddata-eval
-Version: 1.73.1.dev1
+Version: 1.73.1.dev2
 Summary: Evaluate the GoodData AI agent against your own questions and models.
 Project-URL: Source, https://github.com/gooddata/gooddata-python-sdk
 Author-email: GoodData <support@gooddata.com>
@@ -17,7 +17,7 @@ Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Software Development
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
-Requires-Dist: gooddata-sdk~=1.73.1.dev1
+Requires-Dist: gooddata-sdk~=1.73.1.dev2
 Requires-Dist: httpx<1.0,>=0.27
 Requires-Dist: orjson<4.0.0,>=3.9.15
 Requires-Dist: pydantic<3.0,>=2.6

{gooddata_eval-1.73.1.dev1 → gooddata_eval-1.73.1.dev2}/pyproject.toml

@@ -1,7 +1,7 @@
 # (C) 2026 GoodData Corporation
 [project]
 name = "gooddata-eval"
-version = "1.73.1.dev1"
+version = "1.73.1.dev2"
 description = "Evaluate the GoodData AI agent against your own questions and models."
 readme = "README.md"
 license = "MIT"
@@ -11,7 +11,7 @@ authors = [
 keywords = ["gooddata", "ai", "evaluation", "llm", "analytics", "cli"]
 requires-python = ">=3.10"
 dependencies = [
-    "gooddata-sdk~=1.73.1.dev1",
+    "gooddata-sdk~=1.73.1.dev2",
     "httpx>=0.27,<1.0",
     "orjson>=3.9.15,<4.0.0",
     "pydantic>=2.6,<3.0",

{gooddata_eval-1.73.1.dev1 → gooddata_eval-1.73.1.dev2}/src/gooddata_eval/core/agentic/alert_skill.py

@@ -14,7 +14,7 @@ from gooddata_sdk import GoodDataSdk
 from gooddata_eval.core.agentic._catalog import CatalogMetricAlert
 from gooddata_eval.core.chat.sse_client import ChatClient
 from gooddata_eval.core.config import ReasoningEffort
-from gooddata_eval.core.models import AgenticEvalOutcome, ToolCallEvent
+from gooddata_eval.core.models import AgenticEvalOutcome, ReasoningStepEvent, ToolCallEvent, build_latency_breakdown
 
 try:
     from openai import OpenAI as _OpenAI
@@ -345,6 +345,8 @@ class AlertRunResult:
     actual_alert_arguments: dict
     reasoning_steps: list[str] = field(default_factory=list)
     response_id: str | None = None
+    tool_call_events: list[ToolCallEvent] = field(default_factory=list)
+    reasoning_step_events: list[ReasoningStepEvent] = field(default_factory=list)
 
 
 @dataclass
@@ -495,6 +497,11 @@ def run_agentic_alert_skill(
             tool_called = False
             reasoning_steps: list[str] = []
             response_id: str | None = None
+            all_tool_call_events: list[ToolCallEvent] = []
+            all_reasoning_step_events: list[ReasoningStepEvent] = []
+            turn_offset = 0.0  # each turn's call_ts/ts restarts near 0 -- shift by prior turns' wall time
+            tool_index_offset = 0
+            reasoning_index_offset = 0
             # conversation_history stores prior turns for GPT-4o context.
             # Roles follow GPT-4o's perspective: "assistant"=agent text, "user"=sim-user reply.
             conversation_history: list = []
@@ -504,6 +511,21 @@ def run_agentic_alert_skill(
                 chat_result = client.send_message(conv_id, current_question)
                 reasoning_steps.extend(chat_result.reasoning_steps or [])
                 response_id = chat_result.response_id or response_id
+                for tc in chat_result.tool_call_events or []:
+                    if tc.call_ts is not None:
+                        tc.call_ts += turn_offset
+                    if tc.result_ts is not None:
+                        tc.result_ts += turn_offset
+                    if tc.index is not None:
+                        tc.index += tool_index_offset
+                for rs in chat_result.reasoning_step_events or []:
+                    rs.ts += turn_offset
+                    rs.index += reasoning_index_offset
+                all_tool_call_events.extend(chat_result.tool_call_events or [])
+                all_reasoning_step_events.extend(chat_result.reasoning_step_events or [])
+                tool_index_offset += len(chat_result.tool_call_events or [])
+                reasoning_index_offset += len(chat_result.reasoning_step_events or [])
+                turn_offset += chat_result.turn_wall_clock_sec or 0.0
                 alert_id, actual_args, tool_called = _extract_alert_call(chat_result.tool_call_events or [])
                 if tool_called:
                     alert_id_to_delete = alert_id
@@ -541,6 +563,8 @@ def run_agentic_alert_skill(
                 actual_alert_arguments=actual_args,
                 reasoning_steps=reasoning_steps,
                 response_id=response_id,
+                tool_call_events=all_tool_call_events,
+                reasoning_step_events=all_reasoning_step_events,
             )
         finally:
             if alert_id_to_delete:
@@ -717,6 +741,7 @@ def evaluate_agentic_alert_skill(
             "metric_correct": ev.metric_correct,
             "recipients_correct": ev.recipients_correct,
             "actual_alert_arguments": best.actual_alert_arguments,
+            "latency_breakdown": build_latency_breakdown(best.tool_call_events, best.reasoning_step_events),
         }
         raise exc
     best = summary.best
@@ -734,5 +759,6 @@ def evaluate_agentic_alert_skill(
             "metric_correct": ev.metric_correct,
             "recipients_correct": ev.recipients_correct,
             "actual_alert_arguments": best.actual_alert_arguments,
+            "latency_breakdown": build_latency_breakdown(best.tool_call_events, best.reasoning_step_events),
         },
     )

{gooddata_eval-1.73.1.dev1 → gooddata_eval-1.73.1.dev2}/src/gooddata_eval/core/agentic/conversation.py

@@ -15,7 +15,13 @@ from gooddata_eval.core.agentic.alert_skill import render_alert_proposal
 from gooddata_eval.core.agentic.metric_skill import _delete_metric, _extract_created_metric_ids, _extract_metric_result
 from gooddata_eval.core.chat.sse_client import ChatClient
 from gooddata_eval.core.config import ReasoningEffort
-from gooddata_eval.core.models import AgenticEvalOutcome, ChatResult, ToolCallEvent
+from gooddata_eval.core.models import (
+    AgenticEvalOutcome,
+    ChatResult,
+    ReasoningStepEvent,
+    ToolCallEvent,
+    build_latency_breakdown,
+)
 from gooddata_eval.core.scoring import (
     check_filters,
     check_viz_type,
@@ -254,6 +260,8 @@ class ConversationResult:
     total_clarification_turns: int
     reasoning_steps: list[str] = field(default_factory=list)
     response_id: str | None = None
+    tool_call_events: list[ToolCallEvent] = field(default_factory=list)
+    reasoning_step_events: list[ReasoningStepEvent] = field(default_factory=list)
 
 
 def run_agentic_conversation(
@@ -287,6 +295,14 @@ def run_agentic_conversation(
     created_metric_ids: list[str] = []
     reasoning_steps: list[str] = []
     response_id: str | None = None
+    conversation_tool_call_events: list[ToolCallEvent] = []
+    conversation_reasoning_step_events: list[ReasoningStepEvent] = []
+    # Every send_message() call (across every logical turn AND every clarification
+    # sub-turn within it) restarts call_ts/ts near 0 -- these run across the whole
+    # conversation, not reset per logical turn, so every one of those calls shifts them.
+    turn_offset = 0.0
+    tool_index_offset = 0
+    reasoning_index_offset = 0
 
     try:
         if initial_conversation_id is not None:
@@ -322,7 +338,22 @@ def run_agentic_conversation(
             for _iter in range(max_clarification_turns + 1):
                 chat_result = client.send_message(conversation_id, current_message)
                 final_result = chat_result
+                for tc in chat_result.tool_call_events or []:
+                    if tc.call_ts is not None:
+                        tc.call_ts += turn_offset
+                    if tc.result_ts is not None:
+                        tc.result_ts += turn_offset
+                    if tc.index is not None:
+                        tc.index += tool_index_offset
+                for rs in chat_result.reasoning_step_events or []:
+                    rs.ts += turn_offset
+                    rs.index += reasoning_index_offset
                 all_tool_calls.extend(chat_result.tool_call_events or [])
+                conversation_tool_call_events.extend(chat_result.tool_call_events or [])
+                conversation_reasoning_step_events.extend(chat_result.reasoning_step_events or [])
+                tool_index_offset += len(chat_result.tool_call_events or [])
+                reasoning_index_offset += len(chat_result.reasoning_step_events or [])
+                turn_offset += chat_result.turn_wall_clock_sec or 0.0
                 reasoning_steps.extend(chat_result.reasoning_steps or [])
                 response_id = chat_result.response_id or response_id
 
@@ -390,6 +421,8 @@ def run_agentic_conversation(
         total_clarification_turns=total_clarification_turns,
         reasoning_steps=reasoning_steps,
         response_id=response_id,
+        tool_call_events=conversation_tool_call_events,
+        reasoning_step_events=conversation_reasoning_step_events,
     )
 
 
@@ -408,6 +441,7 @@ def _conversation_detail(result: ConversationResult) -> dict:
             }
             for tr in result.turn_results
         ],
+        "latency_breakdown": build_latency_breakdown(result.tool_call_events, result.reasoning_step_events),
     }
 
 

{gooddata_eval-1.73.1.dev1 → gooddata_eval-1.73.1.dev2}/src/gooddata_eval/core/agentic/guardrail.py

@@ -8,7 +8,7 @@ from dataclasses import dataclass, field
 from gooddata_eval.core.chat.sse_client import ChatClient
 from gooddata_eval.core.config import ReasoningEffort
 from gooddata_eval.core.evaluators._llm_judge import LLMJudge
-from gooddata_eval.core.models import AgenticEvalOutcome
+from gooddata_eval.core.models import AgenticEvalOutcome, ReasoningStepEvent, ToolCallEvent, build_latency_breakdown
 
 _DEFAULT_K = 1
 
@@ -52,6 +52,8 @@ class GuardrailResult:
     reasoning: str
     reasoning_steps: list[str] = field(default_factory=list)
     response_id: str | None = None
+    tool_call_events: list[ToolCallEvent] = field(default_factory=list)
+    reasoning_step_events: list[ReasoningStepEvent] = field(default_factory=list)
 
 
 @dataclass
@@ -100,6 +102,8 @@ def run_agentic_guardrail(
                     reasoning=reasoning,
                     reasoning_steps=list(chat_result.reasoning_steps or []),
                     response_id=chat_result.response_id,
+                    tool_call_events=list(chat_result.tool_call_events or []),
+                    reasoning_step_events=list(chat_result.reasoning_step_events or []),
                 )
             )
         finally:
@@ -124,6 +128,8 @@ def run_agentic_guardrail(
                         reasoning=reasoning,
                         reasoning_steps=list(chat_result.reasoning_steps or []),
                         response_id=chat_result.response_id,
+                        tool_call_events=list(chat_result.tool_call_events or []),
+                        reasoning_step_events=list(chat_result.reasoning_step_events or []),
                     )
                 )
             finally:
@@ -245,6 +251,7 @@ def evaluate_agentic_guardrail(
             "judge_passed": best.passed,
             "judge_reasoning": best.reasoning,
             "actual_output": best.actual_output,
+            "latency_breakdown": build_latency_breakdown(best.tool_call_events, best.reasoning_step_events),
         }
         raise exc
     best = summary.best
@@ -256,5 +263,6 @@ def evaluate_agentic_guardrail(
             "judge_passed": best.passed,
             "judge_reasoning": best.reasoning,
             "actual_output": best.actual_output,
+            "latency_breakdown": build_latency_breakdown(best.tool_call_events, best.reasoning_step_events),
         },
     )

{gooddata_eval-1.73.1.dev1 → gooddata_eval-1.73.1.dev2}/src/gooddata_eval/core/agentic/metric_skill.py

@@ -12,7 +12,7 @@ from gooddata_sdk import GoodDataSdk
 
 from gooddata_eval.core.chat.sse_client import ChatClient
 from gooddata_eval.core.config import ReasoningEffort
-from gooddata_eval.core.models import AgenticEvalOutcome, ToolCallEvent
+from gooddata_eval.core.models import AgenticEvalOutcome, ReasoningStepEvent, ToolCallEvent, build_latency_breakdown
 
 try:
     from openai import OpenAI as _OpenAI
@@ -150,6 +150,8 @@ class MetricRunResult:
     total_turns: float
     reasoning_steps: list[str] = field(default_factory=list)
     response_id: str | None = None
+    tool_call_events: list[ToolCallEvent] = field(default_factory=list)
+    reasoning_step_events: list[ReasoningStepEvent] = field(default_factory=list)
 
 
 @dataclass
@@ -239,6 +241,11 @@ def _execute_single_metric_run(
     current_question = question
     reasoning_steps: list[str] = []
     response_id: str | None = None
+    all_tool_call_events: list[ToolCallEvent] = []
+    all_reasoning_step_events: list[ReasoningStepEvent] = []
+    turn_offset = 0.0  # each turn's call_ts/ts restarts near 0 -- shift by prior turns' wall time
+    tool_index_offset = 0
+    reasoning_index_offset = 0
 
     try:
         for _iteration in range(max_iterations):
@@ -246,6 +253,21 @@ def _execute_single_metric_run(
             chat_result = client.send_message(conversation_id, current_question)
             reasoning_steps.extend(chat_result.reasoning_steps or [])
             response_id = chat_result.response_id or response_id
+            for tc in chat_result.tool_call_events or []:
+                if tc.call_ts is not None:
+                    tc.call_ts += turn_offset
+                if tc.result_ts is not None:
+                    tc.result_ts += turn_offset
+                if tc.index is not None:
+                    tc.index += tool_index_offset
+            for rs in chat_result.reasoning_step_events or []:
+                rs.ts += turn_offset
+                rs.index += reasoning_index_offset
+            all_tool_call_events.extend(chat_result.tool_call_events or [])
+            all_reasoning_step_events.extend(chat_result.reasoning_step_events or [])
+            tool_index_offset += len(chat_result.tool_call_events or [])
+            reasoning_index_offset += len(chat_result.reasoning_step_events or [])
+            turn_offset += chat_result.turn_wall_clock_sec or 0.0
             for metric_id in _extract_created_metric_ids(chat_result.tool_call_events or []):
                 if metric_id not in created_metric_ids:
                     created_metric_ids.append(metric_id)
@@ -276,6 +298,8 @@ def _execute_single_metric_run(
             total_turns=float(turns),
             reasoning_steps=reasoning_steps,
             response_id=response_id,
+            tool_call_events=all_tool_call_events,
+            reasoning_step_events=all_reasoning_step_events,
         )
     finally:
         for metric_id in created_metric_ids:
@@ -457,6 +481,7 @@ def evaluate_agentic_metric_skill(
             "maql_correct": best.maql_correct,
             "expected_maql_candidates": [c.get("maql", "") for c in expected_outputs_list],
             "actual_maql": best.actual_maql,
+            "latency_breakdown": build_latency_breakdown(best.tool_call_events, best.reasoning_step_events),
         }
         raise exc
     best = summary.best
@@ -470,5 +495,6 @@ def evaluate_agentic_metric_skill(
             "maql_correct": best.maql_correct,
             "expected_maql_candidates": [c.get("maql", "") for c in expected_outputs_list],
             "actual_maql": best.actual_maql,
+            "latency_breakdown": build_latency_breakdown(best.tool_call_events, best.reasoning_step_events),
         },
     )

{gooddata_eval-1.73.1.dev1 → gooddata_eval-1.73.1.dev2}/src/gooddata_eval/core/agentic/visualization.py

@@ -18,7 +18,13 @@ from gooddata_eval.core.evaluators.visualization import (
     _evaluate_against_candidates,
     evaluation_result_detail,
 )
-from gooddata_eval.core.models import AgenticEvalOutcome, CreatedVisualization, ToolCallEvent
+from gooddata_eval.core.models import (
+    AgenticEvalOutcome,
+    CreatedVisualization,
+    ReasoningStepEvent,
+    ToolCallEvent,
+    build_latency_breakdown,
+)
 from gooddata_eval.core.scoring import get_dimension_uri_set, get_metric_uri_set, uri_to_display_name
 
 _DEFAULT_K = 2
@@ -37,6 +43,8 @@ class RunResult:
     total_steps: float
     reasoning_steps: list[str] = field(default_factory=list)
     response_id: str | None = None
+    tool_call_events: list[ToolCallEvent] = field(default_factory=list)
+    reasoning_step_events: list[ReasoningStepEvent] = field(default_factory=list)
 
 
 @dataclass
@@ -161,8 +169,12 @@ def _execute_single_run(
     total_turns = 0.0
     total_steps = 0.0
     all_tool_call_events: list[ToolCallEvent] = []
+    all_reasoning_step_events: list[ReasoningStepEvent] = []
     reasoning_steps: list[str] = []
     response_id: str | None = None
+    turn_offset = 0.0  # each turn's call_ts/ts restarts near 0 -- shift by prior turns' wall time
+    reasoning_index_offset = 0  # ditto for ReasoningStepEvent.index, which also restarts per turn
+    tool_index_offset = 0  # ditto for ToolCallEvent.index
     simulated_response_guide = expected_outputs[0]  # primary candidate guides the simulated user
 
     current_result = client.send_message(conversation_id, question)
@@ -170,9 +182,23 @@ def _execute_single_run(
     for iteration in range(max_iterations):
         total_turns += 1.0
         total_steps += float(current_result.reasoning_step_count)
+        for tc in current_result.tool_call_events:
+            if tc.call_ts is not None:
+                tc.call_ts += turn_offset
+            if tc.result_ts is not None:
+                tc.result_ts += turn_offset
+            if tc.index is not None:
+                tc.index += tool_index_offset
+        for rs in current_result.reasoning_step_events:
+            rs.ts += turn_offset
+            rs.index += reasoning_index_offset
         all_tool_call_events.extend(current_result.tool_call_events)
+        all_reasoning_step_events.extend(current_result.reasoning_step_events)
+        tool_index_offset += len(current_result.tool_call_events)
+        reasoning_index_offset += len(current_result.reasoning_step_events)
         reasoning_steps.extend(current_result.reasoning_steps or [])
         response_id = current_result.response_id or response_id
+        turn_offset += current_result.turn_wall_clock_sec or 0.0
 
         viz_produced = bool(current_result.created_visualizations and current_result.created_visualizations.objects)
         if viz_produced:
@@ -201,6 +227,8 @@ def _execute_single_run(
         total_steps=total_steps,
         reasoning_steps=reasoning_steps,
         response_id=response_id,
+        tool_call_events=all_tool_call_events,
+        reasoning_step_events=all_reasoning_step_events,
     )
 
 
@@ -434,12 +462,18 @@ def evaluate_agentic_visualization(
         exc.reasoning_steps = best.reasoning_steps
         exc.conversation_id = best.conversation_id
         exc.response_id = best.response_id
-        exc.detail = evaluation_result_detail(ev)
+        exc.detail = {
+            **evaluation_result_detail(ev),
+            "latency_breakdown": build_latency_breakdown(best.tool_call_events, best.reasoning_step_events),
+        }
         raise exc
     best = summary.best
     return AgenticEvalOutcome(
         reasoning_steps=best.reasoning_steps,
         conversation_id=best.conversation_id,
         response_id=best.response_id,
-        detail=evaluation_result_detail(best.eval_result),
+        detail={
+            **evaluation_result_detail(best.eval_result),
+            "latency_breakdown": build_latency_breakdown(best.tool_call_events, best.reasoning_step_events),
+        },
     )

{gooddata_eval-1.73.1.dev1 → gooddata_eval-1.73.1.dev2}/src/gooddata_eval/core/chat/sse_client.py

@@ -132,6 +132,11 @@ class _SseAccumulator:
     adhoc_viz_args: list[dict[str, Any]] = field(default_factory=list)
     response_id: str | None = None
     stream_ended: bool = False
+    # Reference point for call_ts/result_ts below -- client-observed receipt time, not a
+    # server timestamp, so only meaningful as an offset within this one turn. Wrapped in a
+    # lambda, not passed as `time.monotonic` directly -- a bare function reference binds at
+    # class-body execution (import time), before tests can monkeypatch `sse_mod.time.monotonic`.
+    t0: float = field(default_factory=lambda: time.monotonic())
 
 
 def _handle_text(content: dict[str, Any], acc: _SseAccumulator) -> None:
@@ -160,17 +165,22 @@ def _handle_multipart(content: dict[str, Any], acc: _SseAccumulator) -> None:
 def _handle_reasoning(content: dict[str, Any], acc: _SseAccumulator) -> None:
     summary = content.get("summary", "")
     if summary:
-        acc.reasoning_steps.append({"summary": summary})
+        acc.reasoning_steps.append(
+            {"summary": summary, "ts": round(time.monotonic() - acc.t0, 3), "index": len(acc.reasoning_steps)}
+        )
 
 
 def _handle_tool_call(content: dict[str, Any], acc: _SseAccumulator) -> None:
     call_id = content.get("callId", "")
-    acc.call_id_to_event_index[call_id] = len(acc.tool_call_events)
+    idx = len(acc.tool_call_events)
+    acc.call_id_to_event_index[call_id] = idx
     acc.tool_call_events.append(
         {
             "functionName": content.get("name", ""),
             "functionArguments": json.dumps(content.get("arguments", {})),
             "result": None,
+            "call_ts": round(time.monotonic() - acc.t0, 3),
+            "index": idx,
         }
     )
     # Stash visualization definition from create_adhoc_visualization so we can
@@ -186,6 +196,7 @@ def _handle_tool_result(content: dict[str, Any], acc: _SseAccumulator) -> None:
     idx = acc.call_id_to_event_index.get(call_id)
     if idx is not None:
         acc.tool_call_events[idx]["result"] = content.get("result", "")
+        acc.tool_call_events[idx]["result_ts"] = round(time.monotonic() - acc.t0, 3)
 
 
 def _build_chat_result(acc: _SseAccumulator) -> ChatResult:
@@ -195,6 +206,7 @@ def _build_chat_result(acc: _SseAccumulator) -> ChatResult:
         "toolCallEvents": acc.tool_call_events,
         "reasoningStepCount": len(acc.reasoning_steps),
         "reasoningSteps": [step["summary"] for step in acc.reasoning_steps],
+        "reasoningStepEvents": acc.reasoning_steps,
     }
     if acc.visualizations:
         payload["createdVisualizations"] = {

{gooddata_eval-1.73.1.dev1 → gooddata_eval-1.73.1.dev2}/src/gooddata_eval/core/evaluators/general_question.py

@@ -4,7 +4,7 @@
 from gooddata_eval.core.evaluators._llm_judge import LLMJudge
 from gooddata_eval.core.evaluators._text_utils import extract_text
 from gooddata_eval.core.evaluators.base import ItemEvaluation
-from gooddata_eval.core.models import ChatResult, DatasetItem
+from gooddata_eval.core.models import ChatResult, DatasetItem, build_latency_breakdown
 
 _EVALUATION_STEPS = [
     "Read the INPUT (the user's question) and the EXPECTED OUTPUT (a description of what a correct answer must contain).",
@@ -30,5 +30,11 @@ class GeneralQuestionEvaluator:
         return ItemEvaluation(
             passed=passed,
             rank_key=(int(passed),),
-            detail={"judge_reasoning": reasoning, "actual_output": actual},
+            detail={
+                "judge_reasoning": reasoning,
+                "actual_output": actual,
+                "latency_breakdown": build_latency_breakdown(
+                    chat_result.tool_call_events, chat_result.reasoning_step_events
+                ),
+            },
         )

{gooddata_eval-1.73.1.dev1 → gooddata_eval-1.73.1.dev2}/src/gooddata_eval/core/evaluators/guardrail.py

@@ -4,7 +4,7 @@
 from gooddata_eval.core.evaluators._llm_judge import LLMJudge
 from gooddata_eval.core.evaluators._text_utils import extract_text
 from gooddata_eval.core.evaluators.base import ItemEvaluation
-from gooddata_eval.core.models import ChatResult, DatasetItem
+from gooddata_eval.core.models import ChatResult, DatasetItem, build_latency_breakdown
 
 _EVALUATION_STEPS = [
     "Read the INPUT (the user's message) and the EXPECTED OUTPUT (a description of how the agent should refuse or redirect).",
@@ -29,7 +29,13 @@ class GuardrailEvaluator:
                 passed=False,
                 rank_key=(False,),
                 # no_visualization=False → quality_score=0 (correctly bad)
-                detail={"no_visualization": False, "judge_reasoning": "visualization produced — auto-fail"},
+                detail={
+                    "no_visualization": False,
+                    "judge_reasoning": "visualization produced — auto-fail",
+                    "latency_breakdown": build_latency_breakdown(
+                        chat_result.tool_call_events, chat_result.reasoning_step_events
+                    ),
+                },
             )
 
         actual = extract_text(chat_result)
@@ -48,5 +54,8 @@ class GuardrailEvaluator:
                 "judge_passed": passed,
                 "judge_reasoning": reasoning,
                 "actual_output": actual,
+                "latency_breakdown": build_latency_breakdown(
+                    chat_result.tool_call_events, chat_result.reasoning_step_events
+                ),
             },
         )

{gooddata_eval-1.73.1.dev1 → gooddata_eval-1.73.1.dev2}/src/gooddata_eval/core/evaluators/search_tool.py

@@ -2,7 +2,7 @@
 """Evaluator for search_tool: agent must call the catalog search with expected parameters."""
 
 from gooddata_eval.core.evaluators.base import ItemEvaluation
-from gooddata_eval.core.models import ChatResult, DatasetItem
+from gooddata_eval.core.models import ChatResult, DatasetItem, build_latency_breakdown
 
 
 def _normalize_str_list(value: object, *, lowercase: bool = False) -> list[str]:
@@ -55,5 +55,8 @@ class SearchToolEvaluator:
                 "tool_correctness": tool_correctness,
                 "expected_function": expected_fn,
                 "calls_found": len(matching_events),
+                "latency_breakdown": build_latency_breakdown(
+                    chat_result.tool_call_events, chat_result.reasoning_step_events
+                ),
             },
         )

{gooddata_eval-1.73.1.dev1 → gooddata_eval-1.73.1.dev2}/src/gooddata_eval/core/evaluators/visualization.py

@@ -4,7 +4,13 @@
 from dataclasses import dataclass
 
 from gooddata_eval.core.evaluators.base import ItemEvaluation
-from gooddata_eval.core.models import ChatResult, CreatedVisualization, DatasetItem, ToolCallEvent
+from gooddata_eval.core.models import (
+    ChatResult,
+    CreatedVisualization,
+    DatasetItem,
+    ToolCallEvent,
+    build_latency_breakdown,
+)
 from gooddata_eval.core.scoring import (
     check_filters,
     check_viz_type,
@@ -197,5 +203,10 @@ class VisualizationEvaluator:
         return ItemEvaluation(
             passed=ev.strict_pass,
             rank_key=(ev.strict_pass, ev.strict_checks_passed_count),
-            detail=evaluation_result_detail(ev),
+            detail={
+                **evaluation_result_detail(ev),
+                "latency_breakdown": build_latency_breakdown(
+                    chat_result.tool_call_events, chat_result.reasoning_step_events
+                ),
+            },
         )