@barivia/barsom-mcp 0.18.0 → 0.19.0

package/dist/tools/training_prep.js

@@ -1,572 +0,0 @@
-import { z } from "zod";
-import { registerAppTool } from "@modelcontextprotocol/ext-apps/server";
-import { registerAuditedTool, runMcpToolAudit } from "../audit.js";
-import { apiCall, fetchTrainingGuidanceFromApi, getClientSupportsMcpApps, getVizPort, pollUntilComplete, POLL_DERIVE_MAX_MS, structuredTextResult, } from "../shared.js";
-import { buildTrainMapParams, buildFloopParams, fetchTrainingConfig, } from "./training_core.js";
-import { attachTrainingReviewPayload, consumeTrainingReview, getTrainingReview, storeTrainingReview, } from "./training_review_store.js";
-export const TRAINING_PREP_URI = "ui://barsom/training-prep";
-/**
- * Fetch column analysis the same way datasets(action=analyze) does: enqueue the
- * async sampled analyze job, poll, then read the summary. Falls back to the legacy
- * synchronous GET on older APIs (404). Analysis is advisory in prep, so a job that
- * is still running / failed degrades to an empty analysis (preview + presets still
- * render) rather than failing the whole prep call.
- */
-async function fetchAnalyzeData(datasetId) {
-    try {
-        const submit = (await apiCall("POST", `/v1/datasets/${datasetId}/analyze`));
-        const jobId = (submit.id ?? submit.job_id);
-        if (!jobId)
-            return {};
-        const poll = await pollUntilComplete(jobId, POLL_DERIVE_MAX_MS);
-        if (poll.status !== "completed")
-            return {};
-        const results = (await apiCall("GET", `/v1/results/${jobId}`));
-        return (results.summary ?? results);
-    }
-    catch (err) {
-        if (err?.httpStatus === 404) {
-            return (await apiCall("GET", `/v1/datasets/${datasetId}/analyze`));
-        }
-        throw err;
-    }
-}
-function getNumericColumns(preview) {
-    const stats = preview.column_stats ?? [];
-    return stats
-        .filter((stat) => stat.is_numeric !== false)
-        .map((stat) => String(stat.column ?? ""))
-        .filter(Boolean);
-}
-function getLikelyIdColumns(preview) {
-    const stats = preview.column_stats ?? [];
-    const totalRows = Number(preview.total_rows ?? 0);
-    if (totalRows <= 0)
-        return [];
-    return stats
-        .filter((stat) => stat.is_numeric !== false)
-        .filter((stat) => {
-        const mn = Number(stat.min);
-        const mx = Number(stat.max);
-        const colName = String(stat.column ?? "").toLowerCase();
-        const nameHint = /^(id|index|instant|row_?num|serial|record|obs)$/i.test(colName)
-            || colName.endsWith("_id")
-            || colName.startsWith("id_");
-        return ((mn === 0 || mn === 1) &&
-            mx >= totalRows * 0.9 &&
-            mx <= totalRows * 1.1 &&
-            Number(stat.null_count ?? 0) === 0 &&
-            nameHint);
-    })
-        .map((stat) => String(stat.column ?? ""))
-        .filter(Boolean);
-}
-function getRecommendedTrainColumns(preview, analyze) {
-    const recommendations = analyze.recommendations ?? {};
-    const recommended = (recommendations.train ?? []).filter(Boolean);
-    if (recommended.length > 0)
-        return recommended;
-    const numeric = getNumericColumns(preview);
-    const likelyId = new Set(getLikelyIdColumns(preview));
-    return numeric.filter((column) => !likelyId.has(column));
-}
-function getEpochFields(params) {
-    const epochs = params.epochs;
-    if (Array.isArray(epochs) && epochs.length >= 2) {
-        return {
-            ordering: String(epochs[0] ?? ""),
-            convergence: String(epochs[1] ?? ""),
-        };
-    }
-    if (typeof epochs === "number") {
-        return {
-            ordering: String(epochs),
-            convergence: "",
-        };
-    }
-    return { ordering: "", convergence: "" };
-}
-async function fetchPreparePrompt(datasetId) {
-    try {
-        const data = (await apiCall("GET", `/v1/docs/prepare_training?dataset_id=${datasetId}`));
-        if (typeof data.prompt === "string" && data.prompt.trim()) {
-            return data.prompt.trim();
-        }
-    }
-    catch {
-        // Best effort only.
-    }
-    return null;
-}
-const TOOL_SYNTAX_RE = /\(action=|dataset_id=|job_id=|datasets\(|jobs\(/;
-function buildWarnings(preview, selectedColumns, params, analyze) {
-    const warnings = [];
-    const stats = preview.column_stats ?? [];
-    const statByColumn = new Map(stats.map((stat) => [String(stat.column ?? ""), stat]));
-    for (const column of selectedColumns) {
-        const stat = statByColumn.get(column);
-        if (!stat)
-            continue;
-        if (stat.is_numeric === false) {
-            warnings.push(`${column} is not numeric in preview and should not be used directly for training.`);
-        }
-        if (Number(stat.null_count ?? 0) > 0) {
-            warnings.push(`${column} has ${stat.null_count} null values. Training columns must not contain missing values.`);
-        }
-    }
-    const totalRows = Number(preview.total_rows ?? 0);
-    const grid = params.grid;
-    if (grid && totalRows > 0 && grid[0] * grid[1] > totalRows * 0.75) {
-        warnings.push(`Grid ${grid[0]}×${grid[1]} may be large for ${totalRows} rows, which can create many dead nodes.`);
-    }
-    const recommendations = analyze.recommendations ?? {};
-    const consideredDrop = recommendations.consider_dropping ?? [];
-    const overlappingDrop = consideredDrop.filter((column) => selectedColumns.includes(column));
-    if (overlappingDrop.length > 0) {
-        warnings.push(`Some selected columns are highly correlated and may be redundant: ${overlappingDrop.join(", ")}.`);
-    }
-    const rawCategoricals = stats
-        .filter((stat) => stat.is_numeric === false)
-        .map((stat) => String(stat.column ?? ""))
-        .filter(Boolean);
-    if (rawCategoricals.length > 0) {
-        const shown = rawCategoricals.slice(0, 5).join(", ");
-        const suffix = rawCategoricals.length > 5 ? ", ..." : "";
-        warnings.push(`Raw categorical/text columns detected: ${shown}${suffix}. Exclude them by default or use baseline categorical_features explicitly.`);
-    }
-    return warnings;
-}
-function buildDataRecommendations(analyze) {
-    const recommendations = [];
-    const dataRec = analyze.recommendations ?? {};
-    if ((dataRec.project_later ?? []).length > 0) {
-        recommendations.push(`Project later after training: ${(dataRec.project_later ?? []).join(", ")}.`);
-    }
-    if ((dataRec.low_variance ?? []).length > 0) {
-        recommendations.push(`Low-variance columns can usually be excluded: ${(dataRec.low_variance ?? []).join(", ")}.`);
-    }
-    return recommendations;
-}
-function buildGuidanceLines(guidanceText) {
-    const lines = [];
-    for (const line of guidanceText.split("\n")) {
-        const trimmed = line.replace(/^-\s*/, "").trim();
-        if (trimmed &&
-            !trimmed.startsWith("Parameter guidance") &&
-            !trimmed.startsWith("Presets:") &&
-            !TOOL_SYNTAX_RE.test(trimmed)) {
-            lines.push(trimmed);
-        }
-        if (lines.length >= 4)
-            break;
-    }
-    return [...new Set(lines)];
-}
-function buildSuggestedNormalizationMethods(analyze) {
-    const hints = analyze.normalization_hints;
-    if (!hints || typeof hints !== "object")
-        return undefined;
-    const out = {};
-    for (const [col, hint] of Object.entries(hints)) {
-        if (hint === "mad" || hint === "sepd") {
-            out[col] = hint;
-        }
-    }
-    return Object.keys(out).length > 0 ? out : undefined;
-}
-function buildSuggestedTransforms(analyze) {
-    const hints = analyze.normalization_hints;
-    if (!hints || typeof hints !== "object")
-        return undefined;
-    const out = {};
-    for (const [col, hint] of Object.entries(hints)) {
-        if (hint === "log_then_zscore") {
-            out[col] = "log";
-        }
-    }
-    return Object.keys(out).length > 0 ? out : undefined;
-}
-/** Prep action -> (entitlement job type, review store action, display label). */
-const PREP_ACTION_META = {
-    map: { jobType: "train_som", storeAction: "train_map", label: "Map (standard SOM)" },
-    siom_map: { jobType: "train_siom", storeAction: "train_siom", label: "SIOM map" },
-    impute: { jobType: "train_impute", storeAction: "train_impute", label: "Impute (sparse → map + imputed.csv)" },
-    floop_siom: { jobType: "train_floop_siom", storeAction: "train_floop_siom", label: "FLooP-SIOM (growing manifold)" },
-};
-function buildTrainActionOptions(allowedJobTypes) {
-    const allowed = new Set(allowedJobTypes);
-    // map is always available (train_som is the baseline entitlement); gate siom/impute.
-    return Object.keys(PREP_ACTION_META)
-        .filter((action) => action === "map" || allowed.size === 0 || allowed.has(PREP_ACTION_META[action].jobType))
-        .map((action) => ({ value: action, label: PREP_ACTION_META[action].label }));
-}
-/**
- * Apply the action-specific job-type + knobs onto the params built by
- * buildTrainMapParams (mirrors the train tool's runTrain for map/siom/impute).
- */
-function applyPrepActionParams(action, params, input) {
-    if (action === "siom_map") {
-        params._job_type = "train_siom";
-    }
-    else if (action === "impute") {
-        params._job_type = "train_impute";
-        params.model = input.model ?? "auto";
-        params.cv_folds = 5;
-        // impute does not accept these (mirror train.ts) and rejects sepd (warned separately).
-        delete params.categorical_features;
-        delete params.auto_log_transforms;
-        delete params.time_delay_embeddings;
-    }
-}
-/** Effective per-column normalization method, mirroring the worker/auto policy. */
-function resolveColumnNormalization(column, normalize, methods, isCyclic) {
-    if (isCyclic)
-        return "cyclic_encoding";
-    if (methods && methods[column])
-        return methods[column];
-    if (typeof normalize === "string") {
-        if (normalize === "mad" || normalize === "sigmoidal" || normalize === "sepd")
-            return normalize;
-        return "zscore"; // auto / all -> z-score on non-cyclic numerics
-    }
-    return "zscore";
-}
-function normalizationDetail(method, stat, staging) {
-    const fmt = (v) => (v === null || v === undefined ? "?" : Number(v).toFixed(3));
-    const nulls = staging?.null_count ?? stat?.null_count;
-    const nullBit = nulls !== undefined && nulls !== null ? ` [nulls=${nulls}]` : "";
-    switch (method) {
-        case "zscore":
-            return `z-score · mean=${fmt(stat?.mean)}, std=${fmt(stat?.std)}${nullBit}`;
-        case "mad":
-            return `MAD (robust to heavy tails) · min=${fmt(stat?.min)}, max=${fmt(stat?.max)}${nullBit}`;
-        case "sigmoidal":
-            return `sigmoidal (logistic squashing of mean=${fmt(stat?.mean)}, std=${fmt(stat?.std)})${nullBit}`;
-        case "sepd":
-            return `SEPD (skewed exponential power; for skewed financial/policy columns)${nullBit}`;
-        case "none":
-            return `none (raw values)${nullBit}`;
-        case "cyclic_encoding":
-            return `cyclic (encoded as cos/sin, not separately normalized)`;
-        default:
-            return `${method}${nullBit}`;
-    }
-}
-function buildNormalizationPlan(selectedColumns, params, preview, analyze) {
-    const statByColumn = new Map((preview.column_stats ?? []).map((s) => [String(s.column ?? ""), s]));
-    const stagingStats = analyze.column_staging_stats ?? {};
-    const methods = params.normalization_methods;
-    const cyclicNames = new Set((params.cyclic_features ?? []).map((c) => c.feature));
-    return selectedColumns.map((column) => {
-        const method = resolveColumnNormalization(column, params.normalize, methods, cyclicNames.has(column));
-        return {
-            column,
-            method,
-            detail: normalizationDetail(method, statByColumn.get(column), stagingStats[column]),
-        };
-    });
-}
-async function buildTrainingPrepPayload(datasetId, input, trainAction) {
-    const [preview, analyze, config, guidanceText, preparePrompt] = await Promise.all([
-        apiCall("GET", `/v1/datasets/${datasetId}/preview?n_rows=5`),
-        fetchAnalyzeData(datasetId),
-        fetchTrainingConfig().catch(() => ({ presets: {}, allowedJobTypes: [] })),
-        fetchTrainingGuidanceFromApi().catch(() => "No training guidance available."),
-        fetchPreparePrompt(datasetId),
-    ]);
-    const presets = config.presets;
-    const selectedColumns = input.columns?.length
-        ? input.columns
-        : getRecommendedTrainColumns(preview, analyze);
-    const resolvedInput = { ...input, columns: selectedColumns };
-    const isFloop = trainAction === "floop_siom";
-    const params = isFloop
-        ? buildFloopParams(resolvedInput).params
-        : buildTrainMapParams(resolvedInput, presets).params;
-    if (!isFloop)
-        applyPrepActionParams(trainAction, params, resolvedInput);
-    const normalizationPlan = buildNormalizationPlan(selectedColumns, params, preview, analyze);
-    const review = storeTrainingReview(datasetId, params, PREP_ACTION_META[trainAction].storeAction);
-    const recommendations = analyze.recommendations ?? {};
-    const projectLater = recommendations.project_later ?? [];
-    const transforms = Object.entries(params.transforms ?? {})
-        .map(([feature, transform]) => `${feature}: ${transform}`);
-    if (params.auto_log_transforms === true) {
-        transforms.push("Auto log transforms: enabled");
-    }
-    const cyclic = (params.cyclic_features ?? [])
-        .map((feature) => `${feature.feature} (period ${feature.period})`);
-    const temporal = (params.temporal_features ?? [])
-        .map((feature) => {
-        const columns = feature.columns ?? [];
-        const extract = feature.extract ?? [];
-        return `${columns.join(" + ")} -> ${extract.join(", ")}`;
-    });
-    const epochs = getEpochFields(params);
-    const grid = params.grid ?? [];
-    const warnings = buildWarnings(preview, selectedColumns, params, analyze);
-    if (trainAction === "impute") {
-        const sepdCols = normalizationPlan.filter((n) => n.method === "sepd").map((n) => n.column);
-        if (params.normalize === "sepd" || sepdCols.length > 0) {
-            warnings.push(`SEPD normalization is not allowed for impute (train(impute) rejects sepd)${sepdCols.length ? `: ${sepdCols.join(", ")}` : ""}. Switch these columns to mad/zscore before submit.`);
-        }
-    }
-    const suggestedNormalizationMethods = buildSuggestedNormalizationMethods(analyze);
-    const suggestedTransforms = buildSuggestedTransforms(analyze);
-    const recommendationLines = buildDataRecommendations(analyze);
-    if (suggestedNormalizationMethods) {
-        recommendationLines.push("Suggested normalization_methods (confirm before submit): " +
-            JSON.stringify(suggestedNormalizationMethods) +
-            " — see training_guidance for MAD vs SEPD ladder. train(impute) rejects sepd.");
-    }
-    if (suggestedTransforms) {
-        recommendationLines.push("Suggested transforms before normalization (confirm before submit): " +
-            JSON.stringify(suggestedTransforms) +
-            " — rank is train-only (no inference); not for train(impute).");
-    }
-    const guidanceLines = buildGuidanceLines(guidanceText);
-    const datasetName = String(preview.name ?? datasetId);
-    const sections = [
-        {
-            label: "Variables",
-            items: selectedColumns.length > 0 ? selectedColumns : ["No variables selected yet."],
-        },
-        {
-            label: "Projection Candidates",
-            items: projectLater.length > 0
-                ? [...projectLater, "(These columns are good candidates for post-training projection onto the map.)"]
-                : ["None"],
-        },
-        {
-            label: "Preprocessing / Normalization (per column)",
-            items: normalizationPlan.length > 0
-                ? [
-                    ...normalizationPlan.map((n) => `${n.column}: ${n.method} — ${n.detail}`),
-                    "Tweak via normalization_methods (per column) or a global normalize; changing these reruns preprocessing (new recipe) on the next submit.",
-                ]
-                : ["No training columns resolved yet."],
-        },
-        {
-            label: "Transformations",
-            items: transforms.length > 0 ? transforms : ["None"],
-        },
-        {
-            label: "Encodings",
-            items: [...cyclic, ...temporal].length > 0 ? [...cyclic, ...temporal] : ["None"],
-        },
-        {
-            label: "Hyperparameters",
-            items: isFloop
-                ? [
-                    `Variant: FLooP-SIOM (growing manifold — no fixed grid/epochs)`,
-                    `Topology: ${String(params.topology ?? "free")}`,
-                    `Max nodes: ${params.max_nodes !== undefined ? String(params.max_nodes) : "auto (~2·√n_samples)"}`,
-                    `Effort: ${String(params.effort ?? "standard")}`,
-                    params.gamma !== undefined ? `Gamma: ${String(params.gamma)}` : "",
-                    params.siom_decay !== undefined ? `SIOM decay: ${String(params.siom_decay)}` : "",
-                    `Normalize: ${Array.isArray(params.normalize) ? params.normalize.join(", ") : String(params.normalize ?? "auto")}`,
-                    `Output: ${String(params.output_format ?? "png")}`,
-                ].filter(Boolean)
-                : [
-                    `Model: ${String(params.model ?? "SOM")}`,
-                    `Grid: ${grid.length >= 2 ? `${grid[0]}×${grid[1]}` : "auto"}`,
-                    `Epochs: ${epochs.ordering || "auto"}${epochs.convergence ? ` + ${epochs.convergence}` : ""}`,
-                    `Backend: ${String(params.backend ?? "auto")}`,
-                    `Normalize: ${Array.isArray(params.normalize) ? params.normalize.join(", ") : String(params.normalize ?? "auto")}`,
-                    `Output: ${String(params.output_format ?? "png")}`,
-                ],
-        },
-    ];
-    const port = getVizPort();
-    const standaloneUrl = port ? `http://localhost:${port}/viz/training-prep?mode=standalone&review_token=${review.reviewToken}` : undefined;
-    const payload = {
-        type: "training-prep",
-        datasetId,
-        datasetName,
-        reviewId: review.reviewId,
-        reviewToken: review.reviewToken,
-        reviewExpiresAt: new Date(review.expiresAt).toISOString(),
-        trainAction,
-        selectedColumns,
-        suggestedProjectionColumns: projectLater,
-        normalizationPlan,
-        suggestedNormalizationMethods,
-        warnings,
-        recommendations: recommendationLines,
-        guidance: guidanceLines,
-        sections,
-        editable: {
-            values: {
-                preset: input.preset,
-                backend: String(params.backend ?? input.backend ?? "auto"),
-                outputFormat: String(params.output_format ?? input.output_format ?? "png"),
-                model: String(params.model ?? input.model ?? "SOM"),
-                gridX: grid.length >= 2 ? String(grid[0]) : "",
-                gridY: grid.length >= 2 ? String(grid[1]) : "",
-                epochsOrdering: epochs.ordering,
-                epochsConvergence: epochs.convergence,
-                trainAction,
-                columns: selectedColumns.join(", "),
-                normalizationMethodsJson: params.normalization_methods
-                    ? JSON.stringify(params.normalization_methods)
-                    : "",
-                transformsJson: params.transforms ? JSON.stringify(params.transforms) : "",
-            },
-            options: {
-                presetOptions: Object.keys(presets).map((value) => ({ value, label: value.replace("_", " ") })),
-                backendOptions: [
-                    { value: "auto", label: "Auto" },
-                    { value: "cpu", label: "CPU" },
-                    { value: "gpu", label: "GPU" },
-                    { value: "gpu_graphs", label: "GPU Graphs" },
-                ],
-                outputFormatOptions: [
-                    { value: "png", label: "PNG" },
-                    { value: "pdf", label: "PDF" },
-                    { value: "svg", label: "SVG" },
-                ],
-                modelOptions: [
-                    { value: "SOM", label: "SOM" },
-                    { value: "RSOM", label: "RSOM" },
-                    { value: "SOM-SOFT", label: "SOM-SOFT" },
-                    { value: "RSOM-SOFT", label: "RSOM-SOFT" },
-                ],
-                trainActionOptions: buildTrainActionOptions(config.allowedJobTypes),
-            },
-        },
-        draftArgs: {
-            ...resolvedInput,
-            periodic: params.periodic,
-            normalize: params.normalize,
-            columns: selectedColumns,
-            output_format: params.output_format,
-        },
-        summaryLines: [
-            `Dataset: ${datasetName}`,
-            `Action: ${PREP_ACTION_META[trainAction].label}`,
-            `Variables: ${selectedColumns.length > 0 ? selectedColumns.join(", ") : "Not selected"}`,
-            isFloop
-                ? `Topology: ${String(params.topology ?? "free")} | Max nodes: ${params.max_nodes !== undefined ? String(params.max_nodes) : "auto"} | Effort: ${String(params.effort ?? "standard")}`
-                : `Grid: ${grid.length >= 2 ? `${grid[0]}×${grid[1]}` : "auto"} | Model: ${String(params.model ?? "SOM")} | Backend: ${String(params.backend ?? "auto")} | Output: ${String(params.output_format ?? "png")}`,
-            `Normalization: ${normalizationPlan.length > 0 ? normalizationPlan.map((n) => `${n.column}→${n.method}`).join(", ") : "auto"}`,
-        ],
-        standaloneUrl,
-    };
-    attachTrainingReviewPayload(review.reviewToken, payload);
-    return payload;
-}
-function buildTrainingPrepContent(payload) {
-    const normalizationBlock = payload.normalizationPlan.length > 0
-        ? [
-            "",
-            "Preprocessing / normalization plan (per column — review before submit):",
-            ...payload.normalizationPlan.map((n) => `  • ${n.column}: ${n.method} — ${n.detail}`),
-            "To change: re-call training_prep with normalization_methods (per column) and/or normalize/transforms; that reruns preprocessing on submit. Show this to the user and confirm before submit_prepared_training.",
-        ]
-        : [];
-    const content = [
-        {
-            type: "text",
-            text: [
-                `Training prep ready for ${payload.datasetName} (${payload.datasetId}).`,
-                `Review ID: ${payload.reviewId} | Review token: ${payload.reviewToken ?? "(none)"}`,
-                ...payload.summaryLines,
-                payload.warnings.length > 0 ? `Warnings: ${payload.warnings.join(" | ")}` : "",
-                ...normalizationBlock,
-                "",
-                `When the user has confirmed, submit with submit_prepared_training(review_token="${payload.reviewToken ?? ""}", explicit_confirm=true).`,
-            ].filter(Boolean).join("\n"),
-        },
-    ];
-    if (!getClientSupportsMcpApps() && payload.standaloneUrl) {
-        content.push({
-            type: "text",
-            text: `Interactive review: ${payload.standaloneUrl}\nOpen this URL in your browser to review and submit the prepared job.`,
-        });
-    }
-    return content;
-}
-export function registerTrainingPrepTools(server) {
-    const trainPrepSchema = {
-        dataset_id: z.string().describe("Dataset ID to prepare for training"),
-        train_action: z.enum(["map", "siom_map", "impute", "floop_siom"]).optional().default("map")
-            .describe("Which training mode to prepare: map (standard SOM), siom_map (self-interacting), impute (sparse → map + imputed.csv), or floop_siom (growing node-budget manifold). Filtered to your plan's allowed_job_types."),
-        preset: z.enum(["quick", "standard", "refined", "high_res"]).optional(),
-        grid_x: z.number().int().optional(),
-        grid_y: z.number().int().optional(),
-        epochs: z.union([z.number().int(), z.array(z.number().int()).length(2)]).optional(),
-        model: z.enum(["SOM", "RSOM", "SOM-SOFT", "RSOM-SOFT"]).optional(),
-        periodic: z.boolean().optional().default(true),
-        columns: z.array(z.string()).optional(),
-        cyclic_features: z.array(z.object({
-            feature: z.string(),
-            period: z.number(),
-        })).optional(),
-        temporal_features: z.array(z.object({
-            columns: z.array(z.string()),
-            format: z.string(),
-            extract: z.array(z.enum(["hour_of_day", "day_of_year", "month", "day_of_week", "minute_of_hour"])),
-            cyclic: z.boolean().default(true),
-            separator: z.string().optional(),
-        })).optional(),
-        feature_weights: z.record(z.number()).optional(),
-        transforms: z.record(z.enum(["log", "log1p", "log10", "sqrt", "square", "abs", "invert", "rank", "none"])).optional(),
-        auto_log_transforms: z.boolean().optional().default(false),
-        normalize: z.union([z.enum(["all", "auto", "mad", "sigmoidal", "sepd"]), z.array(z.string())]).optional().default("auto"),
-        normalization_methods: z.record(z.enum(["zscore", "mad", "sigmoidal", "sepd", "none"])).optional(),
-        batch_size: z.number().int().optional(),
-        backend: z.enum(["auto", "cpu", "gpu", "gpu_graphs"]).optional().default("auto"),
-        output_format: z.enum(["png", "pdf", "svg"]).optional().default("png"),
-        row_range: z.tuple([z.number().int().min(1), z.number().int().min(1)]).optional(),
-        siom_feature_geometry: z.enum(["l2", "mixed", "auto"]).optional(),
-        siom_qe_backend: z.enum(["cpu", "cuda", "auto"]).optional(),
-        siom_qe_batch_size: z.number().int().min(1).max(1_000_000).optional(),
-        // FLooP-SIOM (train_action=floop_siom) — growing manifold; no fixed grid/epochs.
-        topology: z.enum(["free", "chain"]).optional(),
-        max_nodes: z.number().int().min(2).optional(),
-        effort: z.enum(["quick", "standard", "thorough"]).optional(),
-        n_initial: z.number().int().min(2).optional(),
-        n_passes: z.number().int().min(1).optional(),
-        growth_interval: z.number().int().min(1).optional(),
-        gamma: z.number().optional(),
-        siom_decay: z.number().optional(),
-        siom_penalty: z.enum(["linear", "log", "exp"]).optional(),
-        penalty_alpha: z.number().optional(),
-        elastic_lambda: z.number().optional(),
-        elastic_mu: z.number().optional(),
-        elastic_anchor: z.number().optional(),
-    };
-    registerAppTool(server, "training_prep", {
-        title: "Training Preparation",
-        description: "Interactive training prep UI + guarded submit (submit_prepared_training). Shows the RESOLVED decisions before a job is committed: per-column normalization (z-score / MAD / SEPD / sigmoidal) with its stat, transforms, encodings, grid/epochs/model. Tweak normalization_methods, transforms, columns, or train_action and re-call to iterate preprocessing before submitting. Prep ladder: prepare_training prompt = narrative checklist; training_guidance tool = JSON/presets; this tool = visual review + guarded submit.",
-        inputSchema: trainPrepSchema,
-        _meta: { ui: { resourceUri: TRAINING_PREP_URI } },
-    }, async ({ dataset_id, train_action, ...args }) => runMcpToolAudit("training_prep", "default", { dataset_id, train_action, ...args }, async () => {
-        const payload = await buildTrainingPrepPayload(dataset_id, args, (train_action ?? "map"));
-        return structuredTextResult(payload, undefined, buildTrainingPrepContent(payload));
-    }));
-    registerAuditedTool(server, "submit_prepared_training", "Submit a previously reviewed training-prep configuration. Requires an unexpired review token and explicit confirmation.", {
-        review_token: z.string().describe("Review token returned inside training_prep structured content."),
-        explicit_confirm: z.boolean().describe("Must be true to submit the reviewed training job."),
-    }, async ({ review_token, explicit_confirm }) => {
-        if (!explicit_confirm) {
-            throw new Error("submit_prepared_training requires explicit_confirm=true.");
-        }
-        const review = getTrainingReview(review_token);
-        if (!review) {
-            throw new Error("Review token is missing, expired, or already used. Re-open training_prep and confirm again.");
-        }
-        const data = (await apiCall("POST", "/v1/jobs", {
-            dataset_id: review.datasetId,
-            params: review.params,
-        }));
-        consumeTrainingReview(review_token);
-        const jobId = String(data.id ?? "");
-        return structuredTextResult({
-            type: "prepared-training-submitted",
-            datasetId: review.datasetId,
-            jobId,
-            message: `Training job submitted from reviewed prep. Poll with jobs(action=status, job_id="${jobId}").`,
-        }, `Training job submitted from reviewed prep. Job ID: ${jobId}\nPoll with jobs(action=status, job_id="${jobId}") until complete, then use results(action=get, job_id="${jobId}").`);
-    });
-}

package/dist/tools/training_review_store.js

@@ -1,53 +0,0 @@
-const REVIEW_TTL_MS = 15 * 60 * 1000;
-const reviews = new Map();
-function createToken() {
-    return `${Math.random().toString(36).slice(2, 10)}${Math.random().toString(36).slice(2, 10)}`;
-}
-function createReviewId() {
-    return Math.random().toString(36).slice(2, 10);
-}
-function pruneExpired() {
-    const now = Date.now();
-    for (const [token, review] of reviews.entries()) {
-        if (review.expiresAt <= now) {
-            reviews.delete(token);
-        }
-    }
-}
-export function storeTrainingReview(datasetId, params, trainAction = "train_map") {
-    pruneExpired();
-    const createdAt = Date.now();
-    const review = {
-        reviewId: createReviewId(),
-        reviewToken: createToken(),
-        datasetId,
-        trainAction,
-        params,
-        createdAt,
-        expiresAt: createdAt + REVIEW_TTL_MS,
-    };
-    reviews.set(review.reviewToken, review);
-    return review;
-}
-export function attachTrainingReviewPayload(reviewToken, payload) {
-    pruneExpired();
-    const review = reviews.get(reviewToken);
-    if (!review)
-        return;
-    review.payload = payload;
-}
-export function getTrainingReview(reviewToken) {
-    pruneExpired();
-    const review = reviews.get(reviewToken);
-    if (!review)
-        return null;
-    return review;
-}
-export function consumeTrainingReview(reviewToken) {
-    pruneExpired();
-    const review = reviews.get(reviewToken);
-    if (!review)
-        return null;
-    reviews.delete(reviewToken);
-    return review;
-}