forbocai 0.3.13 → 0.3.15

package/dist/index.js

@@ -30,7 +30,6 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  attackRule: () => attackRule,
   createAgent: () => createAgent,
   createAgentFromSoul: () => createAgentFromSoul,
   createBridge: () => createBridge,
@@ -55,12 +54,9 @@ __export(index_exports, {
   importSoulFromIPFS: () => importSoulFromIPFS,
   init: () => init,
   initVectorEngine: () => initVectorEngine,
-  interactRule: () => interactRule,
-  movementRule: () => movementRule,
+  presets: () => presets_exports,
   processAgentInput: () => processAgentInput,
-  resourceRule: () => resourceRule,
   serializeSoul: () => serializeSoul,
-  speakRule: () => speakRule,
   startGhostSession: () => startGhostSession,
   stopGhostSession: () => stopGhostSession,
   updateAgentState: () => updateAgentState,
@@ -249,26 +245,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"
@@ -292,6 +280,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 };
   };
@@ -300,44 +289,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,
@@ -672,180 +714,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));
   }
@@ -1153,6 +1027,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(`
@@ -1171,7 +1257,6 @@ var init = () => {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  attackRule,
   createAgent,
   createAgentFromSoul,
   createBridge,
@@ -1196,12 +1281,9 @@ var init = () => {
   importSoulFromIPFS,
   init,
   initVectorEngine,
-  interactRule,
-  movementRule,
+  presets,
   processAgentInput,
-  resourceRule,
   serializeSoul,
-  speakRule,
   startGhostSession,
   stopGhostSession,
   updateAgentState,