@uipath/apollo-vertex 0.0.0-stage → 0.3.0

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

@@ -0,0 +1,116 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useVertexTranslation } from "../../../../../lib/vertex-translation.js";
+import { Badge } from "../../../../badge/badge.js";
+import { Tooltip, TooltipContent, TooltipTrigger } from "../../../../tooltip/tooltip.js";
+import { DocumentSection } from "../../../ixp/shared/document-section.js";
+import { IxpDocStatus, IxpVerdict } from "../schema.js";
+import { FieldGroup } from "./field-group.js";
+function groupFields(fields) {
+    const map = new Map();
+    for (const f of fields){
+        const list = map.get(f.group);
+        if (list) list.push(f);
+        else map.set(f.group, [
+            f
+        ]);
+    }
+    return [
+        ...map.entries()
+    ];
+}
+const DocumentSummary = ({ doc, different, semanticallySame })=>{
+    const { t } = useVertexTranslation();
+    if (doc.status === IxpDocStatus.MissingInActual) return /*#__PURE__*/ jsx(Badge, {
+        status: "error",
+        children: t("ixp_doc_missing")
+    });
+    if (doc.status === IxpDocStatus.NewInActual) return /*#__PURE__*/ jsx(Badge, {
+        status: "info",
+        children: t("ixp_doc_new")
+    });
+    const hasDiff = different > 0;
+    const hasSemantic = semanticallySame > 0;
+    const isPerfectMatch = !hasDiff && !hasSemantic;
+    const metrics = [
+        {
+            show: hasDiff,
+            status: "error",
+            labelKey: "ixp_count_different",
+            count: different
+        },
+        {
+            show: hasSemantic,
+            status: "warning",
+            labelKey: "ixp_count_semantically_same",
+            count: semanticallySame
+        },
+        {
+            show: isPerfectMatch,
+            status: "success",
+            labelKey: "ixp_doc_match"
+        }
+    ];
+    return /*#__PURE__*/ jsxs("div", {
+        className: "flex items-center gap-1.5",
+        children: [
+            metrics.filter((m)=>m.show).map((m)=>/*#__PURE__*/ jsx(Badge, {
+                    status: m.status,
+                    variant: "secondary",
+                    children: "count" in m ? t(m.labelKey, {
+                        count: m.count
+                    }) : t(m.labelKey)
+                }, m.labelKey)),
+            /*#__PURE__*/ jsx("span", {
+                className: "text-xs text-muted-foreground",
+                children: t("ixp_identical_ratio", {
+                    identical: doc.identical_count,
+                    total: doc.total_fields
+                })
+            })
+        ]
+    });
+};
+const DocumentRow = ({ doc })=>{
+    const { t } = useVertexTranslation();
+    const verdictCounts = doc.fields.reduce((acc, f)=>{
+        acc[f.verdict] = (acc[f.verdict] ?? 0) + 1;
+        return acc;
+    }, {});
+    const different = verdictCounts[IxpVerdict.Different] ?? 0;
+    const semanticallySame = verdictCounts[IxpVerdict.SemanticallySame] ?? 0;
+    const isClean = doc.status === IxpDocStatus.Compared && 0 === different && 0 === semanticallySame;
+    const groups = groupFields(doc.fields);
+    return /*#__PURE__*/ jsx(DocumentSection, {
+        title: doc.document,
+        titleAccessory: doc.previous_document ? /*#__PURE__*/ jsxs(Tooltip, {
+            children: [
+                /*#__PURE__*/ jsx(TooltipTrigger, {
+                    asChild: true,
+                    children: /*#__PURE__*/ jsx(Badge, {
+                        status: "warning",
+                        variant: "secondary",
+                        className: "shrink-0",
+                        children: t("ixp_doc_reclassified")
+                    })
+                }),
+                /*#__PURE__*/ jsx(TooltipContent, {
+                    children: t("ixp_doc_reclassified_tooltip", {
+                        previous: doc.previous_document
+                    })
+                })
+            ]
+        }) : null,
+        summary: /*#__PURE__*/ jsx(DocumentSummary, {
+            doc: doc,
+            different: different,
+            semanticallySame: semanticallySame
+        }),
+        defaultOpen: !isClean,
+        children: groups.map(([group, fields])=>/*#__PURE__*/ jsx(FieldGroup, {
+                group: group,
+                fields: fields
+            }, group))
+    });
+};
+export { DocumentRow };

package/dist/registry/solution-tests/evaluators/ixp-extraction/internal/field-group.d.ts

