@ateam-ai/mcp 0.4.68 → 0.4.70

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ateam-ai/mcp",
-  "version": "0.4.68",
+  "version": "0.4.70",
   "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

@@ -487,6 +487,29 @@ function formatError(method, path, status, body, baseUrl) {
     503: "A-Team API is temporarily unavailable. Try again in a minute.",
   };
 
+  // A 500 THAT NAMES A MISSING CONFIGURATION IS NOT "TRY AGAIN IN A MINUTE".
+  //
+  // /chat answered 500 {"message":"OPENAI_API_KEY is not set"} and this table
+  // labelled it "the platform may be temporarily unavailable — try again in a
+  // minute". Every part is wrong: nothing is unavailable, a minute changes
+  // nothing, and the fix is to set a key. An agent obeying that hint burns its
+  // retries on a condition that cannot clear on its own. The body already said
+  // so; only the hint disagreed. (2026-08-22, found by sweeping every tool.)
+  if (status >= 500) {
+    // `body` is what this function receives; asText is derived further down, so
+    // read the body directly here rather than a variable that is not yet in scope.
+    const bodyText = typeof body === "string"
+      ? body
+      : (() => { try { return JSON.stringify(body || ""); } catch { return ""; } })();
+    const m = /\b([A-Z][A-Z0-9_]{3,})\s+is not set\b|\bmissing (?:env|environment) (?:var|variable)\s+([A-Z0-9_]+)/i.exec(bodyText);
+    if (m) {
+      const name = m[1] || m[2];
+      hints[status] =
+        `CONFIGURATION, not an outage: the server reports ${name} is not set. Retrying will not help and nothing is down — ` +
+        `this needs ${name} configured on the A-Team backend serving ${baseUrl || "this API"}. Other tools are unaffected.`;
+    }
+  }
+
   // Special-case: GitHub App not connected for this tenant. This is the wall a
   // user hits the first time they iterate on CONNECTOR CODE (github_patch /
   // github_write / github_push / build_and_run auto-pull). The raw

package/src/http.js

@@ -31,6 +31,22 @@ import {
 import { mountOAuth } from "./oauth.js";
 import { connectGithubPage } from "./pages.js";
 
+// Read once at import: the version of the code in THIS process, and when it
+// started. See the /health handler for why both matter.
+const PKG_VERSION = await (async () => {
+  try {
+    const { readFileSync } = await import("node:fs");
+    const { fileURLToPath } = await import("node:url");
+    const { dirname, join } = await import("node:path");
+    const here = dirname(fileURLToPath(import.meta.url));
+    return JSON.parse(readFileSync(join(here, "..", "package.json"), "utf8")).version || "unknown";
+  } catch {
+    // Never let a liveness probe fail over its own labelling.
+    return "unknown";
+  }
+})();
+const STARTED_AT = new Date().toISOString();
+
 // Active sessions
 const transports = {};
 
@@ -213,10 +229,28 @@ export function startHttpServer(port = 3100) {
   }
 
   // ─── Health check ─────────────────────────────────────────────
+  //
+  // version + startedAt are the whole point of this probe, not decoration.
+  //
+  // Without them every field here was TRUE while the agent served seven-day-old
+  // code: ok, service, transport and sessions all reported correctly, and not
+  // one of them could reveal that the process had been running since Aug 15
+  // across ~10 publishes. A liveness probe that cannot answer "is this the code
+  // I shipped?" is the truthful-but-useless shape — and a stale server that
+  // ANSWERS is worse than one that is down, because its errors describe bugs
+  // that were already fixed. (2026-08-22: it returned a 401 from a code path
+  // deleted in 2ff2a34, and a session went debugging a system that was correct.)
+  //
+  // version comes from the package.json NEXT TO THIS FILE, read at import, so it
+  // describes the code actually loaded — not what npm has, and not what a
+  // container was built with.
   app.get("/health", (_req, res) => {
     res.json({
       ok: true,
       service: "ateam-mcp",
+      version: PKG_VERSION,
+      startedAt: STARTED_AT,
+      uptime_s: Math.round(process.uptime()),
       transport: "http",
       sessions: getSessionStats(),
     });

package/src/tools.js

@@ -4303,6 +4303,18 @@ const handlers = {
     post("/deploy/connector", { connector }, sid),
 
   ateam_upload_connector_files: async ({ connector_id, files }, sid) => {
+    // A MISSING ARGUMENT MUST NAME ITSELF. Omitting `files` crashed with
+    // "files is not iterable" — a stack-trace phrase that names a JS type
+    // problem, not the thing the caller has to change, and it reads like the
+    // tool is broken rather than the call. Same for a non-array.
+    if (!Array.isArray(files) || files.length === 0) {
+      throw new Error(
+        `ateam_upload_connector_files needs files: an ARRAY of { path, content } (content_base64 or url also accepted). ` +
+        `Got ${files === undefined ? "nothing" : JSON.stringify(files).slice(0, 60)}. ` +
+        `To upload a connector already in the repo, use ateam_upload_connector(connector_id, github:true) instead.`,
+      );
+    }
+    if (!connector_id) throw new Error("ateam_upload_connector_files needs connector_id — the connector these files belong to.");
     // Resolve content_base64 and url into plain content before sending to backend
     const resolved = [];
     for (const file of files) {
@@ -4697,10 +4709,34 @@ const handlers = {
     };
   },
 
-  ateam_test_pipeline: async ({ solution_id, skill_id, message }, sid) =>
-    post(`/deploy/solutions/${solution_id}/skills/${skill_id}/test-pipeline`, { message }, sid, { timeoutMs: 30_000 }),
+  ateam_test_pipeline: async ({ solution_id, skill_id, message }, sid) => {
+    // NEVER INTERPOLATE undefined INTO A PATH. Omitting skill_id produced a
+    // request to /skills/undefined/test-pipeline, so the server answered about
+    // a skill literally named "undefined" — the caller then hunts a routing
+    // problem instead of reading "you forgot skill_id".
+    if (!skill_id) {
+      throw new Error(
+        `ateam_test_pipeline needs skill_id — it tests ONE skill's intent pipeline. ` +
+        `List them with ateam_get_solution(view:"skills"). To send a message without choosing a skill, use ateam_conversation (it auto-routes).`,
+      );
+    }
+    if (!message) throw new Error("ateam_test_pipeline needs message — the utterance to run through the pipeline.");
+    return post(`/deploy/solutions/${solution_id}/skills/${skill_id}/test-pipeline`, { message }, sid, { timeoutMs: 30_000 });
+  },
 
   ateam_test_voice: async ({ solution_id, messages, phone_number, skill_slug, timeout_ms }, sid) => {
+    // Without this, omitting `messages` died on messages.length with
+    // "Cannot read properties of undefined (reading 'length')" — an internal
+    // crash where the caller needed one sentence about the argument. Note it
+    // is messageS (a turn array), which is easy to miss next to every other
+    // test tool taking a single `message`.
+    if (!Array.isArray(messages) || messages.length === 0) {
+      throw new Error(
+        `ateam_test_voice needs messages: an ARRAY of caller turns, e.g. ["book me an appointment", "tomorrow at 3"]. ` +
+        `Got ${messages === undefined ? "nothing" : JSON.stringify(messages).slice(0, 60)}. ` +
+        `(It is "messages", plural — unlike ateam_test_skill/ateam_conversation, which take a single message.)`,
+      );
+    }
     const body = { messages };
     if (phone_number) body.phone_number = phone_number;
     if (skill_slug) body.skill_slug = skill_slug;