@uipath/apollo-vertex 0.0.0-stage → 0.3.0

package/dist/registry/solution-tests/kpi-bar.js

@@ -0,0 +1,189 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useVertexTranslation } from "../../lib/vertex-translation.js";
+import { TrendingUp } from "lucide-react";
+import { CartesianGrid, Line, LineChart, ReferenceLine, XAxis, YAxis } from "recharts";
+import { Card, CardContent, CardHeader, CardTitle } from "../card/card.js";
+import { ChartContainer, ChartTooltip, ChartTooltipContent } from "../chart/chart.js";
+import { Skeleton } from "../skeleton/skeleton.js";
+import { RunStatus } from "./types.js";
+import { renderValueOrEmptyState } from "../../lib/renderValueOrEmptyState.js";
+import { MAX_TREND_POINTS } from "./constants.js";
+import { useSolutionTestsConfig } from "./context.js";
+import { UserMessagesIcon } from "./user-messages-view.js";
+function isCompletedBatch(batch) {
+    return batch.Status === RunStatus.Passed || batch.Status === RunStatus.Failed;
+}
+const KpiBar = ({ batchRuns, loading = false })=>{
+    const { t } = useVertexTranslation();
+    const { subjectNoun, passThreshold } = useSolutionTestsConfig();
+    const scoreTrendChartConfig = {
+        score: {
+            label: t("score"),
+            color: "var(--primary)"
+        }
+    };
+    const completedBatches = batchRuns.filter((batch)=>isCompletedBatch(batch)).toSorted((a, b)=>new Date(b.CompletedAt ?? b.CreateTime ?? 0).getTime() - new Date(a.CompletedAt ?? a.CreateTime ?? 0).getTime());
+    const lastBatch = completedBatches[0];
+    const lastRunScore = lastBatch?.OverallScore;
+    const testsPassing = lastBatch?.TestsPassed;
+    const testsTotal = lastBatch?.TestsTotal;
+    const trendData = completedBatches.map((b)=>{
+        const date = new Date(b.CompletedAt ?? b.CreateTime ?? 0);
+        return {
+            date: date.toLocaleDateString([], {
+                month: "short",
+                day: "numeric"
+            }),
+            timestamp: date.getTime(),
+            score: null == b.OverallScore ? 0 : Math.round(100 * b.OverallScore)
+        };
+    }).toSorted((a, b)=>a.timestamp - b.timestamp).slice(-MAX_TREND_POINTS);
+    return /*#__PURE__*/ jsxs("div", {
+        className: "grid grid-cols-3 gap-4",
+        children: [
+            /*#__PURE__*/ jsxs(Card, {
+                variant: "glass",
+                className: "py-6",
+                children: [
+                    /*#__PURE__*/ jsx(CardHeader, {
+                        children: /*#__PURE__*/ jsx(CardTitle, {
+                            className: "text-base font-bold",
+                            children: t("last_run_score")
+                        })
+                    }),
+                    /*#__PURE__*/ jsx(CardContent, {
+                        className: "mt-auto",
+                        children: loading ? /*#__PURE__*/ jsx(Skeleton, {
+                            className: "h-9 w-20"
+                        }) : /*#__PURE__*/ jsxs("div", {
+                            className: "flex items-center gap-1.5",
+                            children: [
+                                /*#__PURE__*/ jsx("span", {
+                                    className: "text-3xl font-bold",
+                                    children: renderValueOrEmptyState(lastRunScore, {
+                                        type: "number",
+                                        options: {
+                                            style: "percent",
+                                            maximumFractionDigits: 0
+                                        }
+                                    })
+                                }),
+                                lastBatch && /*#__PURE__*/ jsx(UserMessagesIcon, {
+                                    messages: lastBatch.UserMessages
+                                })
+                            ]
+                        })
+                    })
+                ]
+            }),
+            /*#__PURE__*/ jsxs(Card, {
+                variant: "glass",
+                className: "py-6",
+                children: [
+                    /*#__PURE__*/ jsx(CardHeader, {
+                        children: /*#__PURE__*/ jsx(CardTitle, {
+                            className: "text-base font-bold",
+                            children: subjectNoun ? t("subject_passing", {
+                                subject: subjectNoun.plural
+                            }) : t("tests_passing")
+                        })
+                    }),
+                    /*#__PURE__*/ jsx(CardContent, {
+                        className: "mt-auto",
+                        children: loading ? /*#__PURE__*/ jsx(Skeleton, {
+                            className: "h-9 w-24"
+                        }) : /*#__PURE__*/ jsx("span", {
+                            className: "text-3xl font-bold",
+                            children: null == testsPassing || null == testsTotal ? "-" : `${testsPassing}/${testsTotal}`
+                        })
+                    })
+                ]
+            }),
+            /*#__PURE__*/ jsxs(Card, {
+                variant: "glass",
+                className: "py-6",
+                children: [
+                    /*#__PURE__*/ jsx(CardHeader, {
+                        children: /*#__PURE__*/ jsxs(CardTitle, {
+                            className: "flex items-center gap-1 text-base font-bold",
+                            children: [
+                                /*#__PURE__*/ jsx(TrendingUp, {
+                                    className: "size-3"
+                                }),
+                                t("score_trend")
+                            ]
+                        })
+                    }),
+                    /*#__PURE__*/ jsx(CardContent, {
+                        children: loading ? /*#__PURE__*/ jsx(Skeleton, {
+                            className: "h-[100px] w-full"
+                        }) : trendData.length > 1 ? /*#__PURE__*/ jsx(ChartContainer, {
+                            config: scoreTrendChartConfig,
+                            className: "aspect-auto h-[100px] w-full",
+                            children: /*#__PURE__*/ jsxs(LineChart, {
+                                data: trendData,
+                                margin: {
+                                    top: 8,
+                                    right: 8,
+                                    left: -20,
+                                    bottom: 0
+                                },
+                                children: [
+                                    /*#__PURE__*/ jsx(CartesianGrid, {
+                                        vertical: false,
+                                        strokeDasharray: "3 3"
+                                    }),
+                                    /*#__PURE__*/ jsx(XAxis, {
+                                        dataKey: "date",
+                                        tickLine: false,
+                                        axisLine: false,
+                                        fontSize: 10
+                                    }),
+                                    /*#__PURE__*/ jsx(YAxis, {
+                                        domain: [
+                                            0,
+                                            100
+                                        ],
+                                        tickLine: false,
+                                        axisLine: false,
+                                        fontSize: 10,
+                                        tickFormatter: (v)=>`${v}%`
+                                    }),
+                                    /*#__PURE__*/ jsx(ReferenceLine, {
+                                        y: 100 * passThreshold,
+                                        stroke: "var(--success)",
+                                        strokeDasharray: "3 3",
+                                        strokeOpacity: 0.5
+                                    }),
+                                    /*#__PURE__*/ jsx(ChartTooltip, {
+                                        content: /*#__PURE__*/ jsx(ChartTooltipContent, {
+                                            formatter: (value)=>`${String(value)}%`
+                                        })
+                                    }),
+                                    /*#__PURE__*/ jsx(Line, {
+                                        type: "monotone",
+                                        dataKey: "score",
+                                        stroke: "var(--color-score)",
+                                        strokeWidth: 2,
+                                        dot: {
+                                            fill: "var(--color-score)",
+                                            r: 3
+                                        },
+                                        activeDot: {
+                                            r: 5
+                                        }
+                                    })
+                                ]
+                            })
+                        }) : /*#__PURE__*/ jsx("div", {
+                            className: "flex h-[100px] items-center justify-center text-sm text-muted-foreground",
+                            children: 1 === trendData.length ? `${trendData[0].score}%` : "-"
+                        })
+                    })
+                ]
+            })
+        ]
+    });
+};
+export { KpiBar };

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