@@ -0,0 +1,7 @@
+import { type IxpField } from "../schema";
+/** One field group within a document: a heading + a table of fields. Identical
+ * fields are hidden behind a toggle so the changes stand out. */
+export declare const FieldGroup: ({ group, fields, }: {
+    group: string;
+    fields: IxpField[];
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/registry/solution-tests/evaluators/ixp-extraction/internal/field-group.js

@@ -0,0 +1,78 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { useVertexTranslation } from "../../../../../lib/vertex-translation.js";
+import { Button } from "../../../../button/button.js";
+import { FieldCell, FieldGroupHeading, FieldRow, FieldTable } from "../../../ixp/shared/field-table.js";
+import { formatFieldValues } from "../../../ixp/shared/format-values.js";
+import { IxpVerdict } from "../schema.js";
+import { VerdictBadge } from "./verdict-badge.js";
+const FieldGroup = ({ group, fields })=>{
+    const { t } = useVertexTranslation();
+    const [showUnchanged, setShowUnchanged] = useState(false);
+    const changed = fields.filter((f)=>f.verdict !== IxpVerdict.Identical);
+    const identicalCount = fields.length - changed.length;
+    const visible = showUnchanged ? fields : changed;
+    return /*#__PURE__*/ jsxs("div", {
+        className: "mt-3 first:mt-0",
+        children: [
+            /*#__PURE__*/ jsx(FieldGroupHeading, {
+                children: group
+            }),
+            visible.length > 0 && /*#__PURE__*/ jsx(FieldTable, {
+                columns: [
+                    {
+                        label: t("ixp_field")
+                    },
+                    {
+                        label: t("ixp_baseline")
+                    },
+                    {
+                        label: t("ixp_new")
+                    },
+                    {
+                        label: t("ixp_verdict"),
+                        align: "right"
+                    }
+                ],
+                children: visible.map((f, i)=>/*#__PURE__*/ jsxs(FieldRow, {
+                        children: [
+                            /*#__PURE__*/ jsx(FieldCell, {
+                                className: "font-medium",
+                                children: f.field
+                            }),
+                            /*#__PURE__*/ jsx(FieldCell, {
+                                muted: true,
+                                children: formatFieldValues(f.expected)
+                            }),
+                            /*#__PURE__*/ jsxs(FieldCell, {
+                                children: [
+                                    formatFieldValues(f.actual),
+                                    f.verdict_reason && f.verdict !== IxpVerdict.Identical && /*#__PURE__*/ jsx("div", {
+                                        className: "mt-0.5 text-[11px] italic text-muted-foreground",
+                                        children: f.verdict_reason
+                                    })
+                                ]
+                            }),
+                            /*#__PURE__*/ jsx(FieldCell, {
+                                align: "right",
+                                children: /*#__PURE__*/ jsx(VerdictBadge, {
+                                    verdict: f.verdict
+                                })
+                            })
+                        ]
+                    }, `${f.field}-${i}`))
+            }),
+            identicalCount > 0 && /*#__PURE__*/ jsx(Button, {
+                variant: "link",
+                size: "sm",
+                onClick: ()=>setShowUnchanged((s)=>!s),
+                className: "mt-1 h-auto p-0 text-xs text-muted-foreground",
+                children: showUnchanged ? t("ixp_hide_unchanged") : t("ixp_show_unchanged", {
+                    count: identicalCount
+                })
+            })
+        ]
+    });
+};
+export { FieldGroup };

package/dist/registry/solution-tests/evaluators/ixp-extraction/internal/provenance-bar.d.ts

@@ -0,0 +1,5 @@
+import type { IxpProvenance } from "../schema";
+export declare const ProvenanceBar: ({ expected, actual, }: {
+    expected: IxpProvenance | null;
+    actual: IxpProvenance | null;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/registry/solution-tests/evaluators/ixp-extraction/internal/provenance-bar.js

@@ -0,0 +1,33 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { useVertexTranslation } from "../../../../../lib/vertex-translation.js";
+import { BaselineCompare } from "../../../baseline-compare.js";
+import { versionDelta } from "../../../utils.js";
+import { VersionDeltaGlyph } from "../../../version-delta-glyph.js";
+const ProvenanceBar = ({ expected, actual })=>{
+    const { t } = useVertexTranslation();
+    const baselineVersion = formatVersion(expected?.resolved_project_version);
+    const currentVersion = formatVersion(actual?.resolved_project_version);
+    const { direction } = versionDelta(expected?.resolved_project_version, actual?.resolved_project_version);
+    return /*#__PURE__*/ jsx(BaselineCompare, {
+        rows: [
+            {
+                label: t("ixp_taxonomy_version"),
+                baseline: baselineVersion,
+                current: currentVersion,
+                marker: /*#__PURE__*/ jsx(VersionDeltaGlyph, {
+                    direction: direction,
+                    baseline: baselineVersion
+                })
+            },
+            {
+                label: t("ixp_extractor"),
+                baseline: expected?.extractor ?? null,
+                current: actual?.extractor ?? null,
+                mono: true
+            }
+        ]
+    });
+};
+const formatVersion = (version)=>null == version ? null : `v${version}`;
+export { ProvenanceBar };

package/dist/registry/solution-tests/evaluators/ixp-extraction/internal/summary-bar.d.ts

@@ -0,0 +1,6 @@
+/** Top-level verdict tally across all compared documents. */
+export declare const SummaryBar: ({ different, semanticallySame, identical, }: {
+    different: number;
+    semanticallySame: number;
+    identical: number;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/registry/solution-tests/evaluators/ixp-extraction/internal/summary-bar.js

@@ -0,0 +1,34 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useVertexTranslation } from "../../../../../lib/vertex-translation.js";
+import { Badge } from "../../../../badge/badge.js";
+const SummaryBar = ({ different, semanticallySame, identical })=>{
+    const { t } = useVertexTranslation();
+    return /*#__PURE__*/ jsxs("div", {
+        className: "flex flex-wrap items-center gap-2",
+        children: [
+            /*#__PURE__*/ jsx(Badge, {
+                status: different > 0 ? "error" : "success",
+                variant: "secondary",
+                children: t("ixp_count_different", {
+                    count: different
+                })
+            }),
+            semanticallySame > 0 && /*#__PURE__*/ jsx(Badge, {
+                status: "warning",
+                variant: "secondary",
+                children: t("ixp_count_semantically_same", {
+                    count: semanticallySame
+                })
+            }),
+            /*#__PURE__*/ jsx(Badge, {
+                status: "info",
+                variant: "secondary",
+                children: t("ixp_count_identical", {
+                    count: identical
+                })
+            })
+        ]
+    });
+};
+export { SummaryBar };

package/dist/registry/solution-tests/evaluators/ixp-extraction/internal/verdict-badge.d.ts

@@ -0,0 +1,3 @@
+export declare const VerdictBadge: ({ verdict }: {
+    verdict: string;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/registry/solution-tests/evaluators/ixp-extraction/internal/verdict-badge.js

@@ -0,0 +1,29 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { useVertexTranslation } from "../../../../../lib/vertex-translation.js";
+import { Badge } from "../../../../badge/badge.js";
+import { IxpVerdict } from "../schema.js";
+const VERDICT_CONFIG = {
+    [IxpVerdict.Identical]: {
+        status: "info",
+        labelKey: "ixp_verdict_identical"
+    },
+    [IxpVerdict.SemanticallySame]: {
+        status: "warning",
+        labelKey: "ixp_verdict_semantically_same"
+    },
+    [IxpVerdict.Different]: {
+        status: "error",
+        labelKey: "ixp_verdict_different"
+    }
+};
+const VerdictBadge = ({ verdict })=>{
+    const { t } = useVertexTranslation();
+    const config = VERDICT_CONFIG[verdict];
+    return /*#__PURE__*/ jsx(Badge, {
+        status: config?.status ?? "info",
+        variant: "outline",
+        children: config ? t(config.labelKey) : verdict
+    });
+};
+export { VerdictBadge };

package/dist/registry/solution-tests/evaluators/ixp-extraction/ixp-extraction-result.d.ts

@@ -0,0 +1,7 @@
+import type { EvaluatorResultProps } from "../registry";
+import type { IxpDetails } from "./schema";
+/** IXP document-extraction evaluator view: taxonomy provenance, a verdict
+ * summary, and a per-document / per-field comparison. Renders entirely from
+ * the evaluator details — it does not read the raw expected/actual outputs.
+ * Details are validated by the registry, so they arrive already typed. */
+export declare const IxpExtractionResult: ({ evaluatorDetails, }: EvaluatorResultProps<IxpDetails>) => import("react/jsx-runtime").JSX.Element;

package/dist/registry/solution-tests/evaluators/ixp-extraction/ixp-extraction-result.js

@@ -0,0 +1,34 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useVertexTranslation } from "../../../../lib/vertex-translation.js";
+import { ProvenanceBar } from "./internal/provenance-bar.js";
+import { SummaryBar } from "./internal/summary-bar.js";
+import { DocumentRow } from "./internal/document-row.js";
+const IxpExtractionResult = ({ evaluatorDetails })=>{
+    const { t } = useVertexTranslation();
+    const { documents, different_field_count, semantically_same_field_count, identical_field_count, expected_provenance, actual_provenance } = evaluatorDetails;
+    return /*#__PURE__*/ jsxs("div", {
+        className: "flex flex-col gap-4",
+        children: [
+            /*#__PURE__*/ jsx(ProvenanceBar, {
+                expected: expected_provenance,
+                actual: actual_provenance
+            }),
+            /*#__PURE__*/ jsx(SummaryBar, {
+                different: different_field_count,
+                semanticallySame: semantically_same_field_count,
+                identical: identical_field_count
+            }),
+            /*#__PURE__*/ jsx("div", {
+                className: "flex flex-col gap-2",
+                children: 0 === documents.length ? /*#__PURE__*/ jsx("p", {
+                    className: "text-sm text-muted-foreground",
+                    children: t("ixp_no_documents")
+                }) : documents.map((doc, i)=>/*#__PURE__*/ jsx(DocumentRow, {
+                        doc: doc
+                    }, `${doc.document}-${i}`))
+            })
+        ]
+    });
+};
+export { IxpExtractionResult };

package/dist/registry/solution-tests/evaluators/ixp-extraction/schema.d.ts

@@ -0,0 +1,82 @@
+import { z } from "zod";
+/** The three-way per-field verdict the IXP evaluator emits. */
+export declare const IxpVerdict: {
+    readonly Identical: "identical";
+    readonly SemanticallySame: "semantically_same";
+    readonly Different: "different";
+};
+export type IxpVerdictValue = (typeof IxpVerdict)[keyof typeof IxpVerdict];
+/** Per-document comparison status. */
+export declare const IxpDocStatus: {
+    readonly Compared: "compared";
+    readonly MissingInActual: "missing_in_actual";
+    readonly NewInActual: "new_in_actual";
+};
+declare const ProvenanceSchema: z.ZodObject<{
+    project_name: z.ZodString;
+    resolved_project_version: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>>;
+    extractor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    tag: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+declare const FieldSchema: z.ZodObject<{
+    group: z.ZodString;
+    field: z.ZodString;
+    expected: z.ZodArray<z.ZodUnknown>;
+    actual: z.ZodArray<z.ZodUnknown>;
+    verdict: z.ZodString;
+    verdict_reason: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+declare const DocumentSchema: z.ZodObject<{
+    document: z.ZodString;
+    previous_document: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    status: z.ZodString;
+    score: z.ZodNumber;
+    identical_count: z.ZodNumber;
+    total_fields: z.ZodNumber;
+    fields: z.ZodArray<z.ZodObject<{
+        group: z.ZodString;
+        field: z.ZodString;
+        expected: z.ZodArray<z.ZodUnknown>;
+        actual: z.ZodArray<z.ZodUnknown>;
+        verdict: z.ZodString;
+        verdict_reason: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const IxpDetailsSchema: z.ZodObject<{
+    documents: z.ZodArray<z.ZodObject<{
+        document: z.ZodString;
+        previous_document: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        status: z.ZodString;
+        score: z.ZodNumber;
+        identical_count: z.ZodNumber;
+        total_fields: z.ZodNumber;
+        fields: z.ZodArray<z.ZodObject<{
+            group: z.ZodString;
+            field: z.ZodString;
+            expected: z.ZodArray<z.ZodUnknown>;
+            actual: z.ZodArray<z.ZodUnknown>;
+            verdict: z.ZodString;
+            verdict_reason: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    different_field_count: z.ZodNumber;
+    semantically_same_field_count: z.ZodNumber;
+    identical_field_count: z.ZodNumber;
+    expected_provenance: z.ZodNullable<z.ZodObject<{
+        project_name: z.ZodString;
+        resolved_project_version: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>>;
+        extractor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        tag: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    actual_provenance: z.ZodNullable<z.ZodObject<{
+        project_name: z.ZodString;
+        resolved_project_version: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>>;
+        extractor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        tag: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type IxpDetails = z.infer<typeof IxpDetailsSchema>;
+export type IxpDocument = z.infer<typeof DocumentSchema>;
+export type IxpField = z.infer<typeof FieldSchema>;
+export type IxpProvenance = z.infer<typeof ProvenanceSchema>;
+export {};

package/dist/registry/solution-tests/evaluators/ixp-extraction/schema.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+const IxpVerdict = {
+    Identical: "identical",
+    SemanticallySame: "semantically_same",
+    Different: "different"
+};
+const IxpDocStatus = {
+    Compared: "compared",
+    MissingInActual: "missing_in_actual",
+    NewInActual: "new_in_actual"
+};
+const ProvenanceSchema = z.object({
+    project_name: z.string(),
+    resolved_project_version: z.union([
+        z.number(),
+        z.string()
+    ]).nullish(),
+    extractor: z.string().nullish(),
+    tag: z.string().nullish()
+});
+const FieldSchema = z.object({
+    group: z.string(),
+    field: z.string(),
+    expected: z.array(z.unknown()),
+    actual: z.array(z.unknown()),
+    verdict: z.string(),
+    verdict_reason: z.string().optional().default("")
+});
+const DocumentSchema = z.object({
+    document: z.string(),
+    previous_document: z.string().nullish(),
+    status: z.string(),
+    score: z.number(),
+    identical_count: z.number(),
+    total_fields: z.number(),
+    fields: z.array(FieldSchema)
+});
+const IxpDetailsSchema = z.object({
+    documents: z.array(DocumentSchema),
+    different_field_count: z.number(),
+    semantically_same_field_count: z.number(),
+    identical_field_count: z.number(),
+    expected_provenance: ProvenanceSchema.nullable(),
+    actual_provenance: ProvenanceSchema.nullable()
+});
+export { IxpDetailsSchema, IxpDocStatus, IxpVerdict };

package/dist/registry/solution-tests/evaluators/output-panels.d.ts

@@ -0,0 +1,5 @@
+export declare function formatJson(data: unknown): string;
+export declare const JsonPanel: ({ title, data, }: {
+    title?: string;
+    data: unknown;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/registry/solution-tests/evaluators/output-panels.js

@@ -0,0 +1,28 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { EMPTY_VALUE } from "../constants.js";
+function formatJson(data) {
+    if (null == data) return EMPTY_VALUE;
+    if ("string" == typeof data) try {
+        return JSON.stringify(JSON.parse(data), null, 2);
+    } catch  {
+        return data;
+    }
+    return JSON.stringify(data, null, 2);
+}
+const JsonPanel = ({ title, data })=>/*#__PURE__*/ jsxs("div", {
+        children: [
+            null != title && /*#__PURE__*/ jsx("h4", {
+                className: "mb-2 text-sm font-semibold",
+                children: title
+            }),
+            /*#__PURE__*/ jsx("div", {
+                className: "max-h-[30vh] overflow-auto rounded-md border bg-muted/50 p-3",
+                children: /*#__PURE__*/ jsx("pre", {
+                    className: "whitespace-pre-wrap break-words text-xs",
+                    children: formatJson(data)
+                })
+            })
+        ]
+    });
+export { JsonPanel, formatJson };

package/dist/registry/solution-tests/evaluators/registry.d.ts

@@ -0,0 +1,33 @@
+import type { ComponentType, ReactNode } from "react";
+import type { z } from "zod";
+import type { SolutionTestRunResult } from "../types";
+export declare const JSON_SIMILARITY_EVALUATOR_ID = "uipath-json-similarity";
+export declare const LLM_JUDGE_EVALUATOR_ID = "uipath-llm-judge-output-semantic-similarity";
+export declare const IXP_EXTRACTION_EVALUATOR_ID = "uipath-ixp-document-extraction";
+export declare const CASE_EVALUATION_EVALUATOR_ID = "uipath-pe-case-evaluation";
+export interface EvaluatorRenderArgs {
+    evaluatorId: string;
+    score: number | undefined;
+    /** Raw, unvalidated `details` off the EvaluatorResults attachment. */
+    rawDetails: unknown;
+    expectedOutput: unknown;
+    actualOutput: unknown;
+    result: SolutionTestRunResult;
+}
+export type EvaluatorResultProps<TDetails = unknown> = Omit<EvaluatorRenderArgs, "rawDetails"> & {
+    evaluatorDetails: TDetails;
+};
+export type EvaluatorRenderer = (args: EvaluatorRenderArgs) => ReactNode;
+export type EvaluatorRenderers = Record<string, EvaluatorRenderer>;
+/** Bind an evaluator's schema + component (and any registration-time `bound`
+ * props) into a renderer. */
+export declare function makeRenderer<TDetails, TExtra extends object>(schema: z.ZodType<TDetails>, Component: ComponentType<EvaluatorResultProps<TDetails> & TExtra>, bound: TExtra): EvaluatorRenderer;
+/** The generic card; reuse for a custom evaluator that keeps the
+ * `{score, justification}` contract, binding an optional display `label`. */
+export declare function genericRenderer(options?: {
+    label?: string;
+}): EvaluatorRenderer;
+/** Fallback for unknown ids (the card then shows the raw evaluator id). */
+export declare const GENERIC_RENDERER: EvaluatorRenderer;
+/** Precedence: vertical renderers > built-ins > generic fallback. */
+export declare function resolveEvaluatorRenderer(evaluatorId: string, verticalRenderers?: EvaluatorRenderers): EvaluatorRenderer;

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

@@ -0,0 +1,42 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { GenericEvaluatorDetailsSchema, GenericEvaluatorResult } from "./generic-evaluator-result.js";
+import { CaseEvaluationResult } from "./case-evaluation/case-evaluation-result.js";
+import { CaseEvaluationDetailsSchema } from "./case-evaluation/schema.js";
+import { IxpExtractionResult } from "./ixp-extraction/ixp-extraction-result.js";
+import { IxpDetailsSchema } from "./ixp-extraction/schema.js";
+const JSON_SIMILARITY_EVALUATOR_ID = "uipath-json-similarity";
+const LLM_JUDGE_EVALUATOR_ID = "uipath-llm-judge-output-semantic-similarity";
+const IXP_EXTRACTION_EVALUATOR_ID = "uipath-ixp-document-extraction";
+const CASE_EVALUATION_EVALUATOR_ID = "uipath-pe-case-evaluation";
+function makeRenderer(schema, Component, bound) {
+    return ({ rawDetails, ...rest })=>{
+        const parsed = schema.safeParse(rawDetails);
+        if (!parsed.success) return null;
+        return /*#__PURE__*/ jsx(Component, {
+            evaluatorDetails: parsed.data,
+            ...bound,
+            ...rest
+        });
+    };
+}
+function genericRenderer(options = {}) {
+    return makeRenderer(GenericEvaluatorDetailsSchema, GenericEvaluatorResult, {
+        label: options.label
+    });
+}
+const GENERIC_RENDERER = genericRenderer();
+const EVALUATOR_RENDERERS = {
+    [JSON_SIMILARITY_EVALUATOR_ID]: genericRenderer({
+        label: "JSON Similarity"
+    }),
+    [LLM_JUDGE_EVALUATOR_ID]: genericRenderer({
+        label: "LLM Judge"
+    }),
+    [IXP_EXTRACTION_EVALUATOR_ID]: makeRenderer(IxpDetailsSchema, IxpExtractionResult, {}),
+    [CASE_EVALUATION_EVALUATOR_ID]: makeRenderer(CaseEvaluationDetailsSchema, CaseEvaluationResult, {})
+};
+function resolveEvaluatorRenderer(evaluatorId, verticalRenderers) {
+    return verticalRenderers?.[evaluatorId] ?? EVALUATOR_RENDERERS[evaluatorId] ?? GENERIC_RENDERER;
+}
+export { CASE_EVALUATION_EVALUATOR_ID, GENERIC_RENDERER, IXP_EXTRACTION_EVALUATOR_ID, JSON_SIMILARITY_EVALUATOR_ID, LLM_JUDGE_EVALUATOR_ID, genericRenderer, makeRenderer, resolveEvaluatorRenderer };

package/dist/registry/solution-tests/expanded-agents-view.d.ts

@@ -0,0 +1,16 @@
+import type { SolutionTest, SolutionTestJob } from "./types";
+export interface ExpandedAgentsViewProps {
+    test: SolutionTest;
+    baselines: SolutionTestJob[];
+    isLoading: boolean;
+    /** Jobs whose expected-output fetch came back empty (rendered as "no output"). */
+    noOutputJobIds: Set<string>;
+    viewing: {
+        job: SolutionTestJob;
+        data: unknown;
+        loading: boolean;
+    } | null;
+    onViewExpected: (job: SolutionTestJob) => void;
+    onCloseViewer: () => void;
+}
+export declare const ExpandedAgentsView: ({ test, baselines, isLoading, noOutputJobIds, viewing, onViewExpected, onCloseViewer, }: ExpandedAgentsViewProps) => import("react/jsx-runtime").JSX.Element;