@uipath/apollo-vertex 0.0.0-stage → 0.3.0

package/dist/registry/solution-tests/errors.js

@@ -0,0 +1,57 @@
+"use client";
+import { AGENT_SUCCESS_STATUSES } from "./constants.js";
+class SolutionTestActionError extends Error {
+    key;
+    details;
+    constructor(failure){
+        super(failure.key ?? failure.message ?? "request_failed");
+        this.name = "SolutionTestActionError";
+        this.key = failure.key;
+        this.details = failure.details;
+    }
+}
+function isRecord(value) {
+    return "object" == typeof value && null !== value && !Array.isArray(value);
+}
+function toDetails(value) {
+    if (!isRecord(value)) return;
+    const out = {};
+    for (const [k, v] of Object.entries(value))if ("string" == typeof v) out[k] = v;
+    if (0 === Object.keys(out).length) return;
+    return out;
+}
+function fromUserMessage(value) {
+    if (!isRecord(value)) return null;
+    const failure = {};
+    if ("string" == typeof value.key) failure.key = value.key;
+    if ("string" == typeof value.message) failure.message = value.message;
+    const details = toDetails(value.details);
+    if (details) failure.details = details;
+    if (!failure.key && !failure.message && !failure.details) return null;
+    return failure;
+}
+function extractFailure(data) {
+    if (!isRecord(data)) return null;
+    const output = isRecord(data.output_data) ? data.output_data : data;
+    if ("number" == typeof output.status_code && output.status_code >= 400) {
+        const failure = fromUserMessage(data.body) ?? {};
+        if ("string" == typeof output.error) {
+            failure.key ??= output.error;
+            failure.message ??= output.error;
+        }
+        failure.key ??= "request_failed";
+        return failure;
+    }
+    if ("string" == typeof output.status && !AGENT_SUCCESS_STATUSES.has(output.status)) {
+        const failure = fromUserMessage(output.error_message) ?? {};
+        if ("string" == typeof output.message) {
+            failure.key ??= output.message;
+            failure.message ??= output.message;
+        }
+        failure.key ??= output.status;
+        failure.message ??= output.status;
+        return failure;
+    }
+    return null;
+}
+export { SolutionTestActionError, extractFailure };

