@barivia/barsom-mcp 0.19.0 → 0.20.0

package/README.md

@@ -180,6 +180,10 @@ The right viewer depends on **(MCP App support)** **and** **(can the human reach
 
 ### Migration notes
 
+- **Features (0.20.0, non-breaking):**
+  - **FLooP-SIOM maps are now projectable.** `inference(action=project_columns)`, `inference(action=predict)`, and `datasets(action=add_expression, project_onto_job=<floop_job>)` work on FLooP-SIOM (free/chain) maps — values render onto the FLooP Voronoi layout instead of failing. Grid-only ops (`inference(action=transition_flow | impute_column | render_variant)`) return a clear `unsupported_topology_for_inference` message; use a fixed-grid SOM/SIOM for those. No client change required.
+  - **`datasets(action=reduce_spectral)` column selectors.** New optional `columns_range` (`[first, last]`, the server expands the inclusive numeric block — preferred for wide spectra over sending thousands of names) and `columns_except` (drop non-frequency columns like id/label/target from the block, or use alone for "all numeric except these"). `columns_except` composes with `columns_block` or `columns_range`; `columns_block` and `columns_range` are mutually exclusive. Existing `columns_block` callers are unaffected.
+  - Minimum dataset size for train/analyze relaxed from 50 to **10 rows** (10–49 allowed with a small-N stability caveat).
 - **Surface cleanup (0.19.0, breaking):**
   - `training_prep` and `submit_prepared_training` **removed**. The interactive prep UI is retired; for pre-train help use the `prepare_training` prompt (narrative checklist) or `training_guidance` (presets + resolved per-column normalization), then submit directly with `train(action=map | siom_map | impute | floop_siom)`.
   - The unused `data-preview` and `map-explorer` view scaffolds were deleted (they were never wired to a tool). The two shipped MCP App UIs are now `training_monitor` and `results_explorer`, both enhanced (auto-resize, earlier render, and silent model-context sync of what the user is viewing).
@@ -227,7 +231,7 @@ MCP Client (Cursor/Claude) ←stdio→ @barivia/barsom-mcp ←HTTPS→ api.bariv
 | `401` / invalid key | `BARIVIA_API_KEY` in MCP config; check your email or manage your key in the [account dashboard](https://barivia.se/dashboard). Error text includes a **request id** for support. |
 | Request timed out | Raise `BARIVIA_FETCH_TIMEOUT_MS` (e.g. `120000`). Large uploads already use an extended timeout; `datasets(analyze)` is async (auto-polled). Timeouts are not auto-retried, so re-running a timed-out upload is safe — an idempotency key reconciles it to the original dataset instead of duplicating. |
 | `Path must be within the workspace` / upload can’t find file | Set `BARIVIA_WORKSPACE_ROOT` to your project directory, or use an absolute path / `file:///...` URI. |
-| Job stuck “running” | Poll `jobs(action=status)` every 10–15s; large grids or FLooP-SIOM can take several minutes—not an MCP error. Staged datasets enqueue **`prepare_training_matrix`** (or impute prepare) first — train submit returns `prepare_job_id`; MCP auto-polls prepare when present. CFD mesh submit may return `prepare_job_id` for **`cfd_prepare`** (barmesh auto-polls). |
+| Job stuck “running” | Poll `jobs(action=status)` every 10–15s; large grids or FLooP-SIOM can take several minutes—not an MCP error. Staged datasets enqueue **`prepare_training_matrix`** (or impute prepare) first — train submit returns `prepare_job_id`; MCP auto-polls prepare when present. CFD mesh submit may return `prepare_job_id` for **`prepare_training_matrix`** (barmesh auto-polls). |
 | `429` | Rate limit—wait and retry. |
 | Standalone `…/viz/…` page stuck at "running 0%" or "Loading…" | The link is stale: the viz port is assigned per MCP session and changes when the proxy restarts. Re-run `training_monitor` / `results_explorer` for a fresh URL, or set `BARIVIA_VIZ_PORT` for a persistent port. Confirm with `GET /api/health?job_id=<id>`. |
 | Embedded results explorer: switching figures shows nothing | Fixed in `0.18.0` — earlier versions pointed embedded figures at a localhost URL the webview can't load. Update the package; the embedded view now lazy-loads figures over the MCP App bridge. |

package/dist/job_monitor.js

@@ -0,0 +1,230 @@
+/**
+ * Server-side job monitor for barsom async training workflows.
+ * Polls GET /v1/jobs/:id until terminal (or block_until timeout) and emits
+ * compact throttled snapshots so agents avoid manual status poll loops.
+ */
+import { apiCall, textResult } from "./shared.js";
+import { formatJobStatusText } from "./job_status_format.js";
+import { pollFinalizeIfPresent, refreshJobAfterFinalize } from "./train_finalize.js";
+export const DEFAULT_BLOCK_UNTIL_SEC = 900;
+export const DEFAULT_POLL_INTERVAL_SEC = 5;
+export const MIN_POLL_INTERVAL_SEC = 5;
+export const HEARTBEAT_POLLS = 1;
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+function num(data, key) {
+    const v = data[key];
+    if (v == null || Number.isNaN(Number(v)))
+        return undefined;
+    return Number(v);
+}
+function str(data, key) {
+    const v = data[key];
+    if (v == null || String(v) === "")
+        return undefined;
+    return String(v);
+}
+function tailOrderingErrors(data, n = 4) {
+    const raw = data.ordering_errors;
+    if (!Array.isArray(raw) || raw.length === 0)
+        return undefined;
+    return raw.slice(-n).map((x) => Number(x)).filter((x) => !Number.isNaN(x));
+}
+export function snapshotFromJob(data, elapsedSec, note) {
+    const status = String(data.status ?? "unknown");
+    const progress_pct = (data.progress ?? 0) * 100;
+    const snap = {
+        elapsed_sec: elapsedSec,
+        status,
+        progress_pct: Math.round(progress_pct * 10) / 10,
+    };
+    const phase = str(data, "progress_phase");
+    if (phase)
+        snap.phase = phase;
+    const epoch = num(data, "epoch");
+    const total = num(data, "total_epochs");
+    if (epoch != null)
+        snap.epoch = epoch;
+    if (total != null)
+        snap.total_epochs = total;
+    const qe = num(data, "quantization_error");
+    const te = num(data, "topographic_error");
+    if (qe != null)
+        snap.qe = Math.round(qe * 10_000) / 10_000;
+    if (te != null)
+        snap.te = Math.round(te * 10_000) / 10_000;
+    const eta = num(data, "training_eta_sec");
+    if (eta != null && eta > 0)
+        snap.eta_sec = Math.round(eta);
+    const tail = tailOrderingErrors(data);
+    if (tail && tail.length > 0)
+        snap.ordering_errors_tail = tail;
+    if (note)
+        snap.note = note;
+    return snap;
+}
+/** True when a new snapshot is worth recording (phase/epoch/progress/status change). */
+export function shouldRecordSnapshot(prev, next) {
+    if (!prev)
+        return true;
+    if (prev.status !== next.status)
+        return true;
+    if (next.note)
+        return true;
+    if (prev.phase !== next.phase)
+        return true;
+    if (prev.epoch !== next.epoch)
+        return true;
+    if (Math.abs(prev.progress_pct - next.progress_pct) >= 1)
+        return true;
+    if (prev.qe !== next.qe || prev.te !== next.te)
+        return true;
+    return false;
+}
+export function formatSnapshotLine(s) {
+    const parts = [`[+${s.elapsed_sec}s] ${s.status} ${s.progress_pct.toFixed(1)}%`];
+    if (s.phase)
+        parts.push(`phase ${s.phase}`);
+    if (s.epoch != null && s.total_epochs != null)
+        parts.push(`epoch ${s.epoch}/${s.total_epochs}`);
+    if (s.qe != null)
+        parts.push(`QE ${s.qe.toFixed(4)}`);
+    if (s.te != null)
+        parts.push(`TE ${s.te.toFixed(4)}`);
+    if (s.eta_sec != null)
+        parts.push(`ETA ~${s.eta_sec}s`);
+    if (s.ordering_errors_tail?.length) {
+        parts.push(`ordering_errors tail [${s.ordering_errors_tail.map((x) => x.toFixed(4)).join(", ")}]`);
+    }
+    if (s.note)
+        parts.push(s.note);
+    return parts.join(" | ");
+}
+export function formatMonitorText(result, opts) {
+    const lines = [
+        `Job ${result.job_id} monitor (block_until=${opts.block_until_sec}s, poll=${opts.poll_interval_sec}s):`,
+    ];
+    for (const s of result.snapshots)
+        lines.push(formatSnapshotLine(s));
+    lines.push("");
+    if (result.timed_out) {
+        lines.push(`Timed out before terminal state. Last status: ${result.status_text}`);
+        lines.push(`Re-run jobs(action=monitor, job_id="${result.job_id}") or training_monitor(job_id="${result.job_id}").`);
+    }
+    else {
+        lines.push(`Terminal: ${result.status_text}`);
+    }
+    lines.push(result.suggested_next_step);
+    return lines.join("\n");
+}
+function suggestedNextStep(job_id, data) {
+    const status = String(data.status ?? "");
+    if (status === "completed") {
+        const finalizeId = str(data, "finalize_job_id");
+        if (finalizeId) {
+            return `Compute done; finalize_training may still be running. Re-run jobs(action=monitor, job_id="${job_id}") with wait_finalize=true, then results(action=get, job_id="${job_id}").`;
+        }
+        return `Next: results(action=get, job_id="${job_id}") or results_explorer(job_id="${job_id}").`;
+    }
+    if (status === "failed") {
+        const stage = str(data, "failure_stage");
+        return `Job failed${stage ? ` at ${stage}` : ""}. Read the error above before retrying.`;
+    }
+    if (status === "cancelled")
+        return `Job cancelled. Confirm with jobs(action=status, job_id="${job_id}").`;
+    return `Still running — re-run jobs(action=monitor, job_id="${job_id}") to continue waiting.`;
+}
+async function fetchTrainingLogHint(job_id, data) {
+    const status = String(data.status ?? "");
+    if (status !== "completed" && status !== "failed")
+        return undefined;
+    try {
+        await apiCall("GET", `/v1/results/${job_id}/training-log`);
+        return `Training log available at GET /v1/results/${job_id}/training-log.`;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function monitorJob(job_id, options = {}) {
+    const block_until_sec = Math.max(30, options.block_until_sec ?? DEFAULT_BLOCK_UNTIL_SEC);
+    const poll_interval_sec = Math.max(MIN_POLL_INTERVAL_SEC, options.poll_interval_sec ?? DEFAULT_POLL_INTERVAL_SEC);
+    const wait_finalize = options.wait_finalize !== false;
+    const blockMs = block_until_sec * 1000;
+    const pollMs = poll_interval_sec * 1000;
+    const start = Date.now();
+    const snapshots = [];
+    let lastSnap = null;
+    let data = {};
+    let heartbeat = 0;
+    while (Date.now() - start < blockMs) {
+        data = (await apiCall("GET", `/v1/jobs/${job_id}`));
+        const elapsedSec = Math.round((Date.now() - start) / 1000);
+        const snap = snapshotFromJob(data, elapsedSec);
+        heartbeat += 1;
+        const heartbeatDue = heartbeat >= HEARTBEAT_POLLS;
+        if (shouldRecordSnapshot(lastSnap, snap) || heartbeatDue) {
+            snapshots.push(snap);
+            lastSnap = snap;
+            heartbeat = 0;
+        }
+        const status = String(data.status ?? "");
+        if (status === "completed" || status === "failed" || status === "cancelled") {
+            break;
+        }
+        await sleep(pollMs);
+    }
+    const status = String(data.status ?? "");
+    const terminal = status === "completed" || status === "failed" || status === "cancelled";
+    const timed_out = !terminal;
+    if (terminal && status === "completed" && wait_finalize && data.finalize_job_id) {
+        const finalizeId = String(data.finalize_job_id);
+        const elapsedSec = Math.round((Date.now() - start) / 1000);
+        snapshots.push(snapshotFromJob(data, elapsedSec, `finalize_training ${finalizeId} started — waiting for figure render`));
+        try {
+            const { note } = await pollFinalizeIfPresent(job_id, data, Math.max(0, blockMs - (Date.now() - start)));
+            data = await refreshJobAfterFinalize(job_id);
+            snapshots.push(snapshotFromJob(data, Math.round((Date.now() - start) / 1000), note ?? `finalize_training ${finalizeId} completed`));
+        }
+        catch (err) {
+            snapshots.push(snapshotFromJob(data, Math.round((Date.now() - start) / 1000), `finalize_training failed: ${err.message}`));
+        }
+    }
+    const statusText = formatJobStatusText(job_id, data);
+    const logHint = terminal ? await fetchTrainingLogHint(job_id, data) : undefined;
+    let suggested = suggestedNextStep(job_id, data);
+    if (logHint)
+        suggested += ` ${logHint}`;
+    return {
+        job_id,
+        terminal,
+        timed_out,
+        snapshots,
+        status_text: statusText,
+        data,
+        suggested_next_step: suggested,
+    };
+}
+export async function runJobMonitor(args) {
+    const block_until_sec = args.block_until_sec ?? DEFAULT_BLOCK_UNTIL_SEC;
+    const poll_interval_sec = args.poll_interval_sec ?? DEFAULT_POLL_INTERVAL_SEC;
+    const result = await monitorJob(args.job_id, {
+        block_until_sec,
+        poll_interval_sec,
+        wait_finalize: args.wait_finalize,
+    });
+    const text = formatMonitorText(result, { block_until_sec, poll_interval_sec });
+    return textResult({
+        ...result.data,
+        monitor: {
+            job_id: result.job_id,
+            terminal: result.terminal,
+            timed_out: result.timed_out,
+            snapshots: result.snapshots,
+            status_text: result.status_text,
+            suggested_next_step: result.suggested_next_step,
+        },
+        status_text: text,
+    });
+}

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.19.0";
+export const CLIENT_VERSION = "0.20.0";
 /** 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/jobs.js

@@ -3,11 +3,13 @@ import { registerAuditedTool } from "../audit.js";
 import { apiCall, textResult } from "../shared.js";
 import { formatJobCancelText, formatJobStatusText } from "../job_status_format.js";
 import { pollFinalizeIfPresent, refreshJobAfterFinalize } from "../train_finalize.js";
+import { DEFAULT_BLOCK_UNTIL_SEC, DEFAULT_POLL_INTERVAL_SEC, runJobMonitor } from "../job_monitor.js";
 export const JOBS_DESCRIPTION_BASE = `Manage and inspect jobs (lifecycle only).
 
 | Action | Use when |
 |--------|----------|
-| status | Polling after any async submission — call every 10–15s |
+| monitor | After async submit — blocks server-side with 5s snapshots until terminal (preferred for agents) |
+| status | One-shot progress check (manual poll every 10–15s if not using monitor) |
 | list | Finding job IDs / reviewing pipeline state (optionally filter by dataset_id) |
 | compare | Picking the best TRAINING run from a set (metrics table). NOT inference(compare), which diffs one dataset's distribution against the training set. |
 | cancel | Stopping a running or pending job to free the worker |
@@ -15,8 +17,13 @@ export const JOBS_DESCRIPTION_BASE = `Manage and inspect jobs (lifecycle only).
 
 To SUBMIT training, use the **train** tool (train(action=map | siom_map | impute | floop_siom)); to score data or run post-training map operations (predict, batch_predict, compare, project_columns, impute_column, transition_flow), use **inference**.
 
+ASYNC POLLING PROTOCOL (action=monitor):
+- Preferred after train/inference submit: one call blocks until completed/failed or block_until timeout (default ${DEFAULT_BLOCK_UNTIL_SEC}s, poll every ${DEFAULT_POLL_INTERVAL_SEC}s).
+- Snapshots include phase, epoch/total, QE/TE, ETA, ordering_errors tail when live; waits for finalize_training by default.
+- Optional UI: training_monitor(job_id) for embedded charts; jobs(action=monitor) is the headless equivalent.
+
 ASYNC POLLING PROTOCOL (action=status):
-- Poll every 10-15 seconds. Do NOT poll faster — it wastes context.
+- One-shot check only. If not using monitor, poll every 10-15 seconds manually.
 - Progress increases through phases (ordering then convergence for map training); other job types differ.
 - For large grids (40×40+), do not assume failure before 3 minutes on CPU.
 - Map training typical times: 10×10 ~30s | 20×20 ~3–5 min | 40×40 ~15–30 min.
@@ -137,12 +144,28 @@ export function renderCompareTable(comparisons) {
 export function registerJobsTool(server, description) {
     registerAuditedTool(server, "jobs", description, {
         action: z
-            .enum(["status", "list", "compare", "cancel", "delete"])
-            .describe("status: check progress; list: see all jobs; compare: metrics table; cancel: stop job; delete: remove job + files. (Training is submitted via the train tool; scoring / post-training map ops via inference.)"),
+            .enum(["status", "monitor", "list", "compare", "cancel", "delete"])
+            .describe("status: one-shot check; monitor: block until terminal with snapshots; list/compare/cancel/delete as labeled. (Training via train; scoring via inference.)"),
         job_id: z
             .string()
             .optional()
-            .describe("Job ID — required for action=status, cancel, delete."),
+            .describe("Job ID — required for action=status, monitor, cancel, delete."),
+        block_until_sec: z
+            .number()
+            .int()
+            .min(30)
+            .optional()
+            .describe(`action=monitor only: max wait seconds (default ${DEFAULT_BLOCK_UNTIL_SEC})`),
+        poll_interval_sec: z
+            .number()
+            .int()
+            .min(5)
+            .optional()
+            .describe(`action=monitor only: poll interval seconds (default ${DEFAULT_POLL_INTERVAL_SEC})`),
+        wait_finalize: z
+            .boolean()
+            .optional()
+            .describe("action=monitor only: wait for finalize_training (default true)"),
         job_ids: z
             .array(z.string())
             .optional()
@@ -152,8 +175,13 @@ export function registerJobsTool(server, description) {
             .optional()
             .describe("action=list: filter jobs by this dataset ID."),
     }, async (args) => {
-        const { action, job_id, job_ids, dataset_id } = args;
+        const { action, job_id, job_ids, dataset_id, block_until_sec, poll_interval_sec, wait_finalize } = args;
         // ---- Lifecycle ----
+        if (action === "monitor") {
+            if (!job_id)
+                throw new Error("jobs(monitor) requires job_id");
+            return runJobMonitor({ job_id, block_until_sec, poll_interval_sec, wait_finalize });
+        }
         if (action === "status") {
             if (!job_id)
                 throw new Error("jobs(status) requires job_id");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barivia/barsom-mcp",
-  "version": "0.19.0",
+  "version": "0.20.0",
   "description": "barSOM MCP proxy — connect any MCP client to the barSOM cloud API for Self-Organizing Map analytics",
   "keywords": [
     "mcp",