@ateam-ai/mcp 0.3.4 → 0.3.6

package/package.json

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

@@ -120,18 +120,22 @@ export const tools = [
     name: "ateam_build_and_run",
     core: true,
     description:
-      "Build and deploy a governed AI Team solution in one step. ⚠️ HEAVIEST OPERATION (60-180s): validates solution+skills → deploys all connectors+skills to A-Team Core (regenerates MCP servers) → health-checks → optionally runs a warm test → auto-pushes to GitHub. Use this instead of calling validate, deploy, and health separately. For small changes to an already-deployed solution, prefer ateam_patch (faster, incremental). Requires authentication.",
+      "Build and deploy a governed AI Team solution in one step. ⚠️ HEAVIEST OPERATION (60-180s): validates solution+skills → deploys all connectors+skills to A-Team Core (regenerates MCP servers) → health-checks → optionally runs a warm test → auto-pushes to GitHub. AUTO-DETECTS GitHub repo: if you omit mcp_store and a repo exists, connector code is pulled from GitHub automatically. First deploy requires mcp_store. After that, write files via ateam_github_write, then just call build_and_run without mcp_store. For small changes to an already-deployed solution, prefer ateam_patch (faster, incremental). Requires authentication.",
     inputSchema: {
       type: "object",
       properties: {
+        solution_id: {
+          type: "string",
+          description: "The solution ID. Use this INSTEAD of passing the full solution object — the solution definition is auto-pulled from GitHub. Required if solution object is omitted.",
+        },
         solution: {
           type: "object",
-          description: "Solution architecture — identity, grants, handoffs, routing",
+          description: "Full solution definition. Required on first deploy. After first deploy, just pass solution_id instead — everything is auto-pulled from GitHub.",
         },
         skills: {
           type: "array",
           items: { type: "object" },
-          description: "Array of full skill definitions",
+          description: "Optional after first deploy: skill definitions. If omitted, auto-pulled from GitHub repo (skills/{id}/skill.json).",
         },
         connectors: {
           type: "array",
@@ -144,7 +148,7 @@ export const tools = [
         },
         github: {
           type: "boolean",
-          description: "Optional: if true, pull connector source code from the solution's GitHub repo instead of requiring mcp_store. Use this after the first deploy (which creates the repo). Cannot be used on first deploy.",
+          description: "Optional: if true, pull connector source code from the solution's GitHub repo. AUTO-DETECTED: if you omit both mcp_store and github, the system checks if a repo exists and pulls from it automatically. You rarely need to set this explicitly.",
         },
         test_message: {
           type: "string",
@@ -155,7 +159,7 @@ export const tools = [
           description: "Optional: which skill to test (defaults to the first skill).",
         },
       },
-      required: ["solution", "skills"],
+      required: [],
     },
   },
   {
@@ -850,6 +854,36 @@ export const tools = [
       required: ["solution_id", "path"],
     },
   },
+  {
+    name: "ateam_github_write",
+    core: true,
+    description:
+      "Write a file to the solution's GitHub repo. Use this to create new connector files or replace existing ones — one file per call. " +
+      "This is the PRIMARY way to write connector code after first deploy. " +
+      "Write each file individually (server.js, package.json, UI assets), then call ateam_build_and_run() to deploy.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        solution_id: {
+          type: "string",
+          description: "The solution ID",
+        },
+        path: {
+          type: "string",
+          description: "File path to write (e.g. 'connectors/my-mcp/server.js', 'connectors/my-mcp/package.json')",
+        },
+        content: {
+          type: "string",
+          description: "The full file content",
+        },
+        message: {
+          type: "string",
+          description: "Optional commit message (default: 'Write <path>')",
+        },
+      },
+      required: ["solution_id", "path", "content"],
+    },
+  },
   {
     name: "ateam_github_log",
     core: true,
@@ -1084,7 +1118,7 @@ const handlers = {
         { step: 1, action: "Learn", description: "Get the spec and study examples", tools: ["ateam_get_spec", "ateam_get_examples"] },
         { 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 via ateam_github_patch (commits to main), then redeploy with ateam_build_and_run(github:true). For skill definition changes, use ateam_patch (also pushes to main).", tools: ["ateam_github_patch", "ateam_build_and_run", "ateam_patch"] },
+        { 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: 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"] },
       ],
@@ -1114,16 +1148,18 @@ const handlers = {
       branch: "main — the only branch. All changes land here directly.",
       checkpoints: "safe-YYYY-MM-DD-NNN tags mark safe rollback points. Create with ateam_github_promote().",
       iteration_workflow: {
-        code_changes: "ateam_github_patch (commits to main) → ateam_build_and_run(github:true) (pulls from main, redeploys)",
+        code_changes: "ateam_github_patch (one file at a time, commits to main) → ateam_build_and_run() (auto-pulls from GitHub, redeploys)",
         definition_changes: "ateam_patch (updates + redeploys + auto-pushes to main)",
         first_deploy: "Must include mcp_store — this creates the GitHub repo",
+        after_first_deploy: "NEVER pass mcp_store again. Write files via ateam_github_patch, then ateam_build_and_run() auto-detects the repo.",
         checkpoint: "ateam_github_promote(solution_id) — tag current state as a safe rollback point",
       },
       when_to_use_what: {
-        ateam_github_patch: "Edit connector source code on main (server.js, utils, package.json, UI assets)",
+        ateam_github_write: "Write/create connector files on main — ONE FILE PER CALL (server.js, package.json, UI assets). Use this after first deploy.",
+        ateam_github_patch: "Edit existing files with search/replace (surgical edits to large files)",
         ateam_patch: "Edit skill definitions (intents, tools, policy) — auto-pushes to main",
-        "ateam_build_and_run(github:true)": "Redeploy solution pulling latest connector code from main",
-        "ateam_build_and_run(mcp_store)": "First deploy or when you want to pass connector code inline",
+        "ateam_build_and_run()": "Redeploy — auto-pulls from GitHub if repo exists. No need to pass mcp_store or github flag.",
+        "ateam_build_and_run(mcp_store)": "FIRST DEPLOY ONLY — creates the GitHub repo. Never use mcp_store again after first deploy.",
         ateam_github_promote: "Create a checkpoint (safe-* tag) — use before risky changes",
         ateam_github_rollback: "Revert main to a previous checkpoint",
       },
@@ -1179,6 +1215,8 @@ const handlers = {
         "Dump raw spec unless requested",
         "Write connector code that starts a web server — connectors MUST use stdio transport",
         "Mention dev branch — there is no dev branch, everything is on main",
+        "Pass large connector code via mcp_store after the first deploy — use ateam_github_write/ateam_github_patch one file at a time instead",
+        "Try to pass ALL connector files at once in a single tool call — write them individually to GitHub",
       ],
     },
   }),
@@ -1257,32 +1295,76 @@ const handlers = {
   // Validates → Deploys → Health-checks → Optionally tests
   // One call replaces: validate_solution + deploy_solution + get_solution(health)
 
-  ateam_build_and_run: async ({ solution, skills, connectors, mcp_store, github, test_message, test_skill_id }, sid) => {
+  ateam_build_and_run: async ({ solution_id: solIdArg, solution: solutionArg, skills, connectors, mcp_store, github, test_message, test_skill_id }, sid) => {
+    let solution = solutionArg;
+    // If only solution_id passed (no full solution), we'll pull from GitHub
+    const solutionId = solution?.id || solIdArg;
+    if (!solutionId) {
+      return { ok: false, phase: "pre_check", error: "Provide either solution (object) or solution_id (string)." };
+    }
     const phases = [];
 
-    // Phase 0: GitHub pull (if github:true — pull connector source from repo)
+    // Guard: reject large mcp_store — agent should use github_patch instead
+    if (mcp_store) {
+      const totalSize = Object.values(mcp_store).reduce((sum, files) => {
+        return sum + (Array.isArray(files) ? files.reduce((s, f) => s + (f.content?.length || 0), 0) : 0);
+      }, 0);
+      if (totalSize > 200_000) {
+        return {
+          ok: false,
+          phase: "pre_check",
+          error: `mcp_store is too large (${Math.round(totalSize / 1024)}KB). Max ~200KB inline.`,
+          message: "Connector code is too large to pass inline. Write files individually to GitHub, then deploy from there.",
+          _fix: [
+            "1. Write each file: ateam_github_patch(solution_id, path: 'connectors/<id>/server.js', content: '...')",
+            "2. Repeat for package.json, UI assets, etc.",
+            "3. Deploy: ateam_build_and_run(solution, skills) — will auto-pull from GitHub",
+          ],
+        };
+      }
+    }
+
+    // Phase 0: Auto-detect GitHub repo — if no mcp_store passed and repo exists, pull bundle from GitHub
     let effectiveMcpStore = mcp_store;
+    let effectiveSkills = skills;
+    if (!mcp_store) {
+      try {
+        const ghStatus = await get(`/deploy/solutions/${solutionId}/github/status`, sid);
+        if (ghStatus?.repo_url) {
+          github = true;
+        }
+      } catch { /* no repo — first deploy, mcp_store expected */ }
+    }
     if (github && !mcp_store) {
       try {
         const pullResult = await post(
-          `/deploy/solutions/${solution.id}/github/pull-connectors`,
+          `/deploy/solutions/${solutionId}/github/pull-bundle`,
           {},
           sid,
-          { timeoutMs: 30_000 },
+          { timeoutMs: 60_000 },
         );
         if (!pullResult.ok) {
           return {
             ok: false,
             phase: "github_pull",
-            error: pullResult.error || "Failed to pull connectors from GitHub",
+            error: pullResult.error || "Failed to pull bundle from GitHub",
             hint: pullResult.hint || "Deploy the solution first (with mcp_store) to auto-create the GitHub repo.",
-            message: "Cannot pull connector code from GitHub. The repo may not exist yet — deploy with mcp_store first.",
+            message: "Cannot pull from GitHub. The repo may not exist yet — deploy with mcp_store first.",
           };
         }
-        effectiveMcpStore = pullResult.mcp_store;
+        effectiveMcpStore = pullResult.mcp_store || {};
+        // Use solution from GitHub if not passed inline
+        if (!solution && pullResult.solution) {
+          solution = pullResult.solution;
+        }
+        // Use skills from GitHub if not passed inline
+        if (!effectiveSkills?.length && pullResult.skills?.length) {
+          effectiveSkills = pullResult.skills;
+        }
         phases.push({
           phase: "github_pull",
           status: "done",
+          skills_found: pullResult.skills_found || 0,
           connectors_found: pullResult.connectors_found || 0,
           files_loaded: pullResult.files_loaded || 0,
         });
@@ -1291,15 +1373,35 @@ const handlers = {
           ok: false,
           phase: "github_pull",
           error: err.message,
-          message: "Failed to pull connector code from GitHub. The repo may not exist yet — deploy with mcp_store first.",
+          message: "Failed to pull from GitHub. The repo may not exist yet — deploy with mcp_store first.",
         };
       }
     }
 
+    // Guard: solution required (either inline or from GitHub)
+    if (!solution) {
+      return {
+        ok: false,
+        phase: "pre_check",
+        error: "No solution provided and none found in GitHub repo.",
+        message: "Pass solution inline or ensure solution.json exists in the GitHub repo.",
+      };
+    }
+
+    // Guard: skills required (either inline or from GitHub)
+    if (!effectiveSkills?.length) {
+      return {
+        ok: false,
+        phase: "pre_check",
+        error: "No skills provided and none found in GitHub repo.",
+        message: "Pass skills inline or ensure they exist in the GitHub repo (skills/{id}/skill.json).",
+      };
+    }
+
     // Phase 1: Validate
     let validation;
     try {
-      validation = await post("/validate/solution", { solution, skills, connectors, mcp_store: effectiveMcpStore }, sid, { timeoutMs: 120_000 });
+      validation = await post("/validate/solution", { solution, skills: effectiveSkills, connectors, mcp_store: effectiveMcpStore }, sid, { timeoutMs: 120_000 });
       phases.push({ phase: "validate", status: "done" });
     } catch (err) {
       return {
@@ -1325,7 +1427,7 @@ const handlers = {
     // Phase 2: Deploy
     let deploy;
     try {
-      deploy = await post("/deploy/solution", { solution, skills, connectors, mcp_store: effectiveMcpStore }, sid, { timeoutMs: 300_000, retries: 2 });
+      deploy = await post("/deploy/solution", { solution, skills: effectiveSkills, connectors, mcp_store: effectiveMcpStore }, sid, { timeoutMs: 300_000, retries: 2 });
       phases.push({ phase: "deploy", status: deploy.ok ? "done" : "failed" });
     } catch (err) {
       return {
@@ -1363,7 +1465,7 @@ const handlers = {
     // Phase 4: Warm test (optional)
     let test_result;
     if (test_message) {
-      const skillId = test_skill_id || skills?.[0]?.id;
+      const skillId = test_skill_id || effectiveSkills?.[0]?.id;
       if (skillId) {
         try {
           test_result = await post(
@@ -1648,6 +1750,9 @@ const handlers = {
   ateam_github_patch: async ({ solution_id, path: filePath, content, search, replace, message }, sid) =>
     post(`/deploy/solutions/${solution_id}/github/patch`, { path: filePath, content, search, replace, message }, sid),
 
+  ateam_github_write: async ({ solution_id, path: filePath, content, message }, sid) =>
+    post(`/deploy/solutions/${solution_id}/github/patch`, { path: filePath, content, message }, sid),
+
   ateam_github_log: async ({ solution_id, limit }, sid) => {
     const qs = limit ? `?limit=${limit}` : "";
     return get(`/deploy/solutions/${solution_id}/github/log${qs}`, sid);