package/dist/registry/solution-tests/evaluator-results-view.d.ts

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import type { SolutionTestRunResult } from "./types";
+/** The `EvaluatorResults` attachment is untrusted wire data, so it's validated
+ * at the fetch boundary via `parseEvaluatorResults`. Each value's `details`
+ * stays `unknown` until the resolved renderer validates it against that
+ * evaluator's schema. */
+declare const EvaluatorResultsSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    score: z.ZodOptional<z.ZodNumber>;
+    details: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>>;
+export type EvaluatorResults = z.infer<typeof EvaluatorResultsSchema>;
+/** Validate the raw `EvaluatorResults` attachment (a JSON string or object)
+ * into a typed map, or `null` if it's absent / not a valid results map. This
+ * is the trust boundary — callers pass the parsed result on as a typed prop. */
+export declare function parseEvaluatorResults(data: unknown): EvaluatorResults | null;
+interface EvaluatorResultsViewProps {
+    data: EvaluatorResults;
+    expectedOutput: unknown;
+    actualOutput: unknown;
+    result: SolutionTestRunResult;
+}
+/** Renders each evaluator's result through the renderer registered for its id
+ * (falling back to the generic card). The evaluator id is the object key — no
+ * schema-sniffing needed. */
+export declare const EvaluatorResultsView: ({ data, expectedOutput, actualOutput, result, }: EvaluatorResultsViewProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/registry/solution-tests/evaluator-results-view.js

@@ -0,0 +1,38 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { Fragment } from "react";
+import { z } from "zod";
+import { useSolutionTestsConfig } from "./context.js";
+import { resolveEvaluatorRenderer } from "./evaluators/registry.js";
+const EvaluatorResultsSchema = z.record(z.string(), z.object({
+    score: z.number().optional(),
+    details: z.unknown().optional()
+}));
+function parseEvaluatorResults(data) {
+    if (null == data) return null;
+    let raw = data;
+    if ("string" == typeof raw) try {
+        raw = JSON.parse(raw);
+    } catch  {
+        return null;
+    }
+    const parsed = EvaluatorResultsSchema.safeParse(raw);
+    return parsed.success ? parsed.data : null;
+}
+const EvaluatorResultsView = ({ data, expectedOutput, actualOutput, result })=>{
+    const { evaluatorRenderers } = useSolutionTestsConfig();
+    return /*#__PURE__*/ jsx("div", {
+        className: "flex flex-col gap-4",
+        children: Object.entries(data).map(([evaluatorId, evaluator])=>/*#__PURE__*/ jsx(Fragment, {
+                children: resolveEvaluatorRenderer(evaluatorId, evaluatorRenderers)({
+                    evaluatorId,
+                    score: evaluator.score,
+                    rawDetails: evaluator.details,
+                    expectedOutput,
+                    actualOutput,
+                    result
+                })
+            }, evaluatorId))
+    });
+};
+export { EvaluatorResultsView, parseEvaluatorResults };

package/dist/registry/solution-tests/evaluators/case-evaluation/case-evaluation-result.d.ts

@@ -0,0 +1,7 @@
+import type { EvaluatorResultProps } from "../registry";
+import { type CaseEvaluationDetails } from "./schema";
+/** Case-evaluation evaluator view: baseline-vs-new comparison of the policy
+ * engine's evaluations, matched by policy — outcome exact-matched, summary
+ * judged semantically. Renders entirely from the evaluator details (validated
+ * by the registry, so they arrive already typed). */
+export declare const CaseEvaluationResult: ({ evaluatorDetails, }: EvaluatorResultProps<CaseEvaluationDetails>) => import("react/jsx-runtime").JSX.Element;

package/dist/registry/solution-tests/evaluators/case-evaluation/case-evaluation-result.js

@@ -0,0 +1,284 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { AlertCircle, Check, TriangleAlert } from "lucide-react";
+import { useVertexTranslation } from "../../../../lib/vertex-translation.js";
+import { Alert, AlertDescription, AlertTitle } from "../../../alert/alert.js";
+import { Badge } from "../../../badge/badge.js";
+import { BaselineCompare } from "../../baseline-compare.js";
+import { EMPTY_VALUE } from "../../constants.js";
+import { EvaluationPairStatus, SummaryVerdict } from "./schema.js";
+const pairRank = (pair)=>{
+    if (pair.status !== EvaluationPairStatus.Compared) return 1;
+    return pair.outcome_match && pair.summary_verdict === SummaryVerdict.Same ? 2 : 0;
+};
+const sortPairs = (pairs)=>pairs.toSorted((a, b)=>pairRank(a) - pairRank(b));
+const formatConfidence = (view)=>view?.confidence == null ? null : `${Math.round(100 * view.confidence)}%`;
+const presentOrNull = (value)=>{
+    if (!value) return null;
+    return value;
+};
+const ChangedBadge = ({ status })=>{
+    const { t } = useVertexTranslation();
+    return /*#__PURE__*/ jsx(Badge, {
+        status: status,
+        variant: "secondary",
+        children: t("pe_eval_changed")
+    });
+};
+const PairFields = ({ pair })=>{
+    const { t } = useVertexTranslation();
+    const { expected, actual } = pair;
+    const compared = pair.status === EvaluationPairStatus.Compared;
+    const modelChanged = (expected?.decision_model_id ?? "") !== (actual?.decision_model_id ?? "");
+    return /*#__PURE__*/ jsx(BaselineCompare, {
+        rows: [
+            {
+                label: t("pe_eval_field_outcome"),
+                baseline: presentOrNull(expected?.outcome),
+                current: presentOrNull(actual?.outcome),
+                marker: compared && !pair.outcome_match && /*#__PURE__*/ jsx(ChangedBadge, {
+                    status: "error"
+                })
+            },
+            {
+                label: t("pe_eval_field_confidence"),
+                baseline: formatConfidence(expected),
+                current: formatConfidence(actual)
+            },
+            {
+                label: t("pe_eval_field_decision_model"),
+                baseline: presentOrNull(expected?.decision_model_id),
+                current: presentOrNull(actual?.decision_model_id),
+                mono: true,
+                marker: compared && modelChanged && /*#__PURE__*/ jsx(ChangedBadge, {
+                    status: "warning"
+                })
+            }
+        ]
+    });
+};
+const SummarySide = ({ label, view })=>/*#__PURE__*/ jsxs("div", {
+        className: "flex min-w-0 flex-col gap-1",
+        children: [
+            /*#__PURE__*/ jsx("span", {
+                className: "text-xs text-muted-foreground",
+                children: label
+            }),
+            /*#__PURE__*/ jsx(SummaryCard, {
+                view: view
+            })
+        ]
+    });
+const SummaryCard = ({ view })=>{
+    const { t } = useVertexTranslation();
+    if (!view) return /*#__PURE__*/ jsx("div", {
+        className: "flex min-w-0 items-center justify-center rounded-md border border-dashed bg-muted/20 p-3",
+        children: /*#__PURE__*/ jsx(Badge, {
+            status: "error",
+            variant: "secondary",
+            children: t("pe_eval_no_counterpart")
+        })
+    });
+    return /*#__PURE__*/ jsxs("div", {
+        className: "min-w-0 break-words rounded-md border p-3",
+        children: [
+            view.error_message && /*#__PURE__*/ jsxs(Alert, {
+                status: "error",
+                visual: "tinted",
+                className: "mb-2",
+                children: [
+                    /*#__PURE__*/ jsx(TriangleAlert, {}),
+                    /*#__PURE__*/ jsx(AlertTitle, {
+                        children: t("pe_eval_faulted")
+                    }),
+                    /*#__PURE__*/ jsx(AlertDescription, {
+                        className: "whitespace-pre-wrap break-words",
+                        children: view.error_message
+                    })
+                ]
+            }),
+            view.summary ? /*#__PURE__*/ jsx("p", {
+                className: "whitespace-pre-wrap text-sm",
+                children: view.summary
+            }) : /*#__PURE__*/ jsx("p", {
+                className: "text-sm text-muted-foreground",
+                children: t("pe_eval_no_summary")
+            })
+        ]
+    });
+};
+const SummaryComparison = ({ pair })=>{
+    const { t } = useVertexTranslation();
+    const compared = pair.status === EvaluationPairStatus.Compared;
+    const same = pair.summary_verdict === SummaryVerdict.Same;
+    return /*#__PURE__*/ jsxs("div", {
+        className: "flex min-w-0 flex-col gap-2",
+        children: [
+            /*#__PURE__*/ jsxs("div", {
+                className: "flex flex-wrap items-center gap-2",
+                children: [
+                    /*#__PURE__*/ jsx("span", {
+                        className: "text-xs font-semibold text-muted-foreground",
+                        children: t("pe_eval_field_summary")
+                    }),
+                    compared && /*#__PURE__*/ jsxs(Badge, {
+                        status: same ? "success" : "warning",
+                        variant: "secondary",
+                        children: [
+                            same ? /*#__PURE__*/ jsx(Check, {
+                                className: "size-3",
+                                "aria-hidden": true
+                            }) : /*#__PURE__*/ jsx(TriangleAlert, {
+                                className: "size-3",
+                                "aria-hidden": true
+                            }),
+                            t(same ? "pe_eval_summary_same" : "pe_eval_summary_differs")
+                        ]
+                    }),
+                    pair.summary_reason && /*#__PURE__*/ jsx("span", {
+                        className: "text-[11px] italic text-muted-foreground",
+                        children: pair.summary_reason
+                    })
+                ]
+            }),
+            /*#__PURE__*/ jsxs("div", {
+                className: "grid grid-cols-2 gap-3",
+                children: [
+                    /*#__PURE__*/ jsx(SummarySide, {
+                        label: t("compare_baseline"),
+                        view: pair.expected
+                    }),
+                    /*#__PURE__*/ jsx(SummarySide, {
+                        label: t("compare_new_run"),
+                        view: pair.actual
+                    })
+                ]
+            }),
+            pair.summary_deltas.length > 0 && /*#__PURE__*/ jsxs("div", {
+                className: "rounded-md border border-warning/40 bg-warning/10 p-3",
+                children: [
+                    /*#__PURE__*/ jsx("p", {
+                        className: "text-xs font-medium",
+                        children: t("pe_eval_semantic_deltas")
+                    }),
+                    /*#__PURE__*/ jsx("ul", {
+                        className: "mt-1 list-disc pl-4 text-sm",
+                        children: pair.summary_deltas.map((delta)=>/*#__PURE__*/ jsx("li", {
+                                children: delta
+                            }, delta))
+                    })
+                ]
+            })
+        ]
+    });
+};
+const PairRow = ({ pair })=>{
+    const { t } = useVertexTranslation();
+    const oneSided = pair.status !== EvaluationPairStatus.Compared;
+    return /*#__PURE__*/ jsxs("div", {
+        className: "flex min-w-0 flex-col gap-3 rounded-md border p-3",
+        children: [
+            /*#__PURE__*/ jsxs("div", {
+                className: "flex flex-wrap items-center gap-2 text-xs",
+                children: [
+                    /*#__PURE__*/ jsx("span", {
+                        className: "font-semibold text-muted-foreground",
+                        children: t("pe_eval_policy")
+                    }),
+                    /*#__PURE__*/ jsx("span", {
+                        className: "font-mono",
+                        children: pair.policy_id || EMPTY_VALUE
+                    }),
+                    oneSided && /*#__PURE__*/ jsx(Badge, {
+                        status: "error",
+                        variant: "secondary",
+                        children: t(pair.status === EvaluationPairStatus.MissingInActual ? "pe_eval_status_missing" : "pe_eval_status_new")
+                    })
+                ]
+            }),
+            /*#__PURE__*/ jsx(PairFields, {
+                pair: pair
+            }),
+            /*#__PURE__*/ jsx(SummaryComparison, {
+                pair: pair
+            })
+        ]
+    });
+};
+const CaseEvaluationResult = ({ evaluatorDetails })=>{
+    const { t } = useVertexTranslation();
+    const { pairs, count_mismatch, expected_count, actual_count, same_count, outcome_mismatch_count, summary_differs_count, missing_count, added_count } = evaluatorDetails;
+    const summary = [
+        {
+            show: same_count > 0,
+            status: "success",
+            key: "pe_eval_count_same",
+            count: same_count
+        },
+        {
+            show: outcome_mismatch_count > 0,
+            status: "error",
+            key: "pe_eval_count_outcome_mismatch",
+            count: outcome_mismatch_count
+        },
+        {
+            show: summary_differs_count > 0,
+            status: "warning",
+            key: "pe_eval_count_summary_differs",
+            count: summary_differs_count
+        },
+        {
+            show: missing_count > 0,
+            status: "error",
+            key: "pe_eval_count_missing",
+            count: missing_count
+        },
+        {
+            show: added_count > 0,
+            status: "error",
+            key: "pe_eval_count_new",
+            count: added_count
+        }
+    ];
+    return /*#__PURE__*/ jsxs("div", {
+        className: "flex min-w-0 flex-col gap-4 whitespace-normal",
+        children: [
+            count_mismatch && /*#__PURE__*/ jsxs(Alert, {
+                status: "error",
+                visual: "tinted",
+                children: [
+                    /*#__PURE__*/ jsx(AlertCircle, {}),
+                    /*#__PURE__*/ jsx(AlertTitle, {
+                        children: t("pe_eval_count_mismatch_title")
+                    }),
+                    /*#__PURE__*/ jsx(AlertDescription, {
+                        children: t("pe_eval_count_mismatch_body", {
+                            expected: expected_count,
+                            actual: actual_count
+                        })
+                    })
+                ]
+            }),
+            /*#__PURE__*/ jsx("div", {
+                className: "flex flex-wrap items-center gap-2",
+                children: summary.filter((s)=>s.show).map((s)=>/*#__PURE__*/ jsx(Badge, {
+                        status: s.status,
+                        variant: "secondary",
+                        children: t(s.key, {
+                            count: s.count
+                        })
+                    }, s.key))
+            }),
+            0 === pairs.length ? /*#__PURE__*/ jsx("p", {
+                className: "text-sm text-muted-foreground",
+                children: t("pe_eval_no_pairs")
+            }) : /*#__PURE__*/ jsx("div", {
+                className: "flex min-w-0 flex-col gap-3",
+                children: sortPairs(pairs).map((pair, i)=>/*#__PURE__*/ jsx(PairRow, {
+                        pair: pair
+                    }, i))
+            })
+        ]
+    });
+};
+export { CaseEvaluationResult };

package/dist/registry/solution-tests/evaluators/case-evaluation/schema.d.ts

@@ -0,0 +1,96 @@
+import { z } from "zod";
+/** Per-pair status the case-evaluation evaluator emits (mirrors the BE pair
+ * statuses in shared/solution_tests/evaluators/case_evaluation.py). */
+export declare const EvaluationPairStatus: {
+    readonly Compared: "compared";
+    readonly MissingInActual: "missing_in_actual";
+    readonly NewInActual: "new_in_actual";
+};
+export declare const SummaryVerdict: {
+    readonly Same: "same";
+    readonly Differs: "differs";
+};
+declare const EvaluationViewSchema: z.ZodObject<{
+    outcome: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    confidence: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodNumber>>>;
+    summary: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    decision_model_id: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    status: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    error_message: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+declare const EvaluationPairSchema: z.ZodObject<{
+    policy_id: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    status: z.ZodEnum<{
+        readonly Compared: "compared";
+        readonly MissingInActual: "missing_in_actual";
+        readonly NewInActual: "new_in_actual";
+    }>;
+    outcome_match: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    summary_verdict: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        readonly Same: "same";
+        readonly Differs: "differs";
+    }>, z.ZodLiteral<"">]>>>;
+    summary_deltas: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    summary_reason: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    expected: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        outcome: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        confidence: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodNumber>>>;
+        summary: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        decision_model_id: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        status: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        error_message: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    }, z.core.$strip>>>>;
+    actual: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        outcome: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        confidence: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodNumber>>>;
+        summary: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        decision_model_id: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        status: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        error_message: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    }, z.core.$strip>>>>;
+}, z.core.$strip>;
+export declare const CaseEvaluationDetailsSchema: z.ZodObject<{
+    count_mismatch: z.ZodBoolean;
+    expected_count: z.ZodNumber;
+    actual_count: z.ZodNumber;
+    pairs: z.ZodArray<z.ZodObject<{
+        policy_id: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        status: z.ZodEnum<{
+            readonly Compared: "compared";
+            readonly MissingInActual: "missing_in_actual";
+            readonly NewInActual: "new_in_actual";
+        }>;
+        outcome_match: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        summary_verdict: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            readonly Same: "same";
+            readonly Differs: "differs";
+        }>, z.ZodLiteral<"">]>>>;
+        summary_deltas: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        summary_reason: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        expected: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            outcome: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+            confidence: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodNumber>>>;
+            summary: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+            decision_model_id: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+            status: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+            error_message: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        }, z.core.$strip>>>>;
+        actual: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            outcome: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+            confidence: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodNumber>>>;
+            summary: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+            decision_model_id: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+            status: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+            error_message: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        }, z.core.$strip>>>>;
+    }, z.core.$strip>>;
+    same_count: z.ZodNumber;
+    outcome_mismatch_count: z.ZodNumber;
+    summary_differs_count: z.ZodNumber;
+    missing_count: z.ZodNumber;
+    added_count: z.ZodNumber;
+}, z.core.$strip>;
+export type CaseEvaluationDetails = z.infer<typeof CaseEvaluationDetailsSchema>;
+export type EvaluationPair = z.infer<typeof EvaluationPairSchema>;
+export type EvaluationView = z.infer<typeof EvaluationViewSchema>;
+export {};

