@ateam-ai/mcp 0.4.78 → 0.4.80

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ateam-ai/mcp",
-  "version": "0.4.78",
+  "version": "0.4.80",
   "mcpName": "io.github.ariekogan/ateam-mcp",
   "description": "A-Team MCP Server — build, validate, and deploy multi-agent solutions from any AI environment",
   "type": "module",
@@ -13,7 +13,7 @@
     "start:http": "node src/index.js --http",
     "dev": "node --watch src/index.js",
     "dev:http": "node --watch src/index.js --http",
-    "test": "node test/session-isolation.test.mjs && node test/widget-protocol.test.mjs"
+    "test": "node test/session-isolation.test.mjs && node test/widget-protocol.test.mjs && node test/actor-binding.test.mjs"
   },
   "keywords": [
     "mcp",

package/src/api.js

@@ -173,6 +173,27 @@ export function isExplicitlyAuthenticated(sessionId) {
  * Record activity on a session — called on every tool call.
  * Keeps the session alive and updates context for smarter UX.
  */
+/**
+ * Forget the session's bound actor.
+ *
+ * A session binds an actor from args or from a run-starting tool's result, and
+ * NOTHING ever unbound it — so a session that bound a bad value ("dev", a
+ * branch name a caller mistook for an actor) sent it on every later request
+ * forever, each one 401-ing with `Actor "dev" not found`. Restricting where a
+ * bind may come from narrows the entrance; it does not open an exit.
+ *
+ * Called when Core tells us the actor does not exist. Self-healing beats a
+ * hint telling a human to re-authenticate a key that was never the problem.
+ */
+export function clearSessionActor(sessionId, reason = "") {
+  const session = sessionId ? sessions.get(sessionId) : null;
+  if (!session?.context?.actorId) return false;
+  const had = session.context.actorId;
+  delete session.context.actorId;
+  console.warn(`[Auth] Unbound session actor "${had}"${reason ? ` — ${reason}` : ""}. Later calls act as the tenant until an actor is passed again.`);
+  return true;
+}
+
 export function touchSession(sessionId, { toolName, solutionId, skillId, actorId } = {}) {
   const session = sessions.get(sessionId);
   if (!session) return;
@@ -641,6 +662,15 @@ async function request(method, path, body, sessionId, opts = {}) {
 
       if (!res.ok) {
         const text = await res.text().catch(() => "");
+        // SELF-HEAL A BAD ACTOR BINDING. Core saying `Actor "X" not found` is
+        // proof the session is carrying an actor that does not exist, and every
+        // subsequent request would send it again. Restricting where a bind may
+        // come from narrows the entrance; this is the exit. Unbinding costs
+        // nothing when the actor was genuinely wrong, and the next call simply
+        // acts as the tenant until a real actor is passed.
+        if (res.status === 401 && /Actor\s+\\?"?[^"\\,}]+\\?"?\s+not found|unknown actor/i.test(text)) {
+          clearSessionActor(sessionId, `Core rejected it on ${method} ${path}`);
+        }
         // Attach the HTTP status so callers can distinguish a genuine 404
         // (resource absent) from a transient/5xx failure. ateam_patch relies
         // on this to NOT scaffold-clobber an existing skill on a read error.

package/src/tools.js

@@ -4966,7 +4966,25 @@ const handlers = {
       throw new Error("Pass chain_id (the whole run — recommended) or job_id. ateam_conversation returns chain_id.");
     }
     if (!skill_id) {
-      throw new Error(`job_id "${job_id}" needs skill_id too — the per-job endpoint is scoped by skill. Pass chain_id instead to poll the whole run without knowing which skill ran it.`);
+      // ASK FOR NOTHING THE TOOL CAN WORK OUT ITSELF. This used to throw
+      // "job_id needs skill_id too — pass chain_id instead". The message was
+      // accurate and well-written, and it was reached by FAILING FIRST, every
+      // time: 4 occurrences on 4 different job ids in a single clean e2e, each
+      // one a wasted turn. A good error still costs a round trip.
+      //
+      // /deploy/jobs/:id/status resolves ANY job id — it is the same endpoint
+      // the chain path above already uses — so a job id without a skill needs no
+      // skill at all. `scope` says which question was answered, because "this
+      // job" and "the whole run" genuinely differ: a root job can read completed
+      // while a handoff is still running.
+      const data = await get(`/deploy/jobs/${encodeURIComponent(job_id)}/status`, sid);
+      return {
+        ok: true,
+        scope: "job",
+        job_id,
+        ...data,
+        _note: `Answered for THIS JOB. For the whole run — including handoffs a root job does not cover — pass chain_id instead${data?.chainId ? ` (this job's chain is "${data.chainId}")` : ""}.`,
+      };
     }
     // Existing single-job snapshot via Builder (unchanged shape for back-compat).
     const single = await get(`/deploy/solutions/${solution_id}/skills/${skill_id}/test/${job_id}`, sid);