@barivia/barsom-mcp 0.20.1 → 0.20.3

package/README.md

@@ -29,7 +29,7 @@ MCP clients typically run it with **`npx`** (downloads on first use):
 
 **Audit logging (0.10.3+):** Each tool invocation emits a structured **`mcp_tool_call`** line on stderr for support correlation — not sent to the Barivia API. Fields: `tool`, `action`, `duration_ms`, `outcome`, **`rid`** (matches API `X-Request-ID`), **`job_id`** / **`dataset_id`** when the action returns or accepts them, scale hints **`grid_x`** / **`grid_y`** on training submits, and **`timeout_hit`** / **`output_truncated`** when proxy fetch/output limits apply. No API keys or file paths. Grep client stderr alongside API/worker logs by `rid`; see `docs/OPERATIONS_MANUAL.md` §5b.
 
-**Also available:** hosted HTTP MCP at **`https://mcp.barivia.se/mcp`** (same API key; no npm) for clients that support remote MCP.
+**Hosted HTTP MCP paused (2026-06):** `https://mcp.barivia.se/mcp` returns **503** (`hosted_mcp_paused`). Use this npm package only.
 
 **Cursor / multi-account note:** Cursor's tool dispatcher resolves tools under a `serverIdentifier` (e.g. `user-barivia-bbb-maps`), which can differ from the key you wrote in `mcp.json` (e.g. `barivia-bbb-maps`). If a tool call fails with **"server does not exist"** or similar, list the resolved identifier with your client's tool inspector (`mcp.list-tools` or equivalent) and use that identifier — not the `mcp.json` key.
 

package/dist/job_monitor.js

@@ -91,7 +91,7 @@ export function formatSnapshotLine(s) {
     if (s.qe != null)
         parts.push(`QE ${s.qe.toFixed(4)}`);
     if (s.te != null)
-        parts.push(`TE ${s.te.toFixed(4)}`);
+        parts.push(`Epoch TE ${s.te.toFixed(4)}`);
     if (s.eta_sec != null)
         parts.push(`ETA ~${s.eta_sec}s`);
     if (s.ordering_errors_tail?.length) {

package/dist/shared.js

@@ -26,7 +26,7 @@ export const RETRYABLE_STATUS = new Set([502, 503, 504]);
  * X-Barsom-Client-Version so the server can annotate tool guidance with the
  * wrapper version each action requires. Keep in sync with package.json on bump.
  */
-export const CLIENT_VERSION = "0.20.1";
+export const CLIENT_VERSION = "0.20.3";
 /** User-facing links; keep aligned with barivia.se / api.barivia.se. */
 export const PUBLIC_SITE_ORIGIN = "https://barivia.se";
 /** Self-serve account dashboard (manage plan, billing, and API keys). */

package/dist/tools/explore_map.js

@@ -157,7 +157,10 @@ async function handleResultsExplorer(job_id) {
                 `This localhost port is assigned per MCP session and changes if the proxy restarts — if the page won't load, re-run results_explorer for a fresh URL, or set BARIVIA_VIZ_PORT in your MCP env for a persistent port.`,
         });
     }
