@ateam-ai/mcp 0.4.29 → 0.4.31

package/package.json

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

@@ -102,14 +102,14 @@ function _summarizeDef(def) {
     ...(def.connectors && { connectors: pick(def.connectors, "id") }),
     ...(def.platform_connectors && { platform_connectors: pick(def.platform_connectors, "id") }),
     ...(def.ui_plugins && { ui_plugins: pick(def.ui_plugins, "id") }),
-    ...(def.tools && { tools: pick(def.tools, "name") }),
-    // OPEN-20: connector-imported tools don't all appear as literal entries in
-    // `tools` — they come from `toolbox_imports` and/or wildcard entries like
-    // "connector-id:*" that EXPAND to every tool of that connector at runtime.
-    // Surface both so an agent doesn't read a real runtime tool as "missing".
-    ...(def.toolbox_imports && { toolbox_imports: pick(def.toolbox_imports, "connector_id") || def.toolbox_imports }),
-    ...((Array.isArray(def.tools) && def.tools.some((t) => typeof (t?.name) === "string" && t.name.endsWith(":*"))) && {
-      _tools_note: "Entries ending ':*' (or toolbox_imports) grant ALL of that connector's tools at RUNTIME — the specific tool names (e.g. 'connector.foo.get') are callable even though they aren't listed literally here. Verify with a live test_skill / connectors_health, not this summary.",
+    // OPEN-20: `tools` here are the DECLARED tools only. A skill's REAL callable
+    // set also includes every tool of each connector in `connectors[]` — Core
+    // auto-imports those at deploy, so they're callable at runtime even though
+    // they're NOT listed here. So this summary UNDER-reports the toolset; don't
+    // read a connector tool's absence as "missing".
+    ...(def.tools && { tools_declared: pick(def.tools, "name") }),
+    ...((Array.isArray(def.connectors) && def.connectors.length > 0) && {
+      _tools_note: `Callable tools = tools_declared + ALL tools from linked connectors [${pick(def.connectors, "id").join(", ")}] (Core auto-imports them at deploy — NOT listed above). For the real runtime set use ateam_get_solution(view:"connectors_health") or a live ateam_test_skill; a connector tool (e.g. 'connector.foo.get') is callable via the LINK even if it isn't in tools_declared.`,
     }),
     _fields: Object.keys(def),
     _note: "compact summary — pass include_definition:true to ateam_patch for the full definition.",
@@ -3159,6 +3159,8 @@ const handlers = {
   ateam_patch: async ({ solution_id, target, skill_id, updates, test_message, dry_run, source, include_definition }, sid) => {
     const phases = [];
     let isNewSkill = false;
+    let _connectorToolPush = null;
+    let writeBranch = "dev"; // github/patch default; overwritten by the actual response branch
     const _diff = { arrays_merged: [], arrays_replaced: [], scalars_changed: [], sections_replaced: [] };
 
     // Two backing stores, chosen EXPLICITLY by `source` (never inferred):
@@ -3258,6 +3260,18 @@ const handlers = {
           const field = key.replace(/_push$/, "");
           const { parent, leaf } = _resolveDottedField(patched, field);
           parent[leaf] = [...(Array.isArray(parent[leaf]) ? parent[leaf] : []), ...value];
+          // Record the merge so a successful push is NOT reported as an empty
+          // diff / silent no-op (OPEN-21 reporting gap).
+          _diff.arrays_merged.push({ field, added: value.length });
+          // OPEN-21: a connector's tools are granted by LINKING the connector
+          // (connectors_push), NOT by pushing a definition into tools[]. Flag an
+          // obviously connector-served push so we can redirect the agent.
+          if (field === "tools") {
+            const connectorish = value
+              .filter((t) => t?.source?.type === "mcp_bridge" || (typeof t?.name === "string" && t.name.endsWith(":*")))
+              .map((t) => t?.name).filter(Boolean);
+            if (connectorish.length) _connectorToolPush = connectorish;
+          }
         } else if (key.endsWith("_delete")) {
           if (!Array.isArray(value)) {
             return { ok: false, phase: "patch", error: `${key} requires an array of names/ids (got ${typeof value}). Pass {"${key}": ["name1", "name2"]}.` };
@@ -3403,12 +3417,17 @@ const handlers = {
           phases.push({ phase: "local_write", status: "done" });
         }
       } else {
-        await post(`/deploy/solutions/${solution_id}/github/patch`, {
+        // github/patch writes to `dev` by default (agents don't edit prod
+        // directly). Capture the ACTUAL branch it committed to — do NOT assume
+        // 'main'; mislabeling it strands the change off `main` until an explicit
+        // ateam_github_promote (was: the result hardcoded branch:"main").
+        const ghResp = await post(`/deploy/solutions/${solution_id}/github/patch`, {
           path: filePath,
           content: JSON.stringify(patched, null, 2),
           message,
         }, sid, { timeoutMs: 30_000 });
-        phases.push({ phase: "github_write", status: "done" });
+        writeBranch = ghResp?.branch || writeBranch;
+        phases.push({ phase: "github_write", status: "done", branch: writeBranch });
       }
     } catch (err) {
       const store = isLocal ? "Builder store (local)" : "GitHub";
@@ -3507,7 +3526,12 @@ const handlers = {
       ok: true,
       solution_id,
       source: isLocal ? "local" : "github",
-      ...(isLocal ? {} : { branch: 'main' }),
+      ...(isLocal ? {} : {
+        branch: writeBranch,
+        // Be explicit: a github write lands on `dev`, not prod. The change is
+        // NOT on `main` until an explicit ateam_github_promote(dev→main).
+        ...(writeBranch !== "main" && { _branch_note: `Committed to "${writeBranch}" (not main). Run ateam_github_promote(solution_id) to ship dev→main; otherwise a future build_and_run(main) won't include this.` }),
+      }),
       phases,
       // The full patched definition can be 10s of KB and pushes the rest of the
       // result (redeploy status, widget_health) past the ~50KB output ceiling,
@@ -3516,6 +3540,11 @@ const handlers = {
       ...(include_definition
         ? { patched }
         : { patched_summary: _summarizeDef(patched) }),
+      _diff,
+      ...(_connectorToolPush && {
+        _connector_tool_hint:
+          `Heads up: ${_connectorToolPush.join(", ")} look like CONNECTOR-served tools. A skill gains a connector's tools by LINKING the connector — updates:{ "connectors_push": ["<connector-id>"] } — NOT by pushing a definition into tools[]; Core auto-imports the connector's live tools at deploy. tools_push is only for the skill's OWN tool definitions.`,
+      }),
       ...(isNewSkill && { created_skill: skill_id }),
       ...(redeployResult && { redeploy: redeployResult }),
       ...(widget_health && { widget_health }),