package/dist/registry/solution-tests/evaluators/case-evaluation/schema.js

@@ -0,0 +1,43 @@
+import { z } from "zod";
+const EvaluationPairStatus = {
+    Compared: "compared",
+    MissingInActual: "missing_in_actual",
+    NewInActual: "new_in_actual"
+};
+const SummaryVerdict = {
+    Same: "same",
+    Differs: "differs"
+};
+const EvaluationViewSchema = z.object({
+    outcome: z.string().optional().default(""),
+    confidence: z.number().nullable().optional().default(null),
+    summary: z.string().optional().default(""),
+    decision_model_id: z.string().optional().default(""),
+    status: z.string().optional().default(""),
+    error_message: z.string().optional().default("")
+});
+const EvaluationPairSchema = z.object({
+    policy_id: z.string().optional().default(""),
+    status: z["enum"](EvaluationPairStatus),
+    outcome_match: z.boolean().optional().default(false),
+    summary_verdict: z.union([
+        z["enum"](SummaryVerdict),
+        z.literal("")
+    ]).optional().default(""),
+    summary_deltas: z.array(z.string()).optional().default([]),
+    summary_reason: z.string().optional().default(""),
+    expected: EvaluationViewSchema.nullable().optional().default(null),
+    actual: EvaluationViewSchema.nullable().optional().default(null)
+});
+const CaseEvaluationDetailsSchema = z.object({
+    count_mismatch: z.boolean(),
+    expected_count: z.number(),
+    actual_count: z.number(),
+    pairs: z.array(EvaluationPairSchema),
+    same_count: z.number(),
+    outcome_mismatch_count: z.number(),
+    summary_differs_count: z.number(),
+    missing_count: z.number(),
+    added_count: z.number()
+});
+export { CaseEvaluationDetailsSchema, EvaluationPairStatus, SummaryVerdict };

