@myvillage/cli 1.70.0 → 1.72.0

package/package.json

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

package/src/agent-runtime/builtin-tools-registry.js

@@ -18,6 +18,12 @@ export const DATASET_APPEND_DESCRIPTION =
   'regression provide a numeric `target`. Data stays local; provenance ' +
   'is recorded automatically.';
 
+export const MODEL_PREDICT_DESCRIPTION =
+  'Run a prediction with a LOCAL trained model on this machine. ' +
+  'Returns the predicted class with per-class confidence scores ' +
+  '(classification) or a numeric value (regression). The model must already ' +
+  'exist (trained in the Studio Lab or via `myvillage model train`).';
+
 /** All native built-in tools available to every local agent. */
 export const BUILTIN_TOOL_DEFS = [
   {
@@ -26,5 +32,10 @@ export const BUILTIN_TOOL_DEFS = [
     tier: 'villager',
     builtin: true,
   },
-  // model_predict lands here when L3 (use a trained model as a tool) ships.
+  {
+    name: 'model_predict',
+    description: MODEL_PREDICT_DESCRIPTION,
+    tier: 'villager',
+    builtin: true,
+  },
 ];

package/src/agent-runtime/builtin-tools.js

@@ -15,7 +15,7 @@
 import { tool } from 'ai';
 import { z } from 'zod';
 import { appendRows, datasetExists } from '../utils/dataset-workspace.js';
-import { DATASET_APPEND_DESCRIPTION } from './builtin-tools-registry.js';
+import { DATASET_APPEND_DESCRIPTION, MODEL_PREDICT_DESCRIPTION } from './builtin-tools-registry.js';
 
 export { BUILTIN_TOOL_DEFS } from './builtin-tools-registry.js';
 
@@ -71,5 +71,37 @@ export function getBuiltinTools(agentName, config) {
         }
       },
     }),
+
+    model_predict: tool({
+      description: MODEL_PREDICT_DESCRIPTION,
+      inputSchema: z.object({
+        modelId: z.string().describe('Slug of the local trained model'),
+        input: z
+          .union([z.string(), z.array(z.number())])
+          .describe('Text, or a numeric vector for tabular models'),
+      }),
+      execute: async ({ modelId, input }) => {
+        try {
+          // Lazy-load the model/tfjs code so agent startup stays light — tfjs
+          // only loads the first time an agent actually predicts.
+          const { modelExists, readModelManifest, loadModel } = await import(
+            '../utils/model-workspace.js'
+          );
+          if (!modelExists(modelId)) {
+            return {
+              error:
+                `Model "${modelId}" not found locally. Train one first ` +
+                '(Studio Lab or `myvillage model train`).',
+            };
+          }
+          const { predictWithModel } = await import('../utils/model-trainer.js');
+          const record = readModelManifest(modelId);
+          const model = await loadModel(modelId);
+          return predictWithModel(model, record, input);
+        } catch (e) {
+          return { error: e.message };
+        }
+      },
+    }),
   };
 }

package/src/agent-runtime/context.js

@@ -3,6 +3,8 @@
 // This becomes the user message sent to the LLM.
 
 import { getAgentFeed, getAgentMentions, getAgentEvents } from '../utils/api.js';
+import { listDatasets } from '../utils/dataset-workspace.js';
+import { listModels } from '../utils/model-workspace.js';
 
 export async function gatherContext(agentConfig, lastCheckIn, recentActions = []) {
   const parts = [];
@@ -110,6 +112,33 @@ export async function gatherContext(agentConfig, lastCheckIn, recentActions = []
     }
   }
 
+  // Local Lab datasets & models, so the agent knows what it can append to /
+  // predict with (and the exact slugs to pass to dataset_append / model_predict).
+  // Local-only, synchronous file reads; tfjs is NOT loaded by listing models.
+  try {
+    const datasets = listDatasets();
+    if (datasets.length > 0) {
+      parts.push('\nLocal datasets you can add to with dataset_append (use the slug as datasetId):');
+      for (const d of datasets.slice(0, 25)) {
+        parts.push(`- ${d.slug} — ${d.modality}/${d.taskType}, ${d.stats?.rowCount ?? 0} rows`);
+      }
+    }
+  } catch {
+    /* no local datasets / store unavailable — skip */
+  }
+  try {
+    const models = listModels();
+    if (models.length > 0) {
+      parts.push('\nLocal models you can run with model_predict (use the slug as modelId):');
+      for (const m of models.slice(0, 25)) {
+        const labels = m.labels?.length ? ` → ${m.labels.join('/')}` : '';
+        parts.push(`- ${m.slug} — ${m.modality}/${m.taskType}${labels}`);
+      }
+    }
+  } catch {
+    /* no local models / store unavailable — skip */
+  }
+
   parts.push('\nDecide what actions to take based on your personality and the current context.');
   parts.push('IMPORTANT: If you already commented on a post, only comment again if someone ELSE has replied since your last comment. Do not leave multiple unanswered comments on the same post.');
   parts.push('If there is no new activity and no one has responded to your previous comments, do nothing — that is a valid choice.');

package/src/utils/model-workspace.js

@@ -12,10 +12,13 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, rmSync } from 'fs';
 import { join } from 'path';
 import { randomUUID } from 'crypto';
-import * as tf from '@tensorflow/tfjs';
 import { getConfigDir } from './config.js';
 import { slugify } from './dataset-workspace.js';
 
+// tfjs is loaded lazily (only in save/load) so listing/reading model manifests —
+// e.g. when injecting "available models" into the agent loop's context — never
+// pulls the heavy tfjs runtime into agent startup.
+
 const MODELS_DIR_NAME = 'models';
 export const MODEL_SCHEMA_VERSION = '1.0.0';
 
@@ -71,6 +74,7 @@ export async function saveModel(name, { model, record, datasetSlug, datasetVersi
   const dir = getModelDir(slug);
   mkdirSync(dir, { recursive: true });
 
+  const tf = await import('@tensorflow/tfjs');
   let modelTopology, weightSpecs, weightB64;
   await model.save(
     tf.io.withSaveHandler(async (artifacts) => {
@@ -104,6 +108,7 @@ export async function saveModel(name, { model, record, datasetSlug, datasetVersi
 
 /** Load a saved tf model back into memory (for predict). */
 export async function loadModel(slug) {
+  const tf = await import('@tensorflow/tfjs');
   const dir = getModelDir(slug);
   if (!existsSync(join(dir, 'model.json'))) throw new Error(`Model "${slug}" not found.`);
   const { modelTopology, weightSpecs } = JSON.parse(readFileSync(join(dir, 'model.json'), 'utf-8'));