forbocai 0.3.13 → 0.3.15

package/dist/index.mjs

@@ -1,3 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
 // src/cortex.ts
 import * as fs from "fs";
 import * as path from "path";
@@ -177,26 +183,18 @@ var createCortex = (config) => createNativeCortex(config);
 
 // src/agent.ts
 var createInitialState = (partial) => {
-  return {
-    inventory: partial?.inventory ?? [],
-    skills: partial?.skills ?? {},
-    relationships: partial?.relationships ?? {},
-    mood: partial?.mood ?? "neutral"
-  };
+  return { ...partial };
 };
 var updateAgentState = (currentState, updates) => {
   return {
     ...currentState,
-    ...updates,
-    // Preserve nested immutability
-    inventory: updates.inventory !== void 0 ? [...updates.inventory] : [...currentState.inventory],
-    skills: { ...currentState.skills, ...updates.skills || {} },
-    relationships: { ...currentState.relationships, ...updates.relationships || {} }
+    ...updates
   };
 };
 var processAgentInput = (currentState, input, context = {}) => {
+  const mood = currentState.mood || "neutral";
   return {
-    dialogue: `Processing: "${input}" (Mood: ${currentState.mood})`,
+    dialogue: `Processing: "${input}" (Mood: ${mood})`,
     action: {
       type: "respond",
       reason: "Default processing"
@@ -220,6 +218,7 @@ var createAgent = (config) => {
   let memories = [];
   const cortex = config.cortex;
   const apiUrl = config.apiUrl || "http://localhost:8080";
+  const agentId = config.id || "agent-" + Math.random().toString(36).substring(7);
   const getAgentState = () => {
     return { ...state };
   };
@@ -228,44 +227,97 @@ var createAgent = (config) => {
   };
   const process2 = async (input, context = {}) => {
     const currentState = getAgentState();
-    const hp = currentState.hp || 100;
     const apiContext = Object.entries(context).map(([k, v]) => [k, String(v)]);
-    apiContext.push(["hp", String(hp)]);
     let directive = "Respond normally.";
     let instruction = "IDLE";
+    let target;
+    const timestamp = Date.now();
+    apiContext.push(["timestamp", String(timestamp)]);
     try {
-      const apiResponse = await fetch(`${apiUrl}/agents/mock-agent-id/process`, {
+      const dirRes = await fetch(`${apiUrl}/agents/${agentId}/directive`, {
         method: "POST",
-        headers: { "Content-Type": "application/json" },
+        headers: {
+          "Content-Type": "application/json",
+          "X-Request-Timestamp": String(timestamp)
+        },
         body: JSON.stringify({
-          input,
-          context: apiContext
+          dirContext: apiContext,
+          dirState: currentState,
+          // Full state dump
+          dirMemories: []
+          // TODO: Integrate memory lookup
         })
       });
-      if (apiResponse.ok) {
-        const data = await apiResponse.json();
-        directive = data.directive;
-        instruction = data.instruction;
+      if (dirRes.ok) {
+        const data = await dirRes.json();
+        directive = data.dirReason;
+        instruction = data.dirInstruction;
+        target = data.dirTarget;
       } else {
-        console.warn("API Error, falling back to local.");
+        console.warn(`API Directive Error: ${dirRes.status} ${dirRes.statusText}`);
+        if (config.fallbackStrategy) {
+          const fallback = config.fallbackStrategy(currentState, context);
+          instruction = fallback.instruction;
+          directive = fallback.directive;
+        }
       }
     } catch (e) {
-      console.warn("API Unreachable, falling back to local.", e);
+      console.warn("API Directive Failed (Network), falling back to local laws.", e);
+      if (config.fallbackStrategy) {
+        const fallback = config.fallbackStrategy(currentState, context);
+        instruction = fallback.instruction;
+        directive = fallback.directive;
+      }
     }
-    const prompt = `${directive}
-
+    const prompt = `System: Follow this directive strictly: ${instruction} (${directive}).
+To Target: ${target || "None"}
 User: ${input}
 Agent:`;
     const generatedText = await cortex.complete(prompt);
+    let signature = "unsigned_local_fallback";
+    let isValid = true;
+    const proposedAction = { type: instruction, reason: directive, target };
+    try {
+      const verRes = await fetch(`${apiUrl}/agents/${agentId}/verdict`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          verDirective: {
+            dirInstruction: instruction,
+            dirTarget: target,
+            dirReason: directive
+          },
+          verAction: {
+            actionType: instruction,
+            actionReason: directive,
+            actionTarget: target
+          },
+          verThought: generatedText
+        })
+      });
+      if (verRes.ok) {
+        const vData = await verRes.json();
+        isValid = vData.verValid;
+        signature = vData.verSignature;
+      }
+    } catch (e) {
+      console.warn("API Verdict Failed.", e);
+    }
+    if (!isValid) {
+      return {
+        dialogue: "... [Action Blocked by Protocol]",
+        action: { type: "BLOCKED", reason: "API Validation Failed" }
+      };
+    }
     return {
       dialogue: generatedText,
-      action: { type: instruction, reason: directive },
-      thought: `Directive: ${directive}`
+      action: { ...proposedAction, signature },
+      thought: `Directive: ${directive} | Sig: ${signature}`
     };
   };
   const exportSoul = () => {
     return exportToSoul(
-      "agent-" + Math.random().toString(36).substring(7),
+      agentId,
       "Agent",
       config.persona,
       state,
@@ -600,180 +652,12 @@ var createLanceDBMemory = (config) => {
 var createMemory = (config = {}) => createLanceDBMemory(config);
 
 // src/bridge.ts
-var movementRule = {
-  id: "core.movement",
-  name: "Movement Validation",
-  description: "Ensures MOVE actions have valid x,y coordinates",
-  actionTypes: ["MOVE", "move"],
-  validate: (action, context) => {
-    const payload = action.payload || {};
-    const target = payload.target;
-    if (!target || typeof target.x !== "number" || typeof target.y !== "number") {
-      return {
-        valid: false,
-        reason: "MOVE action must have target with numeric x,y coordinates",
-        correctedAction: {
-          ...action,
-          type: "IDLE",
-          reason: "Invalid MOVE target - defaulting to IDLE"
-        }
-      };
-    }
-    const world = context.worldState || {};
-    const maxX = world.maxX || Infinity;
-    const maxY = world.maxY || Infinity;
-    if (target.x < 0 || target.x > maxX || target.y < 0 || target.y > maxY) {
-      return {
-        valid: false,
-        reason: `MOVE target (${target.x}, ${target.y}) is out of bounds`,
-        correctedAction: {
-          ...action,
-          payload: {
-            ...payload,
-            target: {
-              x: Math.max(0, Math.min(maxX, target.x)),
-              y: Math.max(0, Math.min(maxY, target.y))
-            }
-          }
-        }
-      };
-    }
-    return { valid: true };
-  }
-};
-var attackRule = {
-  id: "core.attack",
-  name: "Attack Validation",
-  description: "Ensures ATTACK actions have valid targetId",
-  actionTypes: ["ATTACK", "attack"],
-  validate: (action, context) => {
-    if (!action.target && !action.payload?.targetId) {
-      return {
-        valid: false,
-        reason: "ATTACK action must have a target or targetId",
-        correctedAction: {
-          ...action,
-          type: "IDLE",
-          reason: "Invalid ATTACK - no target specified"
-        }
-      };
-    }
-    const world = context.worldState || {};
-    const entities = world.entities || [];
-    const targetId = action.target || action.payload?.targetId;
-    if (entities.length > 0 && !entities.includes(targetId)) {
-      return {
-        valid: false,
-        reason: `ATTACK target '${targetId}' does not exist in world`,
-        correctedAction: {
-          ...action,
-          type: "IDLE",
-          reason: "Target not found"
-        }
-      };
-    }
-    return { valid: true };
-  }
-};
-var interactRule = {
-  id: "core.interact",
-  name: "Interact Validation",
-  description: "Ensures INTERACT actions have valid objectId",
-  actionTypes: ["INTERACT", "interact"],
-  validate: (action, context) => {
-    if (!action.target && !action.payload?.objectId) {
-      return {
-        valid: false,
-        reason: "INTERACT action must have objectId",
-        correctedAction: {
-          ...action,
-          type: "IDLE",
-          reason: "Invalid INTERACT - no object specified"
-        }
-      };
-    }
-    return { valid: true };
-  }
-};
-var speakRule = {
-  id: "core.speak",
-  name: "Speak Validation",
-  description: "Ensures SPEAK actions have non-empty text",
-  actionTypes: ["SPEAK", "speak"],
-  validate: (action, context) => {
-    const text = action.payload?.text;
-    if (!text || text.trim().length === 0) {
-      return {
-        valid: false,
-        reason: "SPEAK action must have non-empty text",
-        correctedAction: {
-          ...action,
-          type: "IDLE",
-          reason: "Empty speech - defaulting to IDLE"
-        }
-      };
-    }
-    const maxLength = context.constraints?.maxSpeechLength || 1e3;
-    if (text.length > maxLength) {
-      return {
-        valid: true,
-        // Still valid, but truncated
-        reason: `Speech truncated to ${maxLength} characters`,
-        correctedAction: {
-          ...action,
-          payload: {
-            ...action.payload,
-            text: text.substring(0, maxLength)
-          }
-        }
-      };
-    }
-    return { valid: true };
-  }
-};
-var resourceRule = {
-  id: "core.resources",
-  name: "Resource Validation",
-  description: "Ensures agent has required resources for action",
-  actionTypes: ["ATTACK", "CAST", "USE_ITEM"],
-  validate: (action, context) => {
-    const agent = context.agentState || {};
-    const hp = agent.hp ?? 100;
-    const mana = agent.mana ?? 100;
-    if (hp <= 0) {
-      return {
-        valid: false,
-        reason: "Agent is dead and cannot perform actions",
-        correctedAction: { ...action, type: "IDLE", reason: "Agent dead" }
-      };
-    }
-    if (action.type === "CAST" || action.type === "cast") {
-      const manaCost = action.payload?.manaCost || 10;
-      if (mana < manaCost) {
-        return {
-          valid: false,
-          reason: `Insufficient mana: need ${manaCost}, have ${mana}`,
-          correctedAction: { ...action, type: "IDLE", reason: "Not enough mana" }
-        };
-      }
-    }
-    return { valid: true };
-  }
-};
-var DEFAULT_RULES = [
-  movementRule,
-  attackRule,
-  interactRule,
-  speakRule,
-  resourceRule
-];
 var createBridge = (config = {}) => {
   const effectiveConfig = {
     strictMode: config.strictMode ?? false,
     ...config
   };
   const rules = /* @__PURE__ */ new Map();
-  DEFAULT_RULES.forEach((rule) => rules.set(rule.id, rule));
   if (config.customRules) {
     config.customRules.forEach((rule) => rules.set(rule.id, rule));
   }
@@ -1081,6 +965,218 @@ var createGhost = (config) => {
   };
 };
 
+// src/presets.ts
+var presets_exports = {};
+__export(presets_exports, {
+  RPG_MEMORY_TYPES: () => RPG_MEMORY_TYPES,
+  RPG_MOODS: () => RPG_MOODS,
+  attackRule: () => attackRule,
+  createRPGState: () => createRPGState,
+  interactRule: () => interactRule,
+  movementRule: () => movementRule,
+  puzzleRules: () => puzzleRules,
+  resourceRule: () => resourceRule,
+  rpgFallbackStrategy: () => rpgFallbackStrategy,
+  rpgRules: () => rpgRules,
+  socialRules: () => socialRules,
+  spatialRules: () => spatialRules,
+  speakRule: () => speakRule
+});
+var RPG_MOODS = {
+  hostile: "hostile",
+  suspicious: "suspicious",
+  neutral: "neutral",
+  friendly: "friendly",
+  loyal: "loyal"
+};
+var RPG_MEMORY_TYPES = {
+  observation: "observation",
+  experience: "experience",
+  knowledge: "knowledge",
+  emotion: "emotion"
+};
+var createRPGState = (partial) => {
+  return {
+    inventory: partial?.inventory ?? [],
+    hp: partial?.hp ?? 100,
+    mana: partial?.mana ?? 100,
+    skills: partial?.skills ?? {},
+    relationships: partial?.relationships ?? {},
+    mood: partial?.mood ?? "neutral",
+    ...partial
+  };
+};
+var rpgFallbackStrategy = (state, context) => {
+  const hp = state.hp || 100;
+  if (hp < 20) {
+    return { instruction: "FLEE", directive: "CRITICAL (Fallback): Low Health detected." };
+  }
+  return { instruction: "IDLE", directive: "Autonomous" };
+};
+var movementRule = {
+  id: "core.movement",
+  name: "Movement Validation",
+  description: "Ensures MOVE actions have valid x,y coordinates",
+  actionTypes: ["MOVE", "move"],
+  validate: (action, context) => {
+    const payload = action.payload || {};
+    const target = payload.target;
+    if (!target || typeof target.x !== "number" || typeof target.y !== "number") {
+      return {
+        valid: false,
+        reason: "MOVE action must have target with numeric x,y coordinates",
+        correctedAction: {
+          ...action,
+          type: "IDLE",
+          reason: "Invalid MOVE target - defaulting to IDLE"
+        }
+      };
+    }
+    const world = context.worldState || {};
+    const maxX = world.maxX || Infinity;
+    const maxY = world.maxY || Infinity;
+    if (target.x < 0 || target.x > maxX || target.y < 0 || target.y > maxY) {
+      return {
+        valid: false,
+        reason: `MOVE target (${target.x}, ${target.y}) is out of bounds`,
+        correctedAction: {
+          ...action,
+          payload: {
+            ...payload,
+            target: {
+              x: Math.max(0, Math.min(maxX, target.x)),
+              y: Math.max(0, Math.min(maxY, target.y))
+            }
+          }
+        }
+      };
+    }
+    return { valid: true };
+  }
+};
+var attackRule = {
+  id: "core.attack",
+  name: "Attack Validation",
+  description: "Ensures ATTACK actions have valid targetId",
+  actionTypes: ["ATTACK", "attack"],
+  validate: (action, context) => {
+    if (!action.target && !action.payload?.targetId) {
+      return {
+        valid: false,
+        reason: "ATTACK action must have a target or targetId",
+        correctedAction: {
+          ...action,
+          type: "IDLE",
+          reason: "Invalid ATTACK - no target specified"
+        }
+      };
+    }
+    const world = context.worldState || {};
+    const entities = world.entities || [];
+    const targetId = action.target || action.payload?.targetId;
+    if (entities.length > 0 && !entities.includes(targetId)) {
+      return {
+        valid: false,
+        reason: `ATTACK target '${targetId}' does not exist in world`,
+        correctedAction: {
+          ...action,
+          type: "IDLE",
+          reason: "Target not found"
+        }
+      };
+    }
+    return { valid: true };
+  }
+};
+var interactRule = {
+  id: "core.interact",
+  name: "Interact Validation",
+  description: "Ensures INTERACT actions have valid objectId",
+  actionTypes: ["INTERACT", "interact"],
+  validate: (action, context) => {
+    if (!action.target && !action.payload?.objectId) {
+      return {
+        valid: false,
+        reason: "INTERACT action must have objectId",
+        correctedAction: {
+          ...action,
+          type: "IDLE",
+          reason: "Invalid INTERACT - no object specified"
+        }
+      };
+    }
+    return { valid: true };
+  }
+};
+var speakRule = {
+  id: "core.speak",
+  name: "Speak Validation",
+  description: "Ensures SPEAK actions have non-empty text",
+  actionTypes: ["SPEAK", "speak"],
+  validate: (action, context) => {
+    const text = action.payload?.text;
+    if (!text || text.trim().length === 0) {
+      return {
+        valid: false,
+        reason: "SPEAK action must have non-empty text",
+        correctedAction: {
+          ...action,
+          type: "IDLE",
+          reason: "Empty speech - defaulting to IDLE"
+        }
+      };
+    }
+    const maxLength = context.constraints?.maxSpeechLength || 1e3;
+    if (text.length > maxLength) {
+      return {
+        valid: true,
+        reason: `Speech truncated to ${maxLength} characters`,
+        correctedAction: {
+          ...action,
+          payload: {
+            ...action.payload,
+            text: text.substring(0, maxLength)
+          }
+        }
+      };
+    }
+    return { valid: true };
+  }
+};
+var resourceRule = {
+  id: "core.resources",
+  name: "Resource Validation",
+  description: "Ensures agent has required resources for action",
+  actionTypes: ["ATTACK", "CAST", "USE_ITEM"],
+  validate: (action, context) => {
+    const agent = context.agentState || {};
+    const hp = agent.hp ?? 100;
+    const mana = agent.mana ?? 100;
+    if (hp <= 0) {
+      return {
+        valid: false,
+        reason: "Agent is dead and cannot perform actions",
+        correctedAction: { ...action, type: "IDLE", reason: "Agent dead" }
+      };
+    }
+    if (action.type === "CAST" || action.type === "cast") {
+      const manaCost = action.payload?.manaCost || 10;
+      if (mana < manaCost) {
+        return {
+          valid: false,
+          reason: `Insufficient mana: need ${manaCost}, have ${mana}`,
+          correctedAction: { ...action, type: "IDLE", reason: "Not enough mana" }
+        };
+      }
+    }
+    return { valid: true };
+  }
+};
+var rpgRules = [movementRule, attackRule, interactRule, speakRule, resourceRule];
+var spatialRules = [movementRule];
+var socialRules = [speakRule, interactRule];
+var puzzleRules = [movementRule, interactRule];
+
 // src/index.ts
 var init = () => {
   console.log(`
@@ -1098,7 +1194,6 @@ var init = () => {
   `);
 };
 export {
-  attackRule,
   createAgent,
   createAgentFromSoul,
   createBridge,
@@ -1123,12 +1218,9 @@ export {
   importSoulFromIPFS,
   init,
   initVectorEngine,
-  interactRule,
-  movementRule,
+  presets_exports as presets,
   processAgentInput,
-  resourceRule,
   serializeSoul,
-  speakRule,
   startGhostSession,
   stopGhostSession,
   updateAgentState,

package/package.json

@@ -1,47 +1,51 @@
 {
-    "name": "forbocai",
-    "version": "0.3.13",
-    "description": "The Infrastructure Layer for Autonomous AI Characters",
-    "main": "dist/index.js",
-    "module": "dist/index.mjs",
-    "types": "dist/index.d.ts",
-    "bin": {
-        "forbocai": "dist/cli.js"
-    },
-    "scripts": {
-        "build": "tsup src/index.ts src/cli.ts --format cjs,esm --dts",
-        "dev": "tsup src/index.ts --watch",
-        "test": "vitest",
-        "test:watch": "vitest --watch",
-        "preinstall": "node scripts/check-cmake.js",
-        "postinstall": "node postinstall.js"
-    },
-    "dependencies": {
-        "@helia/json": "^5.0.6",
-        "@lancedb/lancedb": "^0.23.0",
-        "@mlc-ai/web-llm": "^0.2.80",
-        "@xenova/transformers": "^2.17.2",
-        "apache-arrow": "^18.1.0",
-        "axios": "^1.6.2",
-        "blockstore-core": "^6.1.2",
-        "datastore-core": "^11.0.2",
-        "helia": "^6.0.18",
-        "idb": "^8.0.3",
-        "node-llama-cpp": "^3.15.1",
-        "onnxruntime-node": "^1.23.2",
-        "zod": "^3.22.4"
-    },
-    "devDependencies": {
-        "@types/node": "^20.0.0",
-        "tsup": "^8.5.1",
-        "typescript": "^5.9.3",
-        "vitest": "^1.0.0"
-    },
-    "files": [
-        "dist",
-        "README.md",
-        "package.json",
-        "postinstall.js",
-        "scripts"
-    ]
+  "name": "forbocai",
+  "version": "0.3.15",
+  "description": "The Infrastructure Layer for Autonomous AI Characters",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "forbocai": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts src/cli.ts --format cjs,esm --dts",
+    "dev": "tsup src/index.ts --watch",
+    "test": "vitest",
+    "test:watch": "vitest --watch",
+    "preinstall": "node scripts/check-cmake.js",
+    "postinstall": "node postinstall.js"
+  },
+  "dependencies": {
+    "@helia/json": "^5.0.6",
+    "@lancedb/lancedb": "^0.23.0",
+    "@mlc-ai/web-llm": "^0.2.80",
+    "@xenova/transformers": "^2.17.2",
+    "apache-arrow": "^18.1.0",
+    "axios": "^1.6.2",
+    "blockstore-core": "^6.1.2",
+    "datastore-core": "^11.0.2",
+    "helia": "^6.0.18",
+    "idb": "^8.0.3",
+    "node-llama-cpp": "^3.15.1",
+    "onnxruntime-node": "^1.23.2",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^1.0.0"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "package.json",
+    "postinstall.js",
+    "scripts"
+  ],
+  "overrides": {
+    "glob": "^11.0.0",
+    "rimraf": "^5.0.0"
+  }
 }