-    return structuredTextResult(payload, undefined, content);
+    return {
+        ...structuredTextResult(payload, undefined, content),
+        _meta: { ui: { resourceUri: RESULTS_EXPLORER_URI } },
+    };
 }
 export function registerExploreMapTool(server) {
     const toolConfig = {

package/dist/tools/training_monitor.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { registerAppTool } from "@modelcontextprotocol/ext-apps/server";
 import { runMcpToolAudit } from "../audit.js";
 import { apiCall, getClientSupportsMcpApps, getVizPort, structuredTextResult, } from "../shared.js";
+import { lastEpochTeFromCurves, snapTeCurvesToMapTe } from "../training_monitor_curve.js";
 export const TRAINING_MONITOR_URI = "ui://barsom/training-monitor";
 export const TRAINING_MONITOR_REFRESH_MS = 5000;
 function hasCurveArrays(data) {
@@ -24,31 +25,60 @@ function buildStructuredContent(job_id, data) {
         refresh_interval_ms: TRAINING_MONITOR_REFRESH_MS,
     };
 }
+function hasTeCurveArrays(data) {
+    return ((Array.isArray(data.ordering_topographic_errors) &&
+        data.ordering_topographic_errors.length > 0) ||
+        (Array.isArray(data.convergence_topographic_errors) &&
+            data.convergence_topographic_errors.length > 0));
+}
+function needsTrainingLogEnrichment(data) {
+    const status = String(data.status ?? "");
+    if (status !== "completed" && status !== "failed" && status !== "cancelled")
+        return false;
+    if (!hasCurveArrays(data))
+        return true;
+    if (!hasTeCurveArrays(data))
+        return true;
+    if (data.map_topographic_error == null && data.topographic_error == null)
+        return true;
+    return false;
+}
 async function enrichWithTrainingLog(job_id, data) {
     const status = String(data.status ?? "");
-    if (status !== "completed" && status !== "failed")
-        return data;
-    if (hasCurveArrays(data))
+    if (status !== "completed" && status !== "failed" && status !== "cancelled")
         return data;
+    const epochTe = data.epoch_topographic_error ??
+        data.topographic_error ??
+        lastEpochTeFromCurves(data);
     try {
         const log = (await apiCall("GET", `/v1/results/${job_id}/training-log`));
-        return {
+        const merged = {
             ...data,
             ordering_errors: log.ordering_errors ?? data.ordering_errors,
             convergence_errors: log.convergence_errors ?? data.convergence_errors,
             ordering_topographic_errors: log.ordering_topographic_errors ?? data.ordering_topographic_errors,
             convergence_topographic_errors: log.convergence_topographic_errors ?? data.convergence_topographic_errors,
             quantization_error: log.quantization_error ?? data.quantization_error,
-            topographic_error: log.topographic_error ?? data.topographic_error,
             grid: log.grid ?? data.grid,
             model: log.model ?? data.model,
             epochs: log.epochs ?? data.epochs,
             n_samples: log.n_samples ?? data.n_samples,
             n_features: log.n_features ?? data.n_features,
+            training_curve_source_batches: log.training_curve_source_batches ?? data.training_curve_source_batches,
         };
+        const mapTe = log.topographic_error ?? data.map_topographic_error ?? data.topographic_error;
+        merged.epoch_topographic_error = epochTe ?? lastEpochTeFromCurves(merged);
+        merged.map_topographic_error = mapTe;
+        if (status === "completed" || status === "failed" || status === "cancelled") {
+            merged.topographic_error = mapTe;
+        }
+        return snapTeCurvesToMapTe(merged);
     }
     catch {
-        return data;
+        if (epochTe != null) {
+            return snapTeCurvesToMapTe({ ...data, epoch_topographic_error: epochTe });
+        }
+        return data.kernel_complete === true ? snapTeCurvesToMapTe(data) : data;
     }
 }
 export function registerTrainingMonitorTool(server) {
@@ -67,8 +97,7 @@ export function registerTrainingMonitorTool(server) {
         const { job_id, fetch_training_log } = args;
         let data = (await apiCall("GET", `/v1/jobs/${job_id}`));
         const jobStatus = String(data.status ?? "");
-        const terminal = jobStatus === "completed" || jobStatus === "failed";
-        if (fetch_training_log || (terminal && !hasCurveArrays(data))) {
+        if (fetch_training_log || needsTrainingLogEnrichment(data)) {
             data = await enrichWithTrainingLog(job_id, data);
         }
         const structuredContent = buildStructuredContent(job_id, data);
@@ -101,6 +130,9 @@ export function registerTrainingMonitorTool(server) {
                     `This localhost port is assigned per MCP session and changes if the proxy restarts — if the page stays at "running 0%" or stops updating, the link is stale: re-run training_monitor for a fresh URL, or set BARIVIA_VIZ_PORT in your MCP env for a persistent port. Health check: http://localhost:${port}/api/health?job_id=${encodeURIComponent(job_id)}`,
             });
         }
-        return structuredTextResult(structuredContent, text, content);
+        return {
+            ...structuredTextResult(structuredContent, text, content),
+            _meta: { ui: { resourceUri: TRAINING_MONITOR_URI } },
+        };
     }));
 }

package/dist/training_monitor_curve.js

@@ -9,13 +9,38 @@ export function combinedBatchAxis(nOrd, nConv) {
         return [];
     return [...batchSampleAxis(nOrd, 0), ...batchSampleAxis(nConv, nOrd)];
 }