@@ -0,0 +1,6 @@
+import type { UseMutationResult } from "@tanstack/react-query";
+/** A write hook's return: the React Query mutation, keyed by its variables. */
+export type MutationHook<TVariables> = UseMutationResult<void, Error, TVariables>;
+export interface AttachmentFetcher<TArgs extends unknown[]> {
+    fetch: (...args: TArgs) => Promise<unknown>;
+}

package/dist/registry/solution-tests/outputs/case-evaluation/case-evaluation-output.d.ts

@@ -0,0 +1,5 @@
+import { type ProcessOutputProps } from "../registry";
+import { type CaseEvaluationOutput } from "./schema";
+/** evaluate_case job output: one card per processed Evaluations record. */
+export declare const CaseEvaluationOutputResult: ({ output, }: ProcessOutputProps<CaseEvaluationOutput>) => import("react/jsx-runtime").JSX.Element;
+export declare const CASE_EVALUATION_OUTPUT_RENDERER: import("../registry").ProcessOutputRenderer;

package/dist/registry/solution-tests/outputs/case-evaluation/case-evaluation-output.js

@@ -0,0 +1,60 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useVertexTranslation } from "../../../../lib/vertex-translation.js";
+import { Badge } from "../../../badge/badge.js";
+import { makeProcessOutputRenderer } from "../registry.js";
+import { CaseEvaluationOutputSchema } from "./schema.js";
+const EvaluationCard = ({ evaluation })=>{
+    const { t } = useVertexTranslation();
+    const faulted = "faulted" === evaluation.STATUS;
+    const outcome = evaluation.OUTCOME || t("pe_output_no_outcome");
+    const confidence = null == evaluation.OUTCOMECONFIDENCE ? null : Math.round(100 * evaluation.OUTCOMECONFIDENCE);
+    return /*#__PURE__*/ jsxs("div", {
+        className: "flex min-w-0 flex-col gap-2 break-words rounded-md border p-3",
+        children: [
+            /*#__PURE__*/ jsxs("div", {
+                className: "flex flex-wrap items-center gap-2",
+                children: [
+                    /*#__PURE__*/ jsx("span", {
+                        className: "text-xs font-medium text-muted-foreground",
+                        children: t("pe_output_outcome")
+                    }),
+                    /*#__PURE__*/ jsx(Badge, {
+                        status: faulted ? "error" : "info",
+                        variant: "secondary",
+                        children: outcome
+                    }),
+                    null != confidence && /*#__PURE__*/ jsx("span", {
+                        className: "text-xs text-muted-foreground",
+                        children: t("pe_output_confidence", {
+                            percent: confidence
+                        })
+                    })
+                ]
+            }),
+            evaluation.SUMMARY && /*#__PURE__*/ jsx("p", {
+                className: "whitespace-pre-wrap text-sm",
+                children: evaluation.SUMMARY
+            }),
+            faulted && evaluation.ERRORMESSAGE && /*#__PURE__*/ jsx("p", {
+                className: "text-sm text-destructive",
+                children: evaluation.ERRORMESSAGE
+            })
+        ]
+    });
+};
+const CaseEvaluationOutputResult = ({ output })=>{
+    const { t } = useVertexTranslation();
+    if (0 === output.evaluations.length) return /*#__PURE__*/ jsx("p", {
+        className: "text-sm text-muted-foreground",
+        children: t("pe_output_no_evaluations")
+    });
+    return /*#__PURE__*/ jsx("div", {
+        className: "flex min-w-0 flex-col gap-2 whitespace-normal",
+        children: output.evaluations.map((evaluation, i)=>/*#__PURE__*/ jsx(EvaluationCard, {
+                evaluation: evaluation
+            }, i))
+    });
+};
+const CASE_EVALUATION_OUTPUT_RENDERER = makeProcessOutputRenderer(CaseEvaluationOutputSchema, CaseEvaluationOutputResult, {});
+export { CASE_EVALUATION_OUTPUT_RENDERER, CaseEvaluationOutputResult };

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