package/dist/registry/solution-tests/evaluators/generic-evaluator-result.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+import type { EvaluatorResultProps } from "./registry";
+/** Schema for evaluators without a custom view (json-similarity, llm-judge):
+ * a score + optional justification, plus the raw expected/actual outputs. */
+export declare const GenericEvaluatorDetailsSchema: z.ZodObject<{
+    justification: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type GenericEvaluatorDetails = z.infer<typeof GenericEvaluatorDetailsSchema>;
+export declare const GenericEvaluatorResult: ({ evaluatorId, label, score, evaluatorDetails, expectedOutput, actualOutput, }: EvaluatorResultProps<GenericEvaluatorDetails> & {
+    label?: string;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/registry/solution-tests/evaluators/generic-evaluator-result.js

@@ -0,0 +1,62 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { z } from "zod";
+import { useVertexTranslation } from "../../../lib/vertex-translation.js";
+import { EMPTY_VALUE } from "../constants.js";
+import { useSolutionTestsConfig } from "../context.js";
+import { JsonPanel } from "./output-panels.js";
+const GenericEvaluatorDetailsSchema = z.object({
+    justification: z.string().optional()
+});
+function scoreColorClass(score, passThreshold) {
+    if (null == score) return "text-muted-foreground";
+    return score >= passThreshold ? "text-success" : "text-destructive";
+}
+const GenericEvaluatorResult = ({ evaluatorId, label, score, evaluatorDetails, expectedOutput, actualOutput })=>{
+    const { t } = useVertexTranslation();
+    const { passThreshold } = useSolutionTestsConfig();
+    const displayLabel = label ?? evaluatorId;
+    const justification = evaluatorDetails.justification;
+    const scoreStr = null == score ? EMPTY_VALUE : `${Math.round(100 * score)}%`;
+    return /*#__PURE__*/ jsxs("div", {
+        className: "flex flex-col gap-4",
+        children: [
+            /*#__PURE__*/ jsxs("div", {
+                className: "rounded-md border bg-muted/50 p-3",
+                children: [
+                    /*#__PURE__*/ jsxs("div", {
+                        className: "flex items-center justify-between",
+                        children: [
+                            /*#__PURE__*/ jsx("span", {
+                                className: "text-sm font-medium",
+                                children: displayLabel
+                            }),
+                            /*#__PURE__*/ jsx("span", {
+                                className: `text-sm font-semibold ${scoreColorClass(score, passThreshold)}`,
+                                children: scoreStr
+                            })
+                        ]
+                    }),
+                    justification && /*#__PURE__*/ jsx("p", {
+                        className: "mt-2 whitespace-pre-wrap text-xs",
+                        children: justification
+                    })
+                ]
+            }),
+            /*#__PURE__*/ jsxs("div", {
+                className: "grid grid-cols-2 gap-4",
+                children: [
+                    /*#__PURE__*/ jsx(JsonPanel, {
+                        title: t("expected_output"),
+                        data: expectedOutput
+                    }),
+                    /*#__PURE__*/ jsx(JsonPanel, {
+                        title: t("actual_output"),
+                        data: actualOutput
+                    })
+                ]
+            })
+        ]
+    });
+};
+export { GenericEvaluatorDetailsSchema, GenericEvaluatorResult };

package/dist/registry/solution-tests/evaluators/ixp-extraction/internal/document-row.d.ts

@@ -0,0 +1,6 @@
+import { type IxpDocument } from "../schema";
+/** A collapsible per-document section. Clean (all-identical) documents start
+ * collapsed; anything with a change or a missing/new status starts open. */
+export declare const DocumentRow: ({ doc }: {
+    doc: IxpDocument;
+}) => import("react/jsx-runtime").JSX.Element;