@myvillage/cli 1.10.2 → 1.18.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myvillage/cli",
-  "version": "1.10.2",
+  "version": "1.18.0",
   "description": "MyVillageOS CLI for community developers",
   "type": "module",
   "bin": {

package/src/agent-runtime/loop.js

@@ -12,7 +12,8 @@ import { getMCPTools, cleanupMCPClients } from './mcp-client.js';
 import { gatherContext } from './context.js';
 import { isWithinActiveHours, getNextCheckInMs } from './scheduler.js';
 import { parse as parseYaml } from 'yaml';
-import { postAgentHeartbeat } from '../utils/api.js';
+import { postAgentHeartbeat, listAgentTasks, claimAgentTask, completeAgentTask } from '../utils/api.js';
+import { readAgentWisdom } from '../utils/wisdom.js';
 
 export async function agentLoop(agentName, { signal }) {
   const agentDir = join(homedir(), '.myvillage', 'agents', agentName);
@@ -107,19 +108,55 @@ export async function agentLoop(agentName, { signal }) {
     };
     let feedItemsRead = 0;
     let mentionsFound = 0;
+    // Hoisted so the catch block can mark in-flight tasks FAILED.
+    let activeTask = null;
+    // Tracks whether the task's tool calls actually succeeded. The LLM
+    // sometimes "summarizes" a tool error into a falsely-confident final
+    // response — we don't want to trust the model's word about success.
+    const taskActionAudit = {
+      actionToolsCalled: 0,
+      actionToolsSucceeded: 0,
+      toolErrors: [], // { tool, message }
+    };
 
     try {
       // Read prompt.md fresh each iteration (villager may have edited it)
       const promptPath = join(agentDir, 'prompt.md');
-      const systemPrompt = existsSync(promptPath)
+      const basePrompt = existsSync(promptPath)
         ? readFileSync(promptPath, 'utf-8')
         : `You are an agent named ${config.display_name || agentName}. Be helpful and concise.`;
 
+      // Append wisdom skills to the system prompt. We inline the full bodies
+      // for v1 — agent skill packs are small and this keeps the loop simple.
+      // (If they grow large, switch to lazy-load via a `wisdom_load` tool.)
+      const wisdom = readAgentWisdom(agentName);
+      let systemPrompt = basePrompt;
+      if (wisdom.length > 0) {
+        const skills = wisdom.map(w => {
+          const header = `### Skill: ${w.name}${w.description ? ` — ${w.description}` : ''}${w.trigger ? `\nWhen: ${w.trigger}` : ''}`;
+          return `${header}\n\n${w.body.trim()}`;
+        }).join('\n\n---\n\n');
+        systemPrompt = `${basePrompt}\n\n## Available Skills\n\nThese are skill packs you can apply when the trigger matches the current situation.\n\n${skills}`;
+        logActivity(agentDir, { type: 'wisdom_loaded', count: wisdom.length, names: wisdom.map(w => w.name) });
+      }
+
+      // Try to pull an assigned task first. Tasks take priority over ambient
+      // feed-monitoring. If nothing is queued, fall through to the default.
+      if (config.man?.village_agent_id) {
+        activeTask = await pollAndClaim(config.man.village_agent_id, agentDir);
+      }
+
       // Gather context (returns { text, mentionsCount })
       const contextResult = await gatherContext(config, lastCheckIn, recentActions);
-      const context = contextResult.text;
+      let context = contextResult.text;
       mentionsFound = contextResult.mentionsCount;
 
+      if (activeTask) {
+        const taskLine = `TASK ${activeTask.id} (${activeTask.taskType}): ${activeTask.instruction || JSON.stringify(activeTask.input || {})}`;
+        context = `${taskLine}\n\n${context}`;
+        logActivity(agentDir, { type: 'task_claimed', taskId: activeTask.id, taskType: activeTask.taskType });
+      }
+
       // Count feed items from context
       feedItemsRead = (context.match(/^- @/gm) || []).length;
 
@@ -149,7 +186,8 @@ export async function agentLoop(agentName, { signal }) {
         },
       });
 
-      // Log tool calls and count activity
+      // Log tool calls and count activity. Also audit action-tool success
+      // so we don't trust the model's final text about whether a task worked.
       if (result.steps?.length) {
         for (const step of result.steps) {
           if (step.toolCalls?.length) {
@@ -164,19 +202,25 @@ export async function agentLoop(agentName, { signal }) {
             for (let i = 0; i < step.toolResults.length; i++) {
               const tr = step.toolResults[i];
               const args = step.toolCalls[i]?.args;
+              const errored = isToolResultError(tr);
+              auditToolCall(taskActionAudit, tr.toolName, errored, tr);
               logActivity(agentDir, {
                 type: 'tool_call',
                 tool: tr.toolName,
                 args,
-                result: typeof tr.result === 'string' ? tr.result.slice(0, 200) : 'ok',
+                result: summarizeToolResult(tr),
+                ok: !errored,
               });
             }
           } else if (step.toolResults?.length) {
             for (const tr of step.toolResults) {
+              const errored = isToolResultError(tr);
+              auditToolCall(taskActionAudit, tr.toolName, errored, tr);
               logActivity(agentDir, {
                 type: 'tool_call',
                 tool: tr.toolName,
-                result: typeof tr.result === 'string' ? tr.result.slice(0, 200) : 'ok',
+                result: summarizeToolResult(tr),
+                ok: !errored,
               });
             }
           }
@@ -187,6 +231,7 @@ export async function agentLoop(agentName, { signal }) {
           if (tc.toolName === 'post_create') activity.postsCreated++;
           if (tc.toolName === 'comment_create') activity.commentsCreated++;
           if (tc.toolName === 'vote_cast') activity.votesGiven++;
+          // No paired result here — assume executed, can't audit.
           logActivity(agentDir, {
             type: 'tool_call',
             tool: tc.toolName,
@@ -220,6 +265,53 @@ export async function agentLoop(agentName, { signal }) {
       // Keep only last 50 actions to bound memory
       if (recentActions.length > 50) recentActions.splice(0, recentActions.length - 50);
 
+      // If a task was being processed, decide success vs. failure based on
+      // whether the action tools actually succeeded — not on the model's
+      // self-report. The LLM sometimes claims "I posted!" after a tool error.
+      if (activeTask && config.man?.village_agent_id) {
+        const shouldFail =
+          taskActionAudit.actionToolsCalled > 0 &&
+          taskActionAudit.actionToolsSucceeded === 0;
+
+        try {
+          if (shouldFail) {
+            const firstError = taskActionAudit.toolErrors[0];
+            const errorMessage = firstError
+              ? `${firstError.tool} failed: ${firstError.message}`
+              : 'Action tools called but all failed';
+            await completeAgentTask(config.man.village_agent_id, activeTask.id, {
+              errorMessage,
+              output: {
+                text: result.text || '',
+                toolCalls: activity.toolCalls,
+                toolErrors: taskActionAudit.toolErrors,
+                note: 'Marked FAILED because the action tools did not succeed. The model\'s text may claim success but the underlying tool calls errored.',
+              },
+              tokensUsed: (result.usage?.promptTokens || 0) + (result.usage?.completionTokens || 0),
+              durationMs: Date.now() - loopStart,
+            });
+            logActivity(agentDir, {
+              type: 'task_failed',
+              taskId: activeTask.id,
+              reason: errorMessage,
+            });
+          } else {
+            await completeAgentTask(config.man.village_agent_id, activeTask.id, {
+              output: {
+                text: result.text || '',
+                toolCalls: activity.toolCalls,
+                toolErrors: taskActionAudit.toolErrors.length > 0 ? taskActionAudit.toolErrors : undefined,
+              },
+              tokensUsed: (result.usage?.promptTokens || 0) + (result.usage?.completionTokens || 0),
+              durationMs: Date.now() - loopStart,
+            });
+            logActivity(agentDir, { type: 'task_completed', taskId: activeTask.id });
+          }
+        } catch (taskErr) {
+          logActivity(agentDir, { type: 'error', error: `Failed to mark task complete: ${taskErr.message}` });
+        }
+      }
+
       // Send server-side heartbeat
       if (config.man?.agent_id) {
         try {
@@ -242,6 +334,18 @@ export async function agentLoop(agentName, { signal }) {
         type: 'error',
         error: err.message,
       });
+      // If a task was in flight when we crashed, mark it FAILED so it isn't lost
+      if (activeTask && config.man?.village_agent_id) {
+        try {
+          await completeAgentTask(config.man.village_agent_id, activeTask.id, {
+            errorMessage: err.message,
+            durationMs: Date.now() - loopStart,
+          });
+          logActivity(agentDir, { type: 'task_failed', taskId: activeTask.id });
+        } catch {
+          // best-effort
+        }
+      }
     }
 
     lastCheckIn = new Date().toISOString();
@@ -288,6 +392,111 @@ function updateHeartbeat(agentDir) {
   }
 }
 
+// ── Tool result auditing ───────────────────────────────────────────
+// The Vercel AI SDK returns tool results in a few different shapes
+// depending on the underlying transport. These helpers normalise them
+// so we can detect errors regardless of which path is in play.
+
+// Tools that take a real, externally-visible action on the platform.
+// We use this set to decide whether a task that ran but didn't actually
+// succeed (e.g. a 404 from post_create) should be marked FAILED.
+const ACTION_TOOLS = new Set([
+  'post_create',
+  'comment_create',
+  'vote_cast',
+  'knowledge_submit',
+  'community_join',
+  'community_leave',
+  'community_event_create',
+  'community_event_register',
+  'community_event_unregister',
+  'community_event_cancel',
+  'moment_create',
+  'pulse_create',
+  'agent_join_community',
+  'agent_leave_community',
+  'wallet_send',
+  'wallet_tip',
+  'wisdom_import',
+  'task_assign',
+  'task_complete',
+  'task_retry',
+]);
+
+function flattenToolResultText(tr) {
+  if (!tr) return '';
+  const r = tr.result;
+  if (typeof r === 'string') return r;
+  if (Array.isArray(r?.content)) {
+    return r.content
+      .map(c => (typeof c === 'string' ? c : c?.text || ''))
+      .filter(Boolean)
+      .join(' ');
+  }
+  try { return JSON.stringify(r); } catch { return ''; }
+}
+
+function isToolResultError(tr) {
+  if (!tr) return false;
+  // Explicit MCP / Vercel AI SDK error flags
+  if (tr.isError === true) return true;
+  if (tr.result?.isError === true) return true;
+  if (Array.isArray(tr.result?.content) && tr.result.content.some(c => c?.isError === true)) {
+    return true;
+  }
+  // Heuristic fallback: look for HTTP-error and well-known failure phrases
+  // in the result text. Conservative; doesn't false-positive on prose like
+  // "the user was unauthorized to do X" because we anchor on word boundaries.
+  const text = flattenToolResultText(tr);
+  if (!text) return false;
+  return /\b(40[0-9]|50[0-9])\b/.test(text) ||
+    /\b(not found|unauthorized|forbidden|invalid|insufficient_quota|authentication failed)\b/i.test(text);
+}
+
+function auditToolCall(audit, toolName, errored, tr) {
+  if (ACTION_TOOLS.has(toolName)) {
+    audit.actionToolsCalled++;
+    if (!errored) {
+      audit.actionToolsSucceeded++;
+    }
+  }
+  if (errored) {
+    audit.toolErrors.push({
+      tool: toolName,
+      message: flattenToolResultText(tr).slice(0, 300) || 'unknown error',
+    });
+  }
+}
+
+function summarizeToolResult(tr) {
+  const text = flattenToolResultText(tr);
+  if (!text) return 'ok';
+  return text.slice(0, 200);
+}
+
+// Pull up to 5 pending tasks and claim the first one we can win the race for.
+// Returns the claimed task or null. Errors are swallowed and logged — the loop
+// should keep running on transient backend issues.
+async function pollAndClaim(villageAgentId, agentDir) {
+  try {
+    const result = await listAgentTasks(villageAgentId, { status: 'PENDING', limit: 5 });
+    const pending = result.tasks || [];
+    if (pending.length === 0) return null;
+    for (const task of pending) {
+      try {
+        const claim = await claimAgentTask(villageAgentId, task.id);
+        return claim.data || task;
+      } catch {
+        // Race lost (409) or transient — try the next task
+      }
+    }
+    return null;
+  } catch (err) {
+    logActivity(agentDir, { type: 'error', error: `Task poll failed: ${err.message}` });
+    return null;
+  }
+}
+
 function sleep(ms, signal) {
   return new Promise((resolve) => {
     if (signal?.aborted) { resolve(); return; }