@ateam-ai/mcp 0.3.21 → 0.3.23

package/package.json

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

@@ -303,7 +303,9 @@ export const tools = [
       "- Update problem: updates: { \"problem.statement\": \"...\", \"problem.goals\": [\"goal1\"] }\n" +
       "- Add a tool: updates: { \"tools_push\": [{ name: \"conn.tool\", description: \"...\", inputs: [...], output: {...} }] }\n" +
       "- Change intent: updates: { \"intents.supported_update\": [{ id: \"i1\", description: \"new desc\" }] }\n" +
-      "- Force redeploy: updates: { \"_force_redeploy\": true }\n\n" +
+      "- Force redeploy: updates: { \"_force_redeploy\": true }\n" +
+      "- CREATE a new skill: target='skill', skill_id='my-new-skill', updates: { \"problem.statement\": \"...\", \"role.persona\": \"...\" }\n" +
+      "  If the skill doesn't exist yet, a default scaffold is created and the updates are applied on top. The skill is automatically added to the solution topology.\n\n" +
       "Use target='skill' + skill_id for skill fields. Use target='solution' for solution-level fields (linked_skills, platform_connectors, ui_plugins).",
     inputSchema: {
       type: "object",
@@ -1244,6 +1246,56 @@ const handlers = {
       security: "https://ateam-ai.com/#security",
       engine: "https://ateam-ai.com/#engine",
     },
+    platform_connectors: {
+      _note: "Shared infrastructure MCPs available to all solutions. Reference by id in your solution's `platform_connectors` array; tools are automatically merged into every skill's tool catalog (no bridge needed). Do NOT bundle their source in mcp_store — they run as fixed Docker services on ADAS Core.",
+      available: [
+        {
+          id: "memory-mcp",
+          name: "Memory Engine",
+          purpose: "Long-term memory + ephemeral context, per-tenant per-actor",
+          tool_prefixes: ["memory.", "context."],
+          typical_use: "Store user preferences/facts, recall rules, persist working context across conversations",
+        },
+        {
+          id: "docs-index-mcp",
+          name: "Docs Index",
+          purpose: "Source-agnostic document corpus retrieval (chunking, embeddings, cosine search)",
+          tool_prefixes: ["docs.corpus.", "docs.ingest.", "docs.search", "docs.file.", "docs.sync.", "docs.stats"],
+          typical_use: "Index documents from any source (Dropbox, Gmail attachments, uploaded files), answer questions with retrieved chunks + citations. Fed by source connectors (e.g. dropbox-mcp) that call docs.ingest.file.",
+        },
+        {
+          id: "handoff-controller-mcp",
+          name: "Handoff Controller",
+          purpose: "Live conversation handoffs between skills in a multi-skill solution",
+          tool_prefixes: ["handoff."],
+          typical_use: "Pass a live conversation from one skill to another (e.g. identity-assurance → order-support), carrying grants",
+        },
+        {
+          id: "internal-comm-mcp",
+          name: "Internal Communication",
+          purpose: "Skill-to-skill messaging and voice replies",
+          tool_prefixes: ["comm."],
+          typical_use: "Async message between skills, or send a voice reply back through the Twilio channel",
+        },
+        {
+          id: "browser-mcp",
+          name: "Browser",
+          purpose: "Headless Chromium automation (Playwright)",
+          tool_prefixes: ["web."],
+          typical_use: "Navigate, read, click, type, screenshot any public web page; scrape data for enrichment",
+        },
+      ],
+      how_to_use: {
+        step_1: "Declare in solution: platform_connectors: [{ id: 'memory-mcp', required: true }]",
+        step_2: "Tools become available in the skill's tool catalog automatically — no code to write, no bridge needed",
+        step_3: "Reference tools in skill.tools[] with source.type='mcp_bridge', connection_id matching the connector id",
+      },
+      do_not: [
+        "Do NOT include platform connector source code in mcp_store — they're managed by the platform, not by your solution",
+        "Do NOT try to deploy a duplicate platform connector as a solution connector — use the platform one directly",
+        "Do NOT build stdio bridge connectors for platform services — the platform auto-merges their tools",
+      ],
+    },
     critical_connector_rules: {
       _note: "CRITICAL: Read this before writing ANY connector code. Violations are caught at deploy time and BLOCKED.",
       transport: "A-Team connectors use STDIO transport — child processes communicating via stdin/stdout JSON-RPC.",
@@ -1659,11 +1711,12 @@ const handlers = {
 
   ateam_patch: async ({ solution_id, target, skill_id, updates, test_message }, sid) => {
     const phases = [];
+    let isNewSkill = false;
 
     // GitHub-first patch: read from GitHub → apply patch → write back → redeploy
     // This ensures GitHub stays the single source of truth.
 
-    // Phase 1: Read current state from GitHub
+    // Phase 1: Read current state from GitHub (or create scaffold if new skill)
     let current;
     const filePath = target === "skill" && skill_id
       ? `skills/${skill_id}/skill.json`
@@ -1672,7 +1725,38 @@ const handlers = {
       const readResult = await get(`/deploy/solutions/${solution_id}/github/read?path=${encodeURIComponent(filePath)}`, sid);
       current = JSON.parse(readResult.content);
     } catch (err) {
-      return { ok: false, phase: "read", error: `Failed to read ${filePath} from GitHub: ${err.message}` };
+      // If it's a skill that doesn't exist yet, create a default scaffold.
+      // This lets agents use ateam_patch to both CREATE and UPDATE skills —
+      // no separate "create" step needed.
+      if (target === "skill" && skill_id) {
+        console.log(`[ateam_patch] Skill "${skill_id}" not found on GitHub — creating new skill scaffold`);
+        isNewSkill = true;
+        current = {
+          id: skill_id,
+          name: skill_id.replace(/-/g, " ").replace(/\b\w/g, c => c.toUpperCase()),
+          description: "",
+          version: "0.1.0",
+          phase: "PROBLEM_DISCOVERY",
+          connectors: [],
+          problem: { statement: "", context: "", goals: [] },
+          scenarios: [],
+          role: { name: "", persona: "", goals: [], limitations: [], communication_style: { tone: "professional", verbosity: "concise" } },
+          intents: { supported: [], thresholds: { accept: 0.8, clarify: 0.5, reject: 0.5 }, out_of_domain: { action: "redirect", message: "" } },
+          tools: [],
+          policy: { guardrails: { never: [], always: [] }, approvals: [], workflows: [], escalation: { enabled: false, conditions: [], target: "" } },
+          engine: { rv2: { max_iterations: 10, iteration_timeout_ms: 120000, allow_parallel_tools: false, on_max_iterations: "ask_user" }, hlr: { enabled: true, critic: { enabled: true, check_interval: 3, strictness: "medium" }, reflection: { enabled: true, depth: "shallow" }, replanning: { enabled: true, max_replans: 3 } }, autonomy: { level: "supervised" }, finalization_gate: { enabled: true, max_retries: 2 } },
+          access_policy: { rules: [{ tools: ["*"], effect: "allow" }] },
+          grant_mappings: [],
+          channels: [],
+          conversation: [],
+          triggers: [],
+          meta_tools: [],
+          glossary: {},
+        };
+        phases.push({ phase: "read", status: "created_scaffold", skill_id });
+      } else {
+        return { ok: false, phase: "read", error: `Failed to read ${filePath} from GitHub: ${err.message}` };
+      }
     }
 
     // Phase 2: Apply patch in memory
@@ -1730,23 +1814,52 @@ const handlers = {
       return { ok: false, phase: "github_write", error: `Patch applied but failed to write to GitHub: ${err.message}`, phases };
     }
 
-    // Phase 4: Redeploy from GitHub
+    // Phase 3b: If new skill, add it to solution.json topology (skills[], linked_skills)
+    if (isNewSkill && skill_id) {
+      try {
+        const solRead = await get(`/deploy/solutions/${solution_id}/github/read?path=solution.json`, sid);
+        const sol = JSON.parse(solRead.content);
+        const skillEntry = { id: skill_id, name: patched.name || skill_id, role: "worker", description: patched.description || "", connectors: patched.connectors || [] };
+        // Add to skills[] if not already present
+        if (!sol.skills) sol.skills = [];
+        if (!sol.skills.find(s => s.id === skill_id)) {
+          sol.skills.push(skillEntry);
+        }
+        // Add to linked_skills if not already present
+        if (!sol.linked_skills) sol.linked_skills = [];
+        if (!sol.linked_skills.includes(skill_id)) {
+          sol.linked_skills.push(skill_id);
+        }
+        await post(`/deploy/solutions/${solution_id}/github/patch`, {
+          path: "solution.json",
+          content: JSON.stringify(sol, null, 2),
+          message: `Add skill "${skill_id}" to solution topology`,
+        }, sid, { timeoutMs: 30_000 });
+        phases.push({ phase: "solution_topology", status: "done", added: skill_id });
+      } catch (err) {
+        // Non-fatal: skill.json was written, topology can be fixed manually
+        phases.push({ phase: "solution_topology", status: "warning", error: err.message });
+        console.warn(`[ateam_patch] Failed to add ${skill_id} to solution topology: ${err.message}`);
+      }
+    }
+
+    // Phase 4: Redeploy from GitHub (extended timeout — deploys can take 60-120s)
+    // IMPORTANT: if redeploy times out or fails, we return ok:true with a warning
+    // because the patch IS saved to GitHub — it's not lost. The agent can retry
+    // the redeploy with ateam_redeploy(solution_id, skill_id).
     let redeployResult;
     try {
       if (target === "skill" && skill_id) {
-        redeployResult = await post(`/deploy/solutions/${solution_id}/skills/${skill_id}/redeploy`, {}, sid);
+        redeployResult = await post(`/deploy/solutions/${solution_id}/skills/${skill_id}/redeploy`, {}, sid, { timeoutMs: 180_000 });
       } else {
-        redeployResult = await post(`/deploy/solutions/${solution_id}/redeploy`, {}, sid);
+        redeployResult = await post(`/deploy/solutions/${solution_id}/redeploy`, {}, sid, { timeoutMs: 180_000 });
       }
       phases.push({ phase: "redeploy", status: "done" });
     } catch (err) {
-      return {
-        ok: false,
-        phase: "redeploy",
-        phases,
-        error: err.message,
-        message: "Patch saved to GitHub but redeploy failed. Try ateam_redeploy manually.",
-      };
+      // Partial success: patch is saved to GitHub, only redeploy failed.
+      // Return ok:true so the agent doesn't think the patch was lost.
+      phases.push({ phase: "redeploy", status: "timeout_or_error", error: err.message });
+      console.warn(`[ateam_patch] Redeploy failed after successful patch: ${err.message}`);
     }
 
     // Phase 3: Optional re-test
@@ -1767,16 +1880,19 @@ const handlers = {
       }
     }
 
-    // Phase 4: Auto-push to main branch (non-blocking)
+    const redeployOk = phases.some(p => p.phase === "redeploy" && p.status === "done");
     return {
       ok: true,
       solution_id,
       branch: 'main',
       phases,
       patched: patched,
-      redeploy: redeployResult,
+      ...(isNewSkill && { created_skill: skill_id }),
+      ...(redeployResult && { redeploy: redeployResult }),
       ...(test_result && { test_result }),
-      _status: '✅ Patched on GitHub + redeployed.',
+      _status: redeployOk
+        ? '✅ Patched on GitHub + redeployed.'
+        : '⚠️ Patched on GitHub ✅ but redeploy timed out. Run: ateam_redeploy(solution_id' + (skill_id ? `, skill_id: "${skill_id}"` : '') + ')',
       _next: 'Create a checkpoint before making more changes: ateam_github_promote(solution_id)',
     };
   },