gooddata-eval 1.73.0__tar.gz → 1.73.1.dev1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: gooddata-eval
-Version: 1.73.0
+Version: 1.73.1.dev1
 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.0
+Requires-Dist: gooddata-sdk~=1.73.1.dev1
 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.0 → gooddata_eval-1.73.1.dev1}/pyproject.toml

@@ -1,7 +1,7 @@
 # (C) 2026 GoodData Corporation
 [project]
 name = "gooddata-eval"
-version = "1.73.0"
+version = "1.73.1.dev1"
 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.0",
+    "gooddata-sdk~=1.73.1.dev1",
     "httpx>=0.27,<1.0",
     "orjson>=3.9.15,<4.0.0",
     "pydantic>=2.6,<3.0",

{gooddata_eval-1.73.0 → gooddata_eval-1.73.1.dev1}/src/gooddata_eval/cli/agentic_runner.py

@@ -86,12 +86,12 @@ def _dispatch_agentic(
     model_version_override: str | None,
     reasoning_effort: ReasoningEffort | None = None,
     agent_id: str | None = None,
-) -> AgenticEvalOutcome | list[str] | None:
+) -> AgenticEvalOutcome:
     """Call the appropriate evaluate_agentic_* function for the item's test_kind.
 
-    Returns whatever that function returns -- alert_skill/metric_skill/conversation return
-    an AgenticEvalOutcome; the rest still return None
-    (unchanged).
+    Every evaluate_agentic_* function returns an AgenticEvalOutcome (reasoning_steps,
+    conversation_id, response_id, detail) on success and attaches the same four attributes
+    to its raised *AssertionError on failure -- no kind is exempt.
     """
     kind = item.test_kind
     eo = item.expected_output
@@ -174,13 +174,14 @@ def _dispatch_agentic(
             **lf_kw,
         )
     elif kind == "agentic_kda_skill":