@@ -0,0 +1,25 @@
+import { z } from "zod";
+/** One Evaluations record echoed by evaluate_case (File-typed fields omitted).
+ * Unknown fields are stripped; only what the renderer shows is modeled. */
+declare const EvaluationRecordSchema: z.ZodObject<{
+    OUTCOME: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    OUTCOMECONFIDENCE: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    SUMMARY: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    STATUS: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    ERRORMESSAGE: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+/** evaluate_case job output. `evaluations` is required so pre-enrichment
+ * outputs (which only carried evaluation ids) fall back to the raw JSON view. */
+export declare const CaseEvaluationOutputSchema: z.ZodObject<{
+    status: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    evaluations: z.ZodArray<z.ZodObject<{
+        OUTCOME: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        OUTCOMECONFIDENCE: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        SUMMARY: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        STATUS: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        ERRORMESSAGE: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CaseEvaluationOutput = z.infer<typeof CaseEvaluationOutputSchema>;
+export type EvaluationRecord = z.infer<typeof EvaluationRecordSchema>;
+export {};

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

@@ -0,0 +1,13 @@
+import { z } from "zod";
+const EvaluationRecordSchema = z.object({
+    OUTCOME: z.string().nullish(),
+    OUTCOMECONFIDENCE: z.number().nullish(),
+    SUMMARY: z.string().nullish(),
+    STATUS: z.string().nullish(),
+    ERRORMESSAGE: z.string().nullish()
+});
+const CaseEvaluationOutputSchema = z.object({
+    status: z.string().nullish(),
+    evaluations: z.array(EvaluationRecordSchema)
+});
+export { CaseEvaluationOutputSchema };

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

@@ -0,0 +1,4 @@
+import type { ProcessOutputProps } from "../registry";
+import { type IxpOutput } from "./schema";
+export declare const IxpOutputResult: ({ output }: ProcessOutputProps<IxpOutput>) => import("react/jsx-runtime").JSX.Element;
+export declare const IXP_OUTPUT_RENDERER: import("../registry").ProcessOutputRenderer;

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

@@ -0,0 +1,98 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useVertexTranslation } from "../../../../lib/vertex-translation.js";
+import { DocumentSection } from "../../ixp/shared/document-section.js";
+import { FieldCell, FieldGroupHeading, FieldRow, FieldTable } from "../../ixp/shared/field-table.js";
+import { formatFieldValues } from "../../ixp/shared/format-values.js";
+import { makeProcessOutputRenderer } from "../registry.js";
+import { IxpOutputSchema } from "./schema.js";
+const IxpOutputResult = ({ output })=>{
+    const { t } = useVertexTranslation();
+    const documents = Object.entries(output.document_extractions);
+    return /*#__PURE__*/ jsxs("div", {
+        className: "flex flex-col gap-4",
+        children: [
+            /*#__PURE__*/ jsx(OutputSummary, {
+                output: output,
+                documentCount: documents.length
+            }),
+            /*#__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_output_no_documents")
+                }) : documents.map(([fileKey, doc])=>/*#__PURE__*/ jsx(DocumentExtractionRow, {
+                        doc: doc
+                    }, fileKey))
+            })
+        ]
+    });
+};
+const OutputSummary = ({ output, documentCount })=>{
+    const { t } = useVertexTranslation();
+    const parts = [
+        t("ixp_output_total_files", {
+            count: output.total_files ?? documentCount
+        })
+    ];
+    if (null != output.classified_count) parts.push(t("ixp_output_classified", {
+        count: output.classified_count
+    }));
+    if (null != output.unclassified_count) parts.push(t("ixp_output_unclassified", {
+        count: output.unclassified_count
+    }));
+    return /*#__PURE__*/ jsx("div", {
+        className: "w-fit rounded-md border bg-muted/30 px-3 py-2 text-xs text-muted-foreground",
+        children: parts.join(" · ")
+    });
+};
+const DocumentExtractionRow = ({ doc })=>{
+    const { t } = useVertexTranslation();
+    const fieldCount = doc.extractions.reduce((total, group)=>total + group.fieldValues.length, 0);
+    return /*#__PURE__*/ jsx(DocumentSection, {
+        title: doc.documentName,
+        summary: /*#__PURE__*/ jsx("span", {
+            className: "text-xs text-muted-foreground",
+            children: t("ixp_output_field_count", {
+                count: fieldCount
+            })
+        }),
+        children: doc.extractions.map((group, i)=>/*#__PURE__*/ jsx(ExtractionGroup, {
+                group: group
+            }, `${group.fieldGroupName}-${i}`))
+    });
+};
+const ExtractionGroup = ({ group })=>{
+    const { t } = useVertexTranslation();
+    return /*#__PURE__*/ jsxs("div", {
+        className: "mt-3 first:mt-0",
+        children: [
+            /*#__PURE__*/ jsx(FieldGroupHeading, {
+                children: group.fieldGroupName
+            }),
+            /*#__PURE__*/ jsx(FieldTable, {
+                columns: [
+                    {
+                        label: t("ixp_field")
+                    },
+                    {
+                        label: t("ixp_value")
+                    }
+                ],
+                children: group.fieldValues.map((field, i)=>/*#__PURE__*/ jsxs(FieldRow, {
+                        children: [
+                            /*#__PURE__*/ jsx(FieldCell, {
+                                className: "font-medium",
+                                children: field.name
+                            }),
+                            /*#__PURE__*/ jsx(FieldCell, {
+                                children: formatFieldValues(field.value)
+                            })
+                        ]
+                    }, `${field.name}-${i}`))
+            })
+        ]
+    });
+};
+const IXP_OUTPUT_RENDERER = makeProcessOutputRenderer(IxpOutputSchema, IxpOutputResult, {});
+export { IXP_OUTPUT_RENDERER, IxpOutputResult };

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

