@ateam-ai/mcp 0.3.10 → 0.3.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ateam-ai/mcp",
-  "version": "0.3.10",
+  "version": "0.3.11",
   "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/http.js

@@ -60,21 +60,28 @@ export function startHttpServer(port = 3100) {
   app.use(express.json());
 
   // ─── Fix Accept header for MCP endpoints ──────────────────────────
-  // Claude.ai may not send the required Accept header with text/event-stream.
-  // The MCP SDK requires it per spec, so we inject it if missing.
+  // The MCP SDK requires Accept to include BOTH application/json and
+  // text/event-stream. Different clients send different combinations:
+  //   - Claude.ai web: may omit text/event-stream
+  //   - Claude.ai mobile: may send only text/event-stream
+  //   - ChatGPT: may send only application/json
+  // We normalize to always include both to satisfy the SDK.
   // Must patch both parsed headers AND rawHeaders since @hono/node-server
   // reads from rawHeaders when converting to Web Standard Request.
   for (const path of MCP_PATHS) {
     app.use(path, (req, _res, next) => {
-      const accept = req.headers.accept || "";
-      if (req.method === "POST" && !accept.includes("text/event-stream")) {
-        const fixed = "application/json, text/event-stream";
-        req.headers.accept = fixed;
-        const idx = req.rawHeaders.findIndex((h) => h.toLowerCase() === "accept");
-        if (idx !== -1) {
-          req.rawHeaders[idx + 1] = fixed;
-        } else {
-          req.rawHeaders.push("Accept", fixed);
+      if (req.method === "POST") {
+        const accept = req.headers.accept || "";
+        const needsFix = !accept.includes("text/event-stream") || !accept.includes("application/json");
+        if (needsFix) {
+          const fixed = "application/json, text/event-stream";
+          req.headers.accept = fixed;
+          const idx = req.rawHeaders.findIndex((h) => h.toLowerCase() === "accept");
+          if (idx !== -1) {
+            req.rawHeaders[idx + 1] = fixed;
+          } else {
+            req.rawHeaders.push("Accept", fixed);
+          }
         }
       }
       next();

package/src/tools.js

@@ -187,10 +187,47 @@ export const tools = [
           description:
             "If true (default), wait for completion. If false, return job_id immediately for polling via ateam_test_status.",
         },
+        actor_id: {
+          type: "string",
+          description:
+            "Optional actor ID for conversation continuity. Pass the actor_id from a previous test response to continue the conversation. Omit to auto-generate a test actor (test_<timestamp>_<random>, auto-expires in 24h).",
+        },
       },
       required: ["solution_id", "skill_id", "message"],
     },
   },
+  {
+    name: "ateam_conversation",
+    core: true,
+    description:
+      "Send a message to a deployed solution and get the result. No skill_id needed — the system auto-routes to the right skill. Supports multi-turn conversations: pass the actor_id from a previous response to continue the thread (e.g., reply to a confirmation prompt). Each call creates a new job but the same actor_id maintains conversation context.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        solution_id: {
+          type: "string",
+          description: "The solution ID",
+        },
+        message: {
+          type: "string",
+          description: "The message to send (e.g., 'send email to X' or 'I confirm')",
+        },
+        actor_id: {
+          type: "string",
+          description: "Optional: actor ID from a previous response to continue the conversation. Omit for a new conversation.",
+        },
+        wait: {
+          type: "boolean",
+          description: "If true (default), wait for completion. If false, return job_id immediately for polling.",
+        },
+        timeout_ms: {
+          type: "number",
+          description: "Optional: max wait time in ms (default: 60000, max: 300000).",
+        },
+      },
+      required: ["solution_id", "message"],
+    },
+  },
   {
     name: "ateam_test_pipeline",
     core: true,
@@ -628,9 +665,9 @@ export const tools = [
   },
   {
     name: "ateam_test_status",
-    core: false,
+    core: true,
     description:
-      "Poll the progress of an async skill test. Returns iteration count, tool call steps, status, pending questions, and result when done. (Advanced — use ateam_test_skill with wait=true for synchronous testing.)",
+      "Poll the progress of an async skill test. Returns iteration count, tool call steps, status (running/completed/failed), and result when done. (Advanced — use ateam_test_skill with wait=true for synchronous testing.)",
     inputSchema: {
       type: "object",
       properties: {
@@ -652,7 +689,7 @@ export const tools = [
   },
   {
     name: "ateam_test_abort",
-    core: false,
+    core: true,
     description:
       "Abort a running skill test. Stops the job execution at the next iteration boundary. (Advanced.)",
     inputSchema: {
@@ -1095,6 +1132,7 @@ const TENANT_TOOLS = new Set([
   "ateam_list_solutions",
   "ateam_get_solution",
   "ateam_get_execution_logs",
+  "ateam_conversation",
   "ateam_test_skill",
   "ateam_test_pipeline",
   "ateam_test_voice",
@@ -1147,7 +1185,7 @@ const handlers = {
         { step: 2, action: "Build & Run", description: "Define your solution + skills + connector code, then validate, deploy, and health-check in one call. Include mcp_store with connector source code on the first deploy.", tools: ["ateam_build_and_run"] },
         { step: 3, action: "Version", description: "Every deploy auto-pushes to main on GitHub. The repo (tenant--solution-id) is the source of truth for connector code.", tools: ["ateam_github_status", "ateam_github_log"] },
         { step: 4, action: "Iterate", description: "Edit connector code ONE FILE AT A TIME via ateam_github_patch, then redeploy with ateam_build_and_run (auto-pulls from GitHub). NEVER re-pass all connector code inline after first deploy. For skill definitions, use ateam_patch.", tools: ["ateam_github_patch", "ateam_build_and_run", "ateam_patch"] },
-        { step: 5, action: "Test & Debug", description: "Test the decision pipeline or full execution, then diagnose with logs and metrics. For voice-enabled solutions, use ateam_test_voice to simulate phone conversations.", tools: ["ateam_test_pipeline", "ateam_test_skill", "ateam_test_voice", "ateam_get_execution_logs", "ateam_get_metrics"] },
+        { step: 5, action: "Test & Debug", description: "Test with ateam_conversation (auto-routes, supports multi-turn with actor_id for confirmations). Use ateam_test_pipeline for intent debugging, ateam_test_voice for voice. Diagnose with logs and metrics.", tools: ["ateam_conversation", "ateam_test_pipeline", "ateam_test_skill", "ateam_test_voice", "ateam_get_execution_logs", "ateam_get_metrics"] },
         { step: 6, action: "Checkpoint", description: "When solution is in a good state, create a checkpoint (safe point). You can rollback to any checkpoint if something breaks.", tools: ["ateam_github_promote", "ateam_github_list_versions"] },
       ],
     },
@@ -1455,20 +1493,53 @@ const handlers = {
     // Phase 2: Deploy
     let deploy;
     try {
+      // Try sync first (fast for small solutions)
       deploy = await post("/deploy/solution", {
         solution, skills: effectiveSkills, connectors, mcp_store: effectiveMcpStore,
         ...(github && { skip_github_push: true }),
-      }, sid, { timeoutMs: 300_000, retries: 2 });
+      }, sid, { timeoutMs: 120_000 });
       phases.push({ phase: "deploy", status: deploy.ok ? "done" : "failed" });
     } catch (err) {
-      return {
-        ok: false,
-        phase: "deployment",
-        phases,
-        error: err.message,
-        validation_warnings: validation.warnings || [],
-        message: "Deployment failed. See error details above.",
-      };
+      const isTimeout = /524|502|503|timeout|ETIMEDOUT/i.test(err.message);
+      if (!isTimeout) {
+        return { ok: false, phase: "deployment", phases, error: err.message, validation_warnings: validation.warnings || [] };
+      }
+
+      // Timeout → retry with async mode + polling
+      phases.push({ phase: "deploy", status: "async_retry" });
+      try {
+        const asyncResult = await post("/deploy/solution", {
+          solution, skills: effectiveSkills, connectors, mcp_store: effectiveMcpStore,
+          ...(github && { skip_github_push: true }),
+          async: true,
+        }, sid, { timeoutMs: 15_000 });
+
+        if (asyncResult.job_id) {
+          // Poll for completion (up to 10 min)
+          const jobId = asyncResult.job_id;
+          const maxWait = 600_000;
+          const pollInterval = 5_000;
+          const start = Date.now();
+          while (Date.now() - start < maxWait) {
+            await new Promise(r => setTimeout(r, pollInterval));
+            try {
+              const job = await get(`/deploy/jobs/${jobId}`, sid);
+              if (job.status === 'done' || job.status === 'failed') {
+                deploy = job;
+                phases.push({ phase: "deploy", status: job.status });
+                break;
+              }
+            } catch { /* keep polling */ }
+          }
+          if (!deploy) {
+            return { ok: false, phase: "deployment", phases, error: "Async deploy timed out after 10 minutes", validation_warnings: validation.warnings || [],
+              hint: "Deploy is too large even for async mode. Use incremental tools instead: ateam_patch(solution_id, target:'skill', skill_id, updates) for skill changes, ateam_upload_connector(solution_id, connector_id, github:true) for connector code changes." };
+          }
+        }
+      } catch (asyncErr) {
+        return { ok: false, phase: "deployment", phases, error: `Sync timed out, async fallback failed: ${asyncErr.message}`, validation_warnings: validation.warnings || [],
+          hint: "Deploy timed out. Use incremental tools: ateam_patch for skill changes, ateam_upload_connector for connector changes. These deploy one component at a time and never timeout." };
+      }
     }
 
     if (!deploy.ok) {
@@ -1537,17 +1608,16 @@ const handlers = {
       }
     }
 
-    // Phase 5: GitHub push (skip if we just pulled from GitHub — don't overwrite source of truth)
+    // Phase 5: GitHub push — only when NOT deployed from GitHub
     let github_result;
     if (github) {
-      // We pulled from GitHub → GitHub IS the source of truth. Don't push stale Core state back.
-      github_result = { skipped: true, reason: 'Deployed from GitHub — skipping push-back to avoid overwriting source of truth.' };
+      github_result = { skipped: true, reason: 'Deployed from GitHub — push-back skipped.' };
       phases.push({ phase: "github", status: "skipped", reason: "pulled_from_github" });
     } else {
       try {
         github_result = await post(
           `/deploy/solutions/${solutionId}/github/push`,
-          { message: `Deploy: ${solution.name || solutionId}` },
+          { push_to_github: true, message: `Deploy: ${solution.name || solutionId}` },
           sid,
           { timeoutMs: 60_000 },
         );
@@ -1599,11 +1669,15 @@ const handlers = {
       }
       phases.push({ phase: "update", status: "done" });
     } catch (err) {
+      const notFound = /not found|404|ENOENT/i.test(err.message);
       return {
         ok: false,
         phase: "update",
         error: err.message,
         message: "Patch failed. Check your updates payload format.",
+        ...(notFound && {
+          hint: "Skill not found in Builder storage. Use ateam_github_patch to edit the skill JSON directly on GitHub (path: skills/<skill-id>/skill.json), then ateam_redeploy(solution_id, skill_id) to deploy the updated skill.",
+        }),
       };
     }
 
@@ -1650,7 +1724,7 @@ const handlers = {
     try {
       github_result = await post(
         `/deploy/solutions/${solution_id}/github/push`,
-        { message: `Patch: ${target}${skill_id ? ` ${skill_id}` : ''} — ${Object.keys(updates || {}).join(', ')}` },
+        { push_to_github: true, message: `Patch: ${target}${skill_id ? ` ${skill_id}` : ''} — ${Object.keys(updates || {}).join(', ')}` },
         sid,
         { timeoutMs: 60_000 },
       );
@@ -1754,9 +1828,21 @@ const handlers = {
     return get(`/deploy/solutions/${solution_id}/logs${qsStr}`, sid);
   },
 
-  ateam_test_skill: async ({ solution_id, skill_id, message, wait }, sid) => {
+  ateam_conversation: async ({ solution_id, message, actor_id, wait, timeout_ms }, sid) => {
+    const asyncMode = wait === false;
+    const body = {
+      message,
+      ...(actor_id ? { actor_id } : {}),
+      ...(asyncMode ? { async: true } : {}),
+      ...(timeout_ms ? { timeout_ms } : {}),
+    };
+    const timeoutMs = asyncMode ? 15_000 : Math.min((timeout_ms || 60_000) + 30_000, 330_000);
+    return post(`/deploy/solutions/${solution_id}/test`, body, sid, { timeoutMs });
+  },
+
+  ateam_test_skill: async ({ solution_id, skill_id, message, wait, actor_id }, sid) => {
     const asyncMode = wait === false;
-    const body = { message, ...(asyncMode ? { async: true } : {}) };
+    const body = { message, ...(asyncMode ? { async: true } : {}), ...(actor_id ? { actor_id } : {}) };
     const timeoutMs = asyncMode ? 15_000 : 90_000;
     return post(`/deploy/solutions/${solution_id}/skills/${skill_id}/test`, body, sid, { timeoutMs });
   },
@@ -1800,7 +1886,7 @@ const handlers = {
   // ─── GitHub tools ──────────────────────────────────────────────────
 
   ateam_github_push: async ({ solution_id, message }, sid) =>
-    post(`/deploy/solutions/${solution_id}/github/push`, { message }, sid, { timeoutMs: 60_000 }),
+    post(`/deploy/solutions/${solution_id}/github/push`, { push_to_github: true, message }, sid, { timeoutMs: 60_000 }),
 
   ateam_github_pull: async ({ solution_id }, sid) =>
     post(`/deploy/solutions/${solution_id}/github/pull`, {}, sid, { timeoutMs: 300_000, retries: 2 }),
@@ -1849,7 +1935,23 @@ const handlers = {
     const endpoint = skill_id
       ? `/deploy/solutions/${solution_id}/skills/${skill_id}/redeploy`
       : `/deploy/solutions/${solution_id}/redeploy`;
-    const result = await post(endpoint, {}, sid, { timeoutMs: 300_000, retries: 2 });
+    let result;
+    try {
+      result = await post(endpoint, {}, sid, { timeoutMs: 300_000, retries: 2 });
+    } catch (err) {
+      const notFound = /not found|404|ENOENT/i.test(err.message);
+      const isTimeout = /524|502|503|timeout|ETIMEDOUT/i.test(err.message);
+      return {
+        ok: false,
+        error: err.message,
+        ...(notFound && {
+          hint: "Skill not found in Builder storage. Edit the skill on GitHub with ateam_github_patch(solution_id, path: 'skills/<skill-id>/skill.json', search: '...', replace: '...'), then use ateam_build_and_run(solution_id, github: true) or ask the platform operator to deploy the single skill.",
+        }),
+        ...(isTimeout && {
+          hint: "Redeploy timed out. For large solutions, redeploy one skill at a time: ateam_redeploy(solution_id, skill_id: '<specific-skill>').",
+        }),
+      };
+    }
     return {
       ok: result.ok,
       solution_id,
@@ -1917,7 +2019,7 @@ const handlers = {
           // Push: Builder FS → GitHub
           if (!pull_only) {
             try {
-              const pushResult = await post(`/deploy/solutions/${sol.id}/github/push`, {}, sid);
+              const pushResult = await post(`/deploy/solutions/${sol.id}/github/push`, { push_to_github: true }, sid);
               entry.push = { ok: true, commit: pushResult.commitSha?.slice(0, 8), files: pushResult.filesCommitted };
             } catch (err) {
               entry.push = { ok: false, error: err.message.slice(0, 100) };