agent-planner-mcp 1.5.8 → 1.5.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-planner-mcp",
-  "version": "1.5.8",
+  "version": "1.5.10",
   "description": "MCP server for AgentPlanner — AI agent orchestration with planning, dependencies, knowledge graphs, and human oversight",
   "main": "src/index.js",
   "bin": {

package/src/tools/bdi/_shared.js

@@ -26,6 +26,22 @@ function safeArray(value) {
   return Array.isArray(value) ? value : [];
 }
 
+/**
+ * Extract the most actionable message from an axios error. The AP backend's
+ * validation errors carry a field-level `message` (e.g. "urgency: must be one
+ * of ...; options.0: Unrecognized key") plus a `details` array — far more
+ * useful than the generic top-line `error` ("Validation failed"), which is all
+ * most handlers surfaced. Prefer message → error → err.message.
+ */
+function apiErrorMessage(err) {
+  const data = err?.response?.data;
+  if (data) {
+    if (data.message && data.message !== data.error) return data.message;
+    if (typeof data.error === 'string') return data.error;
+  }
+  return err?.message || 'unknown error';
+}
+
 /**
  * The web app origin (where /app/plans/:id lives), for building shareable plan
  * links agents can post (e.g. to Slack). Derived from API_URL — the web app
@@ -56,4 +72,4 @@ function isV1Unavailable(err) {
   return !(body && typeof body === 'object' && body.error);
 }
 
-module.exports = { asOf, formatResponse, errorResponse, safeArray, isV1Unavailable, webOrigin, planUrl };
+module.exports = { asOf, formatResponse, errorResponse, safeArray, apiErrorMessage, isV1Unavailable, webOrigin, planUrl };

package/src/tools/bdi/intentions.js

@@ -13,7 +13,7 @@
  * See ../../../docs/MCP_v1.0_FULL_SURFACE.md for design rationale.
  */
 
-const { asOf, formatResponse, errorResponse, isV1Unavailable, planUrl } = require('./_shared');
+const { asOf, formatResponse, errorResponse, apiErrorMessage, isV1Unavailable, planUrl } = require('./_shared');
 const { version: PKG_VERSION } = require('../../../package.json');
 
 // Provenance tag stamped onto every plan this server creates, so a plan stays
@@ -108,14 +108,37 @@ async function queueDecisionHandler(args, apiClient) {
     return errorResponse('invalid_arg', 'queue_decision requires either plan_id or node_id');
   }
 
+  // The agent-facing urgency vocabulary (low/normal/high) differs from the
+  // backend decision schema (blocking/can_continue/informational) — map it, or
+  // every call fails strict validation.
+  const URGENCY_MAP = { low: 'informational', normal: 'can_continue', high: 'blocking' };
+  const mappedUrgency = URGENCY_MAP[urgency] || 'can_continue';
+
+  // The backend decisionOption shape is {option, pros?, cons?, recommendation?}
+  // and is .strict() — our {label, description} would be rejected. Fold
+  // description into the option text and mark the recommended one.
+  const recText = String(recommendation || '').toLowerCase();
+  const mappedOptions = Array.isArray(options)
+    ? options
+        .map((o) => {
+          const label = o.label || o.option || '';
+          const option = o.description ? `${label} — ${o.description}` : label;
+          const isRecommended = label && recText.includes(label.toLowerCase());
+          return option ? { option, ...(isRecommended ? { recommendation: true } : {}) } : null;
+        })
+        .filter(Boolean)
+    : [];
+
   const body = {
     title,
     context,
-    options: options || [],
-    recommendation: recommendation || null,
-    urgency: urgency || 'normal',
+    options: mappedOptions,
+    urgency: mappedUrgency,
+    // Top-level `recommendation` is not in the strict schema — keep the agent's
+    // free-text recommendation and ask in metadata instead.
     metadata: {
       smallest_input_needed,
+      recommendation: recommendation || null,
       goal_id: goal_id || null,
       source: 'bdi.queue_decision',
       proposed_subtasks: Array.isArray(proposed_subtasks) ? proposed_subtasks : undefined,
@@ -136,10 +159,7 @@ async function queueDecisionHandler(args, apiClient) {
       title: created.title,
     });
   } catch (err) {
-    return errorResponse(
-      'upstream_unavailable',
-      `Failed to queue decision: ${err.response?.data?.error || err.message}`
-    );
+    return errorResponse('upstream_unavailable', `Failed to queue decision: ${apiErrorMessage(err)}`);
   }
 }
 
@@ -187,20 +207,20 @@ async function resolveDecisionHandler(args, apiClient) {
     // Best-effort — if fetch fails, we still try to resolve.
   }
 
+  // The backend resolve schema is strict {decision, rationale}. Encode the
+  // action (+ chosen option) into `decision` and the note into `rationale` —
+  // the previous {resolution, message, selected_option} body was rejected.
+  const decisionText = selected_option ? `${action} — ${selected_option}` : action;
   let resolved;
   try {
     resolved = await apiClient.axiosInstance
       .post(`/plans/${plan_id}/decisions/${decision_id}/resolve`, {
-        resolution: action,
-        message: message || null,
-        selected_option: selected_option || null,
+        decision: decisionText,
+        rationale: message || undefined,
       })
       .then((r) => r.data);
   } catch (err) {
-    return errorResponse(
-      'upstream_unavailable',
-      `Failed to resolve decision: ${err.response?.data?.error || err.message}`
-    );
+    return errorResponse('upstream_unavailable', `Failed to resolve decision: ${apiErrorMessage(err)}`);
   }
 
   // On approve, materialize any proposed_subtasks atomically (best-effort per task).
@@ -738,6 +758,15 @@ function validateTreeShape(tree, depth = 0) {
   return null;
 }
 
+// Count every node in a returned tree, recursing through `children`. The facade
+// response's `tree` is the array of top-level nodes; `tree.length` alone counts
+// only those (e.g. 2 phases) and contradicts structure.task_count, so report
+// the true recursive total.
+function countTreeNodes(tree) {
+  if (!Array.isArray(tree)) return 0;
+  return tree.reduce((sum, node) => sum + 1 + countTreeNodes(node?.children), 0);
+}
+
 const formIntentionDefinition = {
   name: 'form_intention',
   description:
@@ -862,7 +891,7 @@ async function formIntentionHandler(args, apiClient) {
         goal_id,
         status: result.plan?.status || status,
         is_draft: (result.plan?.status || status) === 'draft',
-        nodes_created: Array.isArray(result.tree) ? result.tree.length : undefined,
+        nodes_created: Array.isArray(result.tree) ? countTreeNodes(result.tree) : undefined,
         next_step: (result.plan?.status || status) === 'draft'
           ? "Plan created as draft. Will surface in dashboard pending for human review. Auto-promotes to active when first task moves to in_progress."
           : `Plan active. Claim a task with claim_next_task({plan_id}) to begin work. Shareable link: ${planUrl(facadePlanId)} (set visibility:'unlisted' for a rich Slack/social preview).`,