@@ -0,0 +1,62 @@
+import { z } from "zod";
+declare const FieldValueSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    name: z.ZodString;
+    value: z.ZodUnknown;
+    unformattedValue: z.ZodOptional<z.ZodUnknown>;
+    confidence: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    ocrConfidence: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+declare const ExtractionSchema: z.ZodObject<{
+    fieldGroupName: z.ZodString;
+    fieldValues: z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        name: z.ZodString;
+        value: z.ZodUnknown;
+        unformattedValue: z.ZodOptional<z.ZodUnknown>;
+        confidence: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        ocrConfidence: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const DocumentExtractionSchema: z.ZodObject<{
+    documentName: z.ZodString;
+    extractions: z.ZodArray<z.ZodObject<{
+        fieldGroupName: z.ZodString;
+        fieldValues: z.ZodArray<z.ZodObject<{
+            id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            name: z.ZodString;
+            value: z.ZodUnknown;
+            unformattedValue: z.ZodOptional<z.ZodUnknown>;
+            confidence: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            ocrConfidence: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const IxpOutputSchema: z.ZodObject<{
+    document_extractions: z.ZodRecord<z.ZodString, z.ZodObject<{
+        documentName: z.ZodString;
+        extractions: z.ZodArray<z.ZodObject<{
+            fieldGroupName: z.ZodString;
+            fieldValues: z.ZodArray<z.ZodObject<{
+                id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                name: z.ZodString;
+                value: z.ZodUnknown;
+                unformattedValue: z.ZodOptional<z.ZodUnknown>;
+                confidence: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                ocrConfidence: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    total_files: z.ZodOptional<z.ZodNumber>;
+    classified_count: z.ZodOptional<z.ZodNumber>;
+    unclassified_count: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type IxpOutput = z.infer<typeof IxpOutputSchema>;
+export type IxpDocumentExtraction = z.infer<typeof DocumentExtractionSchema>;
+export type IxpExtractionGroup = z.infer<typeof ExtractionSchema>;
+export type IxpFieldValue = z.infer<typeof FieldValueSchema>;
+export {};

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

@@ -0,0 +1,25 @@
+import { z } from "zod";
+const FieldValueSchema = z.object({
+    id: z.string().nullish(),
+    name: z.string(),
+    value: z.unknown(),
+    unformattedValue: z.unknown().optional(),
+    confidence: z.number().nullish(),
+    ocrConfidence: z.number().nullish(),
+    type: z.string().nullish()
+});
+const ExtractionSchema = z.object({
+    fieldGroupName: z.string(),
+    fieldValues: z.array(FieldValueSchema)
+});
+const DocumentExtractionSchema = z.object({
+    documentName: z.string(),
+    extractions: z.array(ExtractionSchema)
+});
+const IxpOutputSchema = z.object({
+    document_extractions: z.record(z.string(), DocumentExtractionSchema),
+    total_files: z.number().optional(),
+    classified_count: z.number().optional(),
+    unclassified_count: z.number().optional()
+});
+export { IxpOutputSchema };

package/dist/registry/solution-tests/outputs/process-output-view.d.ts

@@ -0,0 +1,11 @@
+interface ProcessOutputViewProps {
+    agentId?: string;
+    processName?: string;
+    output: unknown;
+    title?: string;
+    /** "bare" drops the panel chrome for hosts that own it (e.g. a dialog body). */
+    variant?: "panel" | "bare";
+}
+/** One process's output: the registered renderer when one matches, raw JSON otherwise. */
+export declare const ProcessOutputView: ({ agentId, processName, output, title, variant, }: ProcessOutputViewProps) => string | number | bigint | boolean | Iterable<import("react").ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode> | null | undefined> | import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/registry/solution-tests/outputs/process-output-view.js

@@ -0,0 +1,36 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useSolutionTestsConfig } from "../context.js";
+import { JsonPanel, formatJson } from "../evaluators/output-panels.js";
+import { resolveProcessOutputRenderer } from "./registry.js";
+const ProcessOutputView = ({ agentId, processName, output, title, variant = "panel" })=>{
+    const { outputRenderers } = useSolutionTestsConfig();
+    const renderer = resolveProcessOutputRenderer({
+        agentId,
+        processName
+    }, outputRenderers);
+    const rendered = renderer?.({
+        output
+    }) ?? null;
+    if (null == rendered) {
+        if ("bare" === variant) return /*#__PURE__*/ jsx("pre", {
+            className: "whitespace-pre-wrap break-words text-xs",
+            children: formatJson(output)
+        });
+        return /*#__PURE__*/ jsx(JsonPanel, {
+            title: title,
+            data: output
+        });
+    }
+    if ("bare" === variant || null == title) return rendered;
+    return /*#__PURE__*/ jsxs("div", {
+        children: [
+            /*#__PURE__*/ jsx("h4", {
+                className: "mb-2 text-sm font-semibold",
+                children: title
+            }),
+            rendered
+        ]
+    });
+};
+export { ProcessOutputView };

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

@@ -0,0 +1,19 @@
+import type { ComponentType, ReactNode } from "react";
+import type { z } from "zod";
+export interface ProcessOutputRenderArgs {
+    /** Raw, unvalidated output attachment. */
+    output: unknown;
+}
+export type ProcessOutputProps<TOutput = unknown> = {
+    output: TOutput;
+};
+/** Returns `null` when it can't render this output (caller falls back to raw JSON). */
+export type ProcessOutputRenderer = (args: ProcessOutputRenderArgs) => ReactNode;
+/** Keyed by stable agent id (uipath.json#id) or process name. */
+export type ProcessOutputRenderers = Record<string, ProcessOutputRenderer>;
+export declare function makeProcessOutputRenderer<TOutput, TExtra extends object>(schema: z.ZodType<TOutput>, Component: ComponentType<ProcessOutputProps<TOutput> & TExtra>, bound: TExtra): ProcessOutputRenderer;
+/** Precedence mirrors the BE's `get_evaluators_for_process`. */
+export declare function resolveProcessOutputRenderer(source: {
+    agentId?: string;
+    processName?: string;
+}, renderers: ProcessOutputRenderers): ProcessOutputRenderer | undefined;

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

@@ -0,0 +1,19 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+function makeProcessOutputRenderer(schema, Component, bound) {
+    return ({ output })=>{
+        const parsed = schema.safeParse(output);
+        if (!parsed.success) return null;
+        return /*#__PURE__*/ jsx(Component, {
+            output: parsed.data,
+            ...bound
+        });
+    };
+}
+function resolveProcessOutputRenderer(source, renderers) {
+    return [
+        source.agentId,
+        source.processName
+    ].filter((key)=>null != key).map((key)=>renderers[key]).find((renderer)=>null != renderer);
+}
+export { makeProcessOutputRenderer, resolveProcessOutputRenderer };

package/dist/registry/solution-tests/process-results-viewer-dialog.d.ts

@@ -0,0 +1,11 @@
+import type { ReactNode } from "react";
+interface ProcessResultsViewerDialogProps {
+    open: boolean;
+    onClose: () => void;
+    title: string;
+    data: unknown;
+    loading?: boolean;
+    renderData?: (data: unknown) => ReactNode;
+}
+export declare const ProcessResultsViewerDialog: ({ open, onClose, title, data, loading, renderData, }: ProcessResultsViewerDialogProps) => import("react/jsx-runtime").JSX.Element;
+export {};