-        evaluate_agentic_kda_skill(
+        return evaluate_agentic_kda_skill(
             host=host,
             token=token,
             workspace_id=workspace_id,
             question=item.question,
             expected_output=eo if isinstance(eo, dict) else {},
             k=k,
+            agent_id=agent_id,
             **lf_kw,
         )
     elif kind == "agentic_conversation":
@@ -240,19 +241,22 @@ def run_agentic_items(
                 reasoning_steps = outcome.reasoning_steps
                 conversation_id = outcome.conversation_id
                 response_id = outcome.response_id
+                detail = outcome.detail
             else:
-                reasoning_steps, conversation_id, response_id = outcome, None, None
+                reasoning_steps, conversation_id, response_id, detail = outcome, None, None, {}
             item_report.pass_at_k = True
             item_report.runs = k
             item_report.reasoning_steps = reasoning_steps or []
             item_report.conversation_id = conversation_id
             item_report.response_id = response_id
+            item_report.best_detail = detail or {}
         except AssertionError as exc:
             item_report.pass_at_k = False
             item_report.runs = k
             item_report.reasoning_steps = getattr(exc, "reasoning_steps", None) or []
             item_report.conversation_id = getattr(exc, "conversation_id", None)
             item_report.response_id = getattr(exc, "response_id", None)
+            item_report.best_detail = getattr(exc, "detail", None) or {}
             print(f"[agentic] {item.id} FAIL: {exc}", flush=True)
         except Exception as exc:
             item_report.error = f"{type(exc).__name__}: {exc}"

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

@@ -160,8 +160,18 @@ def _check_recipients(expected: CatalogMetricAlert, actual_args: dict, sdk: Good
         act_recip = []
     if set(expected.recipients) == set(act_recip or []):
         return True
-    act_internal = actual_args.get("internal_recipients")
-    if sdk is not None and isinstance(act_internal, list) and act_internal:
+    act_internal_raw = actual_args.get("internal_recipients")
+    # internal_recipients is declared `anyOf: [array of string, string, null]` in the
+    # create_metric_alert tool schema -- a single id as a bare string is schema-legal,
+    # not a malformed call, so it needs the same string/list normalization already
+    # applied to recipients/external_recipients above.
+    if isinstance(act_internal_raw, str):
+        act_internal = [act_internal_raw]
+    elif isinstance(act_internal_raw, list):
+        act_internal = act_internal_raw
+    else:
+        act_internal = []
+    if sdk is not None and act_internal:
         internal_recipient_ids = _resolve_internal_recipient_ids(sdk, expected.recipients)
         if internal_recipient_ids & set(act_internal):
             return True
@@ -584,6 +594,7 @@ class AlertSkillAssertionError(AssertionError):
     reasoning_steps: list[str]
     conversation_id: str
     response_id: str | None
+    detail: dict
 
 
 def evaluate_agentic_alert_skill(
@@ -697,9 +708,31 @@ def evaluate_agentic_alert_skill(
         exc.reasoning_steps = best.reasoning_steps
         exc.conversation_id = best.conversation_id
         exc.response_id = best.response_id
+        exc.detail = {
+            "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,
+            "actual_alert_arguments": best.actual_alert_arguments,
+        }
         raise exc
+    best = summary.best
+    ev = best.eval
     return AgenticEvalOutcome(
-        reasoning_steps=summary.best.reasoning_steps,
-        conversation_id=summary.best.conversation_id,
-        response_id=summary.best.response_id,
+        reasoning_steps=best.reasoning_steps,
+        conversation_id=best.conversation_id,
+        response_id=best.response_id,
+        detail={
+            "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,
+            "actual_alert_arguments": best.actual_alert_arguments,
+        },
     )

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

@@ -12,7 +12,7 @@ from gooddata_sdk import GoodDataSdk
 from pydantic import BaseModel
 
 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
+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
@@ -120,7 +120,7 @@ def _check_output_present(turn: TurnDefinition, chat_result: ChatResult) -> bool
             and getattr(chat_result.created_visualizations, "objects", chat_result.created_visualizations)
         )
     if otype == "metric":
-        return any(tc.function_name == "create_metric" for tc in (chat_result.tool_call_events or []))
+        return _extract_metric_result(chat_result.tool_call_events or []) is not None
     if otype == "tool_call":
         expected_tool = turn.expected_tool_name
         if not expected_tool:
@@ -129,19 +129,6 @@ def _check_output_present(turn: TurnDefinition, chat_result: ChatResult) -> bool
     return False
 
 
-def _extract_metric_from_turn(tool_call_events: list[ToolCallEvent]) -> dict | None:
-    """Extract the result payload from the create_metric tool call, if present."""
-    for tc in tool_call_events:
-        if tc.function_name != "create_metric":
-            continue
-        if not tc.result:
-            continue
-        result_data = tc.parsed_result()
-        if result_data is not None:
-            return result_data.get("data", result_data)
-    return None
-
-
 def _check_output_correct(turn: TurnDefinition, chat_result: ChatResult) -> bool | None:
     """Check output correctness against expected_output when defined.
 
@@ -186,7 +173,7 @@ def _check_output_correct(turn: TurnDefinition, chat_result: ChatResult) -> bool
         return all(results) if results else None
 
     if otype == "metric":
-        metric_result = _extract_metric_from_turn(chat_result.tool_call_events or [])
+        metric_result = _extract_metric_result(chat_result.tool_call_events or [])
         if not metric_result:
             return False
         return _normalize_maql(metric_result.get("maql", "")) == _normalize_maql(expected.get("maql", ""))
@@ -362,7 +349,7 @@ def run_agentic_conversation(
 
             # Capture metric output for $ref resolution in subsequent turns.
             if final_result and turn.expected_output_type == "metric":
-                metric_data = _extract_metric_from_turn(all_tool_calls)
+                metric_data = _extract_metric_result(all_tool_calls)
                 if metric_data:
                     turn_outputs[turn.turn_id] = metric_data
 
@@ -406,6 +393,24 @@ def run_agentic_conversation(
     )
 
 
+def _conversation_detail(result: ConversationResult) -> dict:
+    return {
+        "full_skill_coverage": result.full_skill_coverage,
+        "total_clarification_turns": result.total_clarification_turns,
+        "turns": [
+            {
+                "turn_id": tr.turn_id,
+                "expected_skill": tr.expected_skill,
+                "skill_routing": tr.skill_routing,
+                "output_present": tr.output_present,
+                "output_correct": tr.output_correct,
+                "activated_skills": tr.activated_skills,
+            }
+            for tr in result.turn_results
+        ],
+    }
+
+
 class ConversationAssertionError(AssertionError):
     """Raised when a conversation evaluation fails."""
 
@@ -413,6 +418,7 @@ class ConversationAssertionError(AssertionError):
     reasoning_steps: list[str]
     conversation_id: str
     response_id: str | None
+    detail: dict
 
 
 def evaluate_agentic_conversation(
@@ -524,9 +530,11 @@ def evaluate_agentic_conversation(
         exc.reasoning_steps = result.reasoning_steps
         exc.conversation_id = result.conversation_id
         exc.response_id = result.response_id
+        exc.detail = _conversation_detail(result)
         raise exc
     return AgenticEvalOutcome(
         reasoning_steps=result.reasoning_steps,
         conversation_id=result.conversation_id,
         response_id=result.response_id,
+        detail=_conversation_detail(result),
     )

{gooddata_eval-1.73.0 → gooddata_eval-1.73.1.dev1}/src/gooddata_eval/core/agentic/general_question.py

@@ -3,11 +3,12 @@
 
 from __future__ import annotations
 
-from dataclasses import dataclass
+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
 
 _DEFAULT_K = 1
 
@@ -52,6 +53,8 @@ class GeneralQuestionResult:
     passed: bool
     llm_judge_score: float
     reasoning: str
+    reasoning_steps: list[str] = field(default_factory=list)
+    response_id: str | None = None
 
 
 @dataclass
@@ -98,6 +101,8 @@ def run_agentic_general_question(
                     passed=passed,
                     llm_judge_score=llm_judge_score,
                     reasoning=reasoning,
+                    reasoning_steps=list(chat_result.reasoning_steps or []),
+                    response_id=chat_result.response_id,
                 )
             )
         finally:
@@ -120,6 +125,8 @@ def run_agentic_general_question(
                         passed=passed,
                         llm_judge_score=llm_judge_score,
                         reasoning=reasoning,
+                        reasoning_steps=list(chat_result.reasoning_steps or []),
+                        response_id=chat_result.response_id,
                     )
                 )
             finally:
@@ -142,6 +149,10 @@ class GeneralQuestionAssertionError(AssertionError):
     """Raised when a general-question evaluation fails."""
 
     __tracebackhide__ = True
+    reasoning_steps: list[str]
+    conversation_id: str
+    response_id: str | None
+    detail: dict
 
 
 def evaluate_agentic_general_question(
@@ -160,8 +171,13 @@ def evaluate_agentic_general_question(
     model_version_override: str | None = None,
     run_metadata_extra: dict | None = None,
     reasoning_effort: ReasoningEffort | None = None,
-) -> None:
-    """Run general-question evaluation, log to Langfuse, and raise on failure."""
+) -> AgenticEvalOutcome:
+    """Run general-question evaluation, log to Langfuse, and raise GeneralQuestionAssertionError on failure.
+
+    Returns the best run's outcome (reasoning_steps, conversation_id, response_id) as an
+    AgenticEvalOutcome on success; on failure the same three values are attached to the
+    raised exception as ``.reasoning_steps``/``.conversation_id``/``.response_id``.
+    """
     from datetime import datetime as _dt  # noqa: PLC0415
     from datetime import timezone as _tz  # noqa: PLC0415
 
@@ -223,6 +239,26 @@ def evaluate_agentic_general_question(
 
     if not summary.pass_at_k:
         best = summary.best
-        raise GeneralQuestionAssertionError(
+        exc = GeneralQuestionAssertionError(
             f"General question assertion failed. passed={best.passed}. Reasoning: {best.reasoning}"
         )
+        exc.reasoning_steps = best.reasoning_steps
+        exc.conversation_id = best.conversation_id
+        exc.response_id = best.response_id
+        exc.detail = {
+            "judge_passed": best.passed,
+            "judge_reasoning": best.reasoning,
+            "actual_output": best.actual_output,
+        }
+        raise exc
+    best = summary.best
+    return AgenticEvalOutcome(
+        reasoning_steps=best.reasoning_steps,
+        conversation_id=best.conversation_id,
+        response_id=best.response_id,
+        detail={
+            "judge_passed": best.passed,
+            "judge_reasoning": best.reasoning,
+            "actual_output": best.actual_output,
+        },
+    )

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

@@ -3,11 +3,12 @@
 
 from __future__ import annotations
 
-from dataclasses import dataclass
+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
 
 _DEFAULT_K = 1
 
@@ -49,6 +50,8 @@ class GuardrailResult:
     passed: bool
     llm_judge_score: float
     reasoning: str
+    reasoning_steps: list[str] = field(default_factory=list)
+    response_id: str | None = None
 
 
 @dataclass
@@ -95,6 +98,8 @@ def run_agentic_guardrail(
                     passed=passed,
                     llm_judge_score=llm_judge_score,
                     reasoning=reasoning,
+                    reasoning_steps=list(chat_result.reasoning_steps or []),
+                    response_id=chat_result.response_id,
                 )
             )
         finally:
@@ -117,6 +122,8 @@ def run_agentic_guardrail(
                         passed=passed,
                         llm_judge_score=llm_judge_score,
                         reasoning=reasoning,
+                        reasoning_steps=list(chat_result.reasoning_steps or []),
+                        response_id=chat_result.response_id,
                     )
                 )
             finally:
@@ -139,6 +146,10 @@ class GuardrailAssertionError(AssertionError):
     """Raised when a guardrail evaluation fails."""
 
     __tracebackhide__ = True
+    reasoning_steps: list[str]
+    conversation_id: str
+    response_id: str | None
+    detail: dict
 
 
 def evaluate_agentic_guardrail(
@@ -157,8 +168,14 @@ def evaluate_agentic_guardrail(
     model_version_override: str | None = None,
     run_metadata_extra: dict | None = None,
     reasoning_effort: ReasoningEffort | None = None,
-) -> None:
-    """Run guardrail evaluation, log to Langfuse, and raise on failure."""
+) -> AgenticEvalOutcome:
+    """Run guardrail evaluation, log to Langfuse, and raise GuardrailAssertionError on failure.
+
+    Returns the best run's outcome (reasoning_steps, conversation_id, response_id) as an
+    AgenticEvalOutcome on success; on failure the same three values are attached to the
+    raised exception as ``.reasoning_steps``/``.conversation_id``/``.response_id`` (mirrors
+    `evaluate_agentic_metric_skill`'s idiom) so callers can retrieve them either way.
+    """
     from datetime import datetime as _dt  # noqa: PLC0415
     from datetime import timezone as _tz  # noqa: PLC0415
 
@@ -220,4 +237,24 @@ def evaluate_agentic_guardrail(
 
     if not summary.pass_at_k:
         best = summary.best
-        raise GuardrailAssertionError(f"Guardrail assertion failed. passed={best.passed}. Reasoning: {best.reasoning}")
+        exc = GuardrailAssertionError(f"Guardrail assertion failed. passed={best.passed}. Reasoning: {best.reasoning}")
+        exc.reasoning_steps = best.reasoning_steps
+        exc.conversation_id = best.conversation_id
+        exc.response_id = best.response_id
+        exc.detail = {
+            "judge_passed": best.passed,
+            "judge_reasoning": best.reasoning,
+            "actual_output": best.actual_output,
+        }
+        raise exc
+    best = summary.best
+    return AgenticEvalOutcome(
+        reasoning_steps=best.reasoning_steps,
+        conversation_id=best.conversation_id,
+        response_id=best.response_id,
+        detail={
+            "judge_passed": best.passed,
+            "judge_reasoning": best.reasoning,
+            "actual_output": best.actual_output,
+        },
+    )

{gooddata_eval-1.73.0 → gooddata_eval-1.73.1.dev1}/src/gooddata_eval/core/agentic/kda_skill.py

@@ -5,11 +5,11 @@ from __future__ import annotations
 
 import logging
 import os
-from dataclasses import dataclass
+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.models import ToolCallEvent
+from gooddata_eval.core.models import AgenticEvalOutcome, ToolCallEvent
 
 _log = logging.getLogger(__name__)
 
@@ -159,6 +159,8 @@ class KdaRunResult:
     # Wall-clock time of the turn that called create (None if create never happened) --
     # not any earlier disambiguation turn. See run_agentic_kda_skill's _run_once.
     turn_wall_clock_sec: float | None = None
+    reasoning_steps: list[str] = field(default_factory=list)
+    response_id: str | None = None
 
 
 @dataclass
@@ -199,6 +201,7 @@ def run_agentic_kda_skill(
     max_iterations: int = _DEFAULT_MAX_ITERATIONS,
     initial_conversation_id: str | None = None,
     reasoning_effort: ReasoningEffort | None = None,
+    agent_id: str | None = None,
 ) -> AgenticKdaSummary:
     """Run the KDA-skill agentic evaluation K times and return a summary.
 
@@ -215,7 +218,9 @@ def run_agentic_kda_skill(
         # k=0 or negative would otherwise silently run once, indistinguishable from k=1.
         raise ValueError(f"k must be >= 1, got {k}")
     run_results: list[KdaRunResult] = []
-    client = ChatClient(host=host, token=token, workspace_id=workspace_id, reasoning_effort=reasoning_effort)
+    client = ChatClient(
+        host=host, token=token, workspace_id=workspace_id, reasoning_effort=reasoning_effort, agent_id=agent_id
+    )
 
     def _run_once(conv_id: str) -> KdaRunResult:
         create_args: dict | None = None
@@ -224,6 +229,8 @@ def run_agentic_kda_skill(
         turn_completed = False
         disambiguated = False
         current_question = question
+        reasoning_steps: list[str] = []
+        response_id: str | None = None
 
         for iteration in range(max_iterations):
             try:
@@ -232,11 +239,15 @@ def run_agentic_kda_skill(
                 _log.warning("KDA send_message failed for conversation %s: %s", conv_id, exc)
                 partial = getattr(exc, "partial_result", None)
                 if partial is not None:
+                    reasoning_steps.extend(partial.reasoning_steps or [])
+                    response_id = partial.response_id or response_id
                     create_args, execute_result = _extract_kda_calls(partial.tool_call_events or [])
                     if create_args is not None:
                         turn_wall_clock_sec = partial.turn_wall_clock_sec
                 turn_completed = False
                 break
+            reasoning_steps.extend(chat_result.reasoning_steps or [])
+            response_id = chat_result.response_id or response_id
             create_args, execute_result = _extract_kda_calls(chat_result.tool_call_events or [])
             response_text = (chat_result.text_response or "").strip()
             turn_completed = chat_result.stream_ended and bool(response_text)
@@ -273,6 +284,8 @@ def run_agentic_kda_skill(
             actual_create_args=create_args,
             actual_execute_result=execute_result,
             turn_wall_clock_sec=turn_wall_clock_sec,
+            reasoning_steps=reasoning_steps,
+            response_id=response_id,
         )
 
     try:
@@ -312,6 +325,10 @@ class KdaSkillAssertionError(AssertionError):
     """Raised when a KDA-skill evaluation fails."""
 
     __tracebackhide__ = True
+    reasoning_steps: list[str]
+    conversation_id: str
+    response_id: str | None
+    detail: dict
 
 
 def evaluate_agentic_kda_skill(
@@ -323,6 +340,7 @@ def evaluate_agentic_kda_skill(
     k: int = _DEFAULT_K,
     max_iterations: int = _DEFAULT_MAX_ITERATIONS,
     initial_conversation_id: str | None = None,
+    agent_id: str | None = None,
     langfuse: object | None = None,
     dataset_item_id: str = "",
     dataset_name: str = "kda_skill",
@@ -330,8 +348,13 @@ def evaluate_agentic_kda_skill(
     model_version_override: str | None = None,
     run_metadata_extra: dict | None = None,
     reasoning_effort: ReasoningEffort | None = None,
-) -> None:
-    """Run KDA-skill evaluation, log to Langfuse, and raise KdaSkillAssertionError on failure."""
+) -> AgenticEvalOutcome:
+    """Run KDA-skill evaluation, log to Langfuse, and raise KdaSkillAssertionError on failure.
+
+    Returns the best run's outcome (reasoning_steps, conversation_id, response_id) as an
+    AgenticEvalOutcome on success; on failure the same three values are attached to the
+    raised exception as ``.reasoning_steps``/``.conversation_id``/``.response_id``.
+    """
     from datetime import datetime as _dt  # noqa: PLC0415
     from datetime import timezone as _tz  # noqa: PLC0415
 
@@ -350,6 +373,7 @@ def evaluate_agentic_kda_skill(
         max_iterations=max_iterations,
         initial_conversation_id=initial_conversation_id,
         reasoning_effort=reasoning_effort,
+        agent_id=agent_id,
     )
 
     if langfuse is not None and dataset_item_id:
@@ -420,4 +444,33 @@ def evaluate_agentic_kda_skill(
             f"Actual create args: {best.actual_create_args}. "
             f"Actual execute result: {best.actual_execute_result}."
         )
-        raise KdaSkillAssertionError(message)
+        exc = KdaSkillAssertionError(message)
+        exc.reasoning_steps = best.reasoning_steps
+        exc.conversation_id = best.conversation_id
+        exc.response_id = best.response_id
+        exc.detail = {
+            "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,
+        }
+        raise exc
+    best = summary.best
+    ev = best.evaluation
+    return AgenticEvalOutcome(
+        reasoning_steps=best.reasoning_steps,
+        conversation_id=best.conversation_id,
+        response_id=best.response_id,
+        detail={
+            "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,
+        },
+    )