@ateam-ai/mcp 0.4.45 → 0.4.47

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ateam-ai/mcp",
-  "version": "0.4.45",
+  "version": "0.4.47",
   "mcpName": "io.github.ariekogan/ateam-mcp",
   "description": "A-Team MCP Server — build, validate, and deploy multi-agent solutions from any AI environment",
   "type": "module",

package/src/api.js

@@ -467,14 +467,14 @@ function formatError(method, path, status, body, baseUrl) {
   // the caller as a bare "returned 422", throwing away the very thing it was
   // asked to produce. Serialize objects too, capped the same way.
   let detail = "";
-  if (typeof body === "string") {
-    if (body.length > 0 && body.length < 2000) detail = body;
-  } else if (body && typeof body === "object") {
-    try {
-      const s = JSON.stringify(body);
-      if (s.length < 2000) detail = s;
-      else detail = s.slice(0, 2000) + "… (truncated)";
-    } catch { /* non-serializable — leave detail empty */ }
+  const asText = typeof body === "string"
+    ? body
+    : (body && typeof body === "object" ? (() => { try { return JSON.stringify(body); } catch { return ""; } })() : "");
+  if (asText.length > 0) {
+    // Previously a body of 2000+ chars was dropped ENTIRELY, so the richer the
+    // error the less the caller was told — a 422 carrying the full diagnosis
+    // arrived as a bare status code. Truncate instead of discarding.
+    detail = asText.length < 2000 ? asText : asText.slice(0, 2000) + "… (truncated)";
   }
 
   // Always show the FULL URL actually hit — ateam-mcp is a PUBLIC MCP with a
@@ -539,6 +539,12 @@ async function request(method, path, body, sessionId, opts = {}) {
         // on this to NOT scaffold-clobber an existing skill on a read error.
         const e = new Error(formatError(method, path, res.status, text, baseUrl));
         e.status = res.status;
+        // Keep the RAW body on the error. formatError truncates for humans, and
+        // an endpoint that answers 4xx WITH the diagnosis (ui.surfaceProbe's 422
+        // carries the failures explaining why a surface is broken) is exactly the
+        // case where the body matters more than the status. A caller that knows
+        // how to read its own error shape should not have to scrape a message.
+        e.body = text;
         throw e;
       }
 

package/src/tools.js

@@ -2168,6 +2168,20 @@ function _scaffoldConnectorFiles({ connectorId, displayName, uiCapable }) {
 //
 // Fill in your real tools below (see TOOLS + the tools/call dispatch). The
 // JSON-RPC framing, actor isolation, stdio loop${uiCapable ? ", and ui-dist plugin discovery" : ""} are template-provided.
+//
+// ⚠️ NEVER SWALLOW A FAILURE. If something this tool depends on fails — a fetch,
+// a platform call, a store read — RETURN THE ERROR. Do not catch it and answer
+// with empty data:
+//
+//   BAD:   try { rows = await load(); } catch { rows = []; }   // renders 0.00 forever
+//   GOOD:  try { rows = await load(); }
+//          catch (e) { return toText({ ok: false, error: String(e.message || e) }); }
+//
+// A tool that returns ok:true with an empty result when its dependency is broken
+// is INDISTINGUISHABLE from one that genuinely has no data — to the widget, to
+// the person reading the screen, and to the agent trying to fix it. That exact
+// shape cost a full day: a connector caught a 401, returned an empty ledger, and
+// the dashboard showed 0.00 while every check reported success.
 ${uiCapable ? `
 import { readdirSync, readFileSync, existsSync } from "node:fs";
 import { fileURLToPath } from "node:url";
@@ -4047,10 +4061,9 @@ const handlers = {
       // generic error path turned into "returned 422" — hiding the failures that
       // say WHY the screen is broken, and leaving the caller as blind as before
       // it ran the probe. Hand the verdict back as a result instead of throwing.
-      const m = /returned (4\d\d|503)\b[\s\S]*?— (\{[\s\S]*)$/.exec(err?.message || "");
-      if (m) {
+      if (typeof err?.body === "string" && err.body) {
         try {
-          const parsed = JSON.parse(m[2].replace(/\n?Hint: [\s\S]*$/, "").trim());
+          const parsed = JSON.parse(err.body);
           if (parsed && (parsed.verdict || Array.isArray(parsed.failures))) return parsed;
         } catch { /* not the probe's body — fall through */ }
       }