agent-planner-mcp 1.5.9 → 1.5.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-planner-mcp",
-  "version": "1.5.9",
+  "version": "1.5.12",
   "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/desires.js

@@ -7,7 +7,7 @@
  * directly — no UI round-trip and no forced approval gate.
  */
 
-const { asOf, formatResponse, errorResponse, safeArray } = require('./_shared');
+const { asOf, formatResponse, errorResponse, safeArray, apiErrorMessage } = require('./_shared');
 
 const listGoalsDefinition = {
   name: 'list_goals',
@@ -110,11 +110,20 @@ async function updateGoalHandler(args, apiClient) {
   const applied = [];
   const failures = [];
 
-  // Direct field updates
+  // Direct field updates. title/description/priority/status share their name
+  // with the backend, but success_criteria must be camelCased to successCriteria
+  // — the goal update schema is .strict(), so the snake_case key was rejected
+  // with a 400 (the one multi-word field, hence "description writes but
+  // success_criteria fails"). Match the create shape: wrap a bare array as
+  // { criteria: [...] }.
   const directFields = {};
-  for (const k of ['title', 'description', 'priority', 'status', 'success_criteria']) {
+  for (const k of ['title', 'description', 'priority', 'status']) {
     if (changes[k] !== undefined) directFields[k] = changes[k];
   }
+  if (changes.success_criteria !== undefined) {
+    const sc = changes.success_criteria;
+    directFields.successCriteria = Array.isArray(sc) ? { criteria: sc } : sc;
+  }
   // Map the public `committed` boolean onto the backend's commitment write
   // (the API still accepts the legacy goalType field and translates it to
   // promoted_at). committed:true ⇒ promoted, false ⇒ aspirational.
@@ -127,21 +136,21 @@ async function updateGoalHandler(args, apiClient) {
       await apiClient.goals.update(goal_id, directFields);
       applied.push('direct_fields');
     } catch (err) {
-      failures.push({ step: 'direct_fields', error: err.message });
+      failures.push({ step: 'direct_fields', error: apiErrorMessage(err) });
     }
   }
 
   for (const planId of safeArray(changes.add_linked_plans)) {
     try { await apiClient.goals.linkPlan(goal_id, planId); applied.push(`link_plan:${planId}`); }
-    catch (err) { failures.push({ step: `link_plan:${planId}`, error: err.message }); }
+    catch (err) { failures.push({ step: `link_plan:${planId}`, error: apiErrorMessage(err) }); }
   }
   for (const planId of safeArray(changes.remove_linked_plans)) {
     try { await apiClient.goals.unlinkPlan(goal_id, planId); applied.push(`unlink_plan:${planId}`); }
-    catch (err) { failures.push({ step: `unlink_plan:${planId}`, error: err.message }); }
+    catch (err) { failures.push({ step: `unlink_plan:${planId}`, error: apiErrorMessage(err) }); }
   }
   for (const nodeId of safeArray(changes.add_achievers)) {
     try { await apiClient.goals.addAchiever(goal_id, nodeId); applied.push(`add_achiever:${nodeId}`); }
-    catch (err) { failures.push({ step: `add_achiever:${nodeId}`, error: err.message }); }
+    catch (err) { failures.push({ step: `add_achiever:${nodeId}`, error: apiErrorMessage(err) }); }
   }
   for (const nodeId of safeArray(changes.remove_achievers)) {
     try {
@@ -152,7 +161,7 @@ async function updateGoalHandler(args, apiClient) {
         applied.push(`remove_achiever:${nodeId}`);
       }
     } catch (err) {
-      failures.push({ step: `remove_achiever:${nodeId}`, error: err.message });
+      failures.push({ step: `remove_achiever:${nodeId}`, error: apiErrorMessage(err) });
     }
   }
 

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).
@@ -209,15 +229,21 @@ async function resolveDecisionHandler(args, apiClient) {
   if (action === 'approve' && decision?.metadata?.proposed_subtasks?.length) {
     for (const proposal of decision.metadata.proposed_subtasks) {
       try {
+        // createNode's schema is .strict() and has no acceptance_criteria field —
+        // sending it 400s the whole subtask. Fold it into the description so the
+        // criteria survive instead of being silently dropped on approval.
+        const description = [
+          proposal.description,
+          proposal.acceptance_criteria ? `Acceptance criteria: ${proposal.acceptance_criteria}` : null,
+        ].filter(Boolean).join('\n\n') || undefined;
         const node = await apiClient.nodes.createNode(plan_id, {
           parent_id: proposal.parent_id,
           node_type: proposal.node_type || 'task',
           title: proposal.title,
-          description: proposal.description,
+          description,
           status: 'not_started',
           task_mode: proposal.task_mode || 'free',
           agent_instructions: proposal.agent_instructions,
-          acceptance_criteria: proposal.acceptance_criteria,
         });
         created.push({ id: node.id || node.node?.id, title: proposal.title, parent_id: proposal.parent_id });
       } catch (err) {
@@ -254,6 +280,12 @@ const STATUS_TO_LOG_TYPE = {
   plan_ready: 'progress',
 };
 
+// The backend log endpoint accepts comment/progress/reasoning/decision/challenge.
+// Two friendly aliases the tool historically advertised are NOT valid there and
+// 400'd the log step — map them to the closest valid type.
+const LOG_TYPE_ALIASES = { blocker: 'challenge', completion: 'progress' };
+const normalizeLogType = (lt) => (lt ? (LOG_TYPE_ALIASES[lt] || lt) : lt);
+
 const updateTaskDefinition = {
   name: 'update_task',
   description:
@@ -275,8 +307,9 @@ const updateTaskDefinition = {
       log_message: { type: 'string', description: 'Optional progress note' },
       log_type: {
         type: 'string',
-        enum: ['progress', 'decision', 'blocker', 'completion', 'challenge'],
-        description: "Defaults from status: blocked→challenge, others→progress.",
+        enum: ['progress', 'reasoning', 'decision', 'challenge', 'comment'],
+        description: "Defaults from status: blocked→challenge, others→progress. "
+          + "Legacy 'blocker'/'completion' are accepted and mapped to challenge/progress.",
       },
       release_claim: {
         type: 'boolean',
@@ -324,7 +357,7 @@ async function updateTaskHandler(args, apiClient) {
       const data = await apiClient.v1.updateTask(task_id, {
         status,
         log_message,
-        log_type: args.log_type,
+        log_type: normalizeLogType(args.log_type),
         release_claim,
         add_learning,
       });
@@ -370,7 +403,7 @@ async function updateTaskHandler(args, apiClient) {
 
   // 2. Log entry
   if (log_message) {
-    const logType = args.log_type || STATUS_TO_LOG_TYPE[status] || 'progress';
+    const logType = normalizeLogType(args.log_type) || STATUS_TO_LOG_TYPE[status] || 'progress';
     try {
       const log = await apiClient.logs.addLogEntry(planId, task_id, {
         content: log_message,
@@ -698,6 +731,13 @@ async function addLearningHandler(args, apiClient) {
       plan_id: scope.plan_id,
       node_id: scope.node_id,
       entity_type: entry_type,
+      // The episodes endpoint only persists {content,name,plan_id,node_id,metadata};
+      // the top-level entry_type/source_description were silently dropped. Carry
+      // the categorization in metadata so it survives on the stored episode.
+      metadata: {
+        entry_type,
+        source_description: source_description || 'BDI add_learning',
+      },
     });
     return formatResponse({
       as_of: asOf(),