+export function isKernelTrainingComplete(data, status) {
+    if (status === "failed" || status === "cancelled")
+        return true;
+    if (data.kernel_complete === true)
+        return true;
+    return status === "completed";
+}
+/** Snap the last TE curve point to authoritative full-map TE when kernel training is done. */
+export function snapTeCurvesToMapTe(data) {
+    const mapTe = data.map_topographic_error ??
+        (data.kernel_complete === true ? data.topographic_error : null);
+    if (mapTe == null || !Number.isFinite(Number(mapTe)))
+        return data;
+    const out = { ...data };
+    for (const key of ["ordering_topographic_errors", "convergence_topographic_errors"]) {
+        const arr = out[key];
+        if (Array.isArray(arr) && arr.length > 0) {
+            const copy = arr.slice();
+            copy[copy.length - 1] = Number(mapTe);
+            out[key] = copy;
+        }
+    }
+    return out;
+}
+export function teCurveLabel(base, kernelComplete) {
+    return kernelComplete ? `${base} (→ map TE)` : `${base} (sampled)`;
+}
 export function formatCurveSourceNote(data) {
     const src = data.training_curve_source_batches;
-    if (!src)
-        return null;
     const parts = [];
-    const ordTotal = typeof src.ordering === "number" ? src.ordering : null;
-    const convTotal = typeof src.convergence === "number" ? src.convergence : null;
+    const ordTotal = src && typeof src.ordering === "number" ? src.ordering : null;
+    const convTotal = src && typeof src.convergence === "number" ? src.convergence : null;
     const ordShown = Array.isArray(data.ordering_errors) ? data.ordering_errors.length : 0;
     const convShown = Array.isArray(data.convergence_errors) ? data.convergence_errors.length : 0;
     if (ordTotal != null && ordTotal > ordShown) {
@@ -24,7 +49,52 @@ export function formatCurveSourceNote(data) {
     if (convTotal != null && convTotal > convShown) {
         parts.push(`${convShown} of ${convTotal.toLocaleString()} convergence batch samples`);
     }
+    const mapTe = data.map_topographic_error;
+    const epochTe = data.epoch_topographic_error;
+    if (mapTe != null &&
+        epochTe != null &&
+        Number.isFinite(Number(mapTe)) &&
+        Number.isFinite(Number(epochTe)) &&
+        Math.abs(Number(epochTe) - Number(mapTe)) > 0.0005) {
+        parts.push(`Live TE is a subsampled batch estimate during training; final point snaps to map TE ${Number(mapTe).toFixed(4)} (last sampled ${Number(epochTe).toFixed(4)})`);
+    }
+    else if (mapTe != null && Number.isFinite(Number(mapTe))) {
+        parts.push(`TE curve final point is full-map topographic error (${Number(mapTe).toFixed(4)}).`);
+    }
     if (parts.length === 0)
         return null;
-    return `Displaying uniformly subsampled curves (≤1000 points/phase): ${parts.join("; ")}.`;
+    const subsample = ordTotal != null || convTotal != null
+        ? "Displaying uniformly subsampled QE+TE curves (≤1000 points/phase, joint indices): "
+        : "";
+    return `${subsample}${parts.join("; ")}.`.replace(/: ;/, ":");
+}
+/** Map TE onto QE batch axis; when batch-aligned (same length), use values directly. */
+export function alignTeToQeAxis(te, qeLen) {
+    if (qeLen <= 0)
+        return [];
+    if (te.length === qeLen)
+        return te;
+    if (te.length === 0)
+        return Array(qeLen).fill(null);
+    if (te.length >= qeLen)
+        return te.slice(0, qeLen);
+    const pad = qeLen - te.length;
+    return [...Array(pad).fill(null), ...te];
+}
+/**
+ * Last sampled TE point from the (batch-aligned) live TE curve. This is the most
+ * recent per-epoch TE estimate, distinct from the final trained-map TE in the summary.
+ */
+export function lastEpochTeFromCurves(data) {
+    const conv = data.convergence_topographic_errors;
+    if (Array.isArray(conv) && conv.length > 0) {
+        const v = Number(conv[conv.length - 1]);
+        return Number.isFinite(v) ? v : null;
+    }
+    const ord = data.ordering_topographic_errors;
+    if (Array.isArray(ord) && ord.length > 0) {
+        const v = Number(ord[ord.length - 1]);
+        return Number.isFinite(v) ? v : null;
+    }
+    return null;
 }