@forbocai/core 0.4.4

package/dist/index.mjs

@@ -0,0 +1,903 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/agent.ts
+var createInitialState = (partial) => {
+  return { ...partial };
+};
+var updateAgentState = (currentState, updates) => {
+  return {
+    ...currentState,
+    ...updates
+  };
+};
+var processAgentInput = (currentState, input, context = {}) => {
+  const stateKeys = Object.keys(currentState);
+  const stateSummary = stateKeys.length > 0 ? stateKeys.map((k) => `${k}=${JSON.stringify(currentState[k])}`).join(", ") : "empty";
+  return {
+    dialogue: `Processing: "${input}" (State: ${stateSummary})`,
+    action: {
+      type: "respond",
+      reason: "Default processing"
+    }
+  };
+};
+var exportToSoul = (agentId, name, persona, state, memories) => {
+  return {
+    id: agentId,
+    version: "1.0.0",
+    name,
+    persona,
+    memories: [...memories],
+    // Copy array for immutability
+    state: { ...state }
+    // Copy state for immutability
+  };
+};
+var createAgent = (config) => {
+  let state = createInitialState(config.initialState);
+  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 };
+  };
+  const setAgentState = (newState) => {
+    state = newState;
+  };
+  const process = async (input, context = {}) => {
+    const currentState = getAgentState();
+    const apiContext = Object.entries(context).map(([k, v]) => [k, String(v)]);
+    const timestamp = Date.now();
+    apiContext.push(["timestamp", String(timestamp)]);
+    let relevantMemories = [];
+    if (config.memory && typeof config.memory.recall === "function") {
+      try {
+        relevantMemories = await config.memory.recall(input, 5);
+      } catch {
+      }
+    }
+    let directive = "Respond normally.";
+    let instruction = "IDLE";
+    let target;
+    try {
+      const dirRes = await fetch(`${apiUrl}/agents/${agentId}/directive`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-Request-Timestamp": String(timestamp)
+        },
+        body: JSON.stringify({
+          dirContext: apiContext,
+          dirState: currentState,
+          dirMemories: relevantMemories.map((m) => ({ text: m.text, type: m.type, importance: m.importance }))
+        })
+      });
+      if (dirRes.ok) {
+        const data = await dirRes.json();
+        directive = data.dirReason;
+        instruction = data.dirInstruction;
+        target = data.dirTarget;
+      } else {
+        throw new Error(`API Error: ${dirRes.status}`);
+      }
+    } catch (e) {
+      throw new Error(`API Directive Failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    const memoryContext = relevantMemories.length > 0 ? `
+Memories:
+${relevantMemories.map((m) => `- [${m.type}] ${m.text}`).join("\n")}
+` : "";
+    const prompt = `System: You are ${config.persona}.
+Directive: ${instruction} (${directive}).
+Target: ${target || "None"}${memoryContext}
+User: ${input}
+Agent:`;
+    const generatedText = await cortex.complete(prompt);
+    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: {
+          gaType: instruction,
+          // Map to generic action type
+          actionReason: directive,
+          actionTarget: target || ""
+        },
+        verThought: generatedText
+      })
+    });
+    if (!verRes.ok) {
+      throw new Error(`API Verdict Error: ${verRes.status}`);
+    }
+    const vData = await verRes.json();
+    const isValid = vData.verValid;
+    const signature = vData.verSignature;
+    if (!isValid) {
+      return {
+        dialogue: "... [Action Blocked by Protocol]",
+        action: { type: "BLOCKED", reason: "API Validation Failed" }
+      };
+    }
+    if (config.memory && typeof config.memory.store === "function") {
+      config.memory.store(`Input: "${input}" \u2192 Action: ${instruction}`, "experience", 0.5).catch(() => {
+      });
+    }
+    return {
+      dialogue: generatedText,
+      action: {
+        type: instruction,
+        reason: directive,
+        target,
+        signature
+      },
+      thought: `Directive: ${directive}`
+    };
+  };
+  const exportSoul2 = async () => {
+    let exportedMemories = [...memories];
+    if (config.memory && typeof config.memory.export === "function") {
+      try {
+        exportedMemories = await config.memory.export();
+      } catch {
+      }
+    }
+    return exportToSoul(agentId, "Agent", config.persona, state, exportedMemories);
+  };
+  return {
+    process,
+    getState: getAgentState,
+    setState: setAgentState,
+    export: exportSoul2
+  };
+};
+var fromSoul = async (soul, cortex, memory) => {
+  const agent = createAgent({
+    id: soul.id,
+    cortex,
+    memory: memory || null,
+    persona: soul.persona,
+    initialState: soul.state
+  });
+  if (memory && soul.memories && soul.memories.length > 0 && typeof memory.import === "function") {
+    try {
+      await memory.import(soul.memories);
+    } catch (e) {
+      console.warn("Failed to import memories into module:", e);
+    }
+  }
+  return agent;
+};
+
+// src/bridge.ts
+var createBridge = (config = {}) => {
+  const effectiveConfig = {
+    strictMode: config.strictMode ?? false,
+    ...config
+  };
+  const rules = /* @__PURE__ */ new Map();
+  if (config.customRules) {
+    config.customRules.forEach((rule) => rules.set(rule.id, rule));
+  }
+  const validateRemote = async (action) => {
+    const response = await fetch(`${effectiveConfig.apiUrl}/bridge/validate`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        actionType: action.type,
+        payload: JSON.stringify(action.payload || {})
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`API validation failed: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return {
+      valid: data.valid,
+      reason: data.reason
+    };
+  };
+  const validate = async (action, context = {}) => {
+    const applicableRules = Array.from(rules.values()).filter(
+      (rule) => rule.actionTypes.some(
+        (t) => t.toLowerCase() === action.type.toLowerCase()
+      )
+    );
+    if (effectiveConfig.strictMode && applicableRules.length === 0) {
+      const safeTypes = ["IDLE", "idle", "WAIT", "wait"];
+      if (!safeTypes.includes(action.type)) {
+        return {
+          valid: false,
+          reason: `Unknown action type '${action.type}' in strict mode`,
+          correctedAction: { ...action, type: "IDLE", reason: "Unknown action type" }
+        };
+      }
+    }
+    let currentAction = action;
+    for (const rule of applicableRules) {
+      const result = rule.validate(currentAction, context);
+      if (!result.valid) {
+        if (effectiveConfig.apiUrl) {
+          const apiResult = await validateRemote(action);
+          console.debug("API validation result:", apiResult);
+        }
+        return result;
+      }
+      if (result.correctedAction) {
+        currentAction = result.correctedAction;
+      }
+    }
+    return {
+      valid: true,
+      correctedAction: currentAction !== action ? currentAction : void 0
+    };
+  };
+  const registerRule = (rule) => {
+    rules.set(rule.id, rule);
+    if (effectiveConfig.apiUrl) {
+    }
+  };
+  const listRules = () => {
+    return Array.from(rules.values());
+  };
+  const removeRule = (ruleId) => {
+    return rules.delete(ruleId);
+  };
+  return {
+    validate,
+    registerRule,
+    listRules,
+    removeRule
+  };
+};
+var validateAction = (action, rules, context = {}) => {
+  for (const rule of rules) {
+    if (rule.actionTypes.some((t) => t.toLowerCase() === action.type.toLowerCase())) {
+      const result = rule.validate(action, context);
+      if (!result.valid) {
+        return result;
+      }
+    }
+  }
+  return { valid: true };
+};
+
+// src/soul.ts
+import Irys from "@irys/sdk";
+var createSoul = (id, name, persona, state, memories = []) => {
+  return {
+    id,
+    version: "1.0.0",
+    name,
+    persona,
+    state: { ...state },
+    memories: [...memories]
+  };
+};
+var serializeSoul = (soul) => {
+  return JSON.stringify(soul, null, 2);
+};
+var deserializeSoul = (json) => {
+  const parsed = JSON.parse(json);
+  if (!parsed.id || !parsed.persona || !parsed.state) {
+    throw new Error("Invalid Soul format: missing required fields");
+  }
+  return {
+    id: parsed.id,
+    version: parsed.version || "1.0.0",
+    name: parsed.name || "Unknown",
+    persona: parsed.persona,
+    state: parsed.state,
+    memories: parsed.memories || [],
+    signature: parsed.signature
+  };
+};
+var uploadToArweave = async (soul, config) => {
+  if (!config.privateKey) {
+    throw new Error("Private key required for direct Arweave upload");
+  }
+  const irys = new Irys({
+    url: config.irysUrl || "https://node1.irys.xyz",
+    token: config.token || "solana",
+    key: config.privateKey
+  });
+  const dataToUpload = serializeSoul(soul);
+  try {
+    const receipt = await irys.upload(dataToUpload);
+    return {
+      txId: receipt.id,
+      url: `https://gateway.irys.xyz/${receipt.id}`,
+      soul
+    };
+  } catch (e) {
+    throw new Error(`Failed to upload to Arweave: ${e}`);
+  }
+};
+var exportSoul = async (agentId, soul, config = {}) => {
+  if (config.privateKey) {
+    try {
+      return await uploadToArweave(soul, config);
+    } catch (e) {
+      console.warn("Direct Arweave upload failed, falling back to API", e);
+    }
+  }
+  const apiUrl = config.apiUrl || "https://api.forboc.ai";
+  try {
+    const response = await fetch(`${apiUrl}/agents/${agentId}/soul/export`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ soul })
+      // Sending full soul for server to sign/upload
+    });
+    if (!response.ok) {
+      throw new Error(`Export failed: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return {
+      txId: data.txId,
+      url: data.url,
+      soul
+    };
+  } catch (e) {
+    console.warn("API export failed, returning mock Arweave TXID used for dev");
+    const mockTxId = `mock_ar_${Date.now()}`;
+    return {
+      txId: mockTxId,
+      url: `https://arweave.net/${mockTxId}`,
+      soul
+    };
+  }
+};
+var importSoulFromArweave = async (txId, config = {}) => {
+  const gateway = config.gatewayUrl || "https://gateway.irys.xyz";
+  try {
+    const response = await fetch(`${gateway}/${txId}`, {
+      method: "GET",
+      headers: { "Content-Type": "application/json" }
+    });
+    if (!response.ok) {
+      throw new Error(`Import failed: ${response.statusText}`);
+    }
+    const data = await response.json();
+    if (!data.id || !data.persona) {
+      throw new Error("Invalid soul data from Arweave");
+    }
+    return data;
+  } catch (e) {
+    throw new Error(`Failed to import Soul from TXID ${txId}: ${e}`);
+  }
+};
+var getSoulList = async (limit = 50, apiUrl) => {
+  const url = apiUrl || "https://api.forboc.ai";
+  try {
+    const response = await fetch(`${url}/souls?limit=${limit}`);
+    if (!response.ok) throw new Error(response.statusText);
+    const data = await response.json();
+    return data.souls.map((s) => ({
+      txId: s.txId,
+      name: s.name,
+      agentId: s.agentId,
+      exportedAt: s.exportedAt,
+      url: s.url || `https://gateway.irys.xyz/${s.txId}`
+    }));
+  } catch (e) {
+    return [];
+  }
+};
+var createSoulInstance = (id, name, persona, state, memories = [], initialApiUrl) => {
+  const soulData = createSoul(id, name, persona, state, memories);
+  const defaultApiUrl = initialApiUrl || "https://api.forboc.ai";
+  const performExport = async (config) => {
+    return exportSoul(soulData.id, soulData, {
+      ...config,
+      apiUrl: config?.apiUrl || defaultApiUrl
+    });
+  };
+  return {
+    export: performExport,
+    toJSON: () => ({ ...soulData })
+  };
+};
+var validateSoul = (soul) => {
+  const errors = [];
+  if (!soul.id) errors.push("Missing id");
+  if (!soul.persona) errors.push("Missing persona");
+  if (!soul.state) errors.push("Missing state");
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+};
+
+// src/ghost.ts
+var startGhostSession = async (config) => {
+  const apiUrl = config.apiUrl || "https://api.forboc.ai";
+  try {
+    const response = await fetch(`${apiUrl}/ghost/run`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        testSuite: config.testSuite,
+        duration: config.duration
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to start Ghost session: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return {
+      sessionId: data.sessionId,
+      status: data.runStatus
+    };
+  } catch (e) {
+    const mockId = `ghost_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+    return {
+      sessionId: mockId,
+      status: "running"
+    };
+  }
+};
+var getGhostStatus = async (sessionId, apiUrl) => {
+  const url = apiUrl || "https://api.forboc.ai";
+  try {
+    const response = await fetch(`${url}/ghost/${sessionId}/status`, {
+      method: "GET",
+      headers: { "Content-Type": "application/json" }
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to get Ghost status: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return {
+      sessionId: data.ghostSessionId,
+      status: data.ghostStatus,
+      progress: data.ghostProgress,
+      startedAt: data.ghostStartedAt,
+      duration: data.ghostDuration,
+      errors: data.ghostErrors
+    };
+  } catch (e) {
+    return {
+      sessionId,
+      status: "running",
+      progress: Math.floor(Math.random() * 100),
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      duration: 60,
+      errors: 0
+    };
+  }
+};
+var getGhostResults = async (sessionId, apiUrl) => {
+  const url = apiUrl || "https://api.forboc.ai";
+  try {
+    const response = await fetch(`${url}/ghost/${sessionId}/results`, {
+      method: "GET",
+      headers: { "Content-Type": "application/json" }
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to get Ghost results: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return {
+      sessionId: data.resultsSessionId,
+      totalTests: data.resultsTotalTests,
+      passed: data.resultsPassed,
+      failed: data.resultsFailed,
+      skipped: data.resultsSkipped,
+      duration: data.resultsDuration,
+      tests: data.resultsTests.map((t) => ({
+        name: t.testName,
+        passed: t.testPassed,
+        duration: t.testDuration,
+        error: t.testError,
+        screenshot: t.testScreenshot
+      })),
+      coverage: data.resultsCoverage,
+      metrics: Object.fromEntries(data.resultsMetrics)
+    };
+  } catch (e) {
+    return {
+      sessionId,
+      totalTests: 5,
+      passed: 4,
+      failed: 1,
+      skipped: 0,
+      duration: 1245,
+      tests: [
+        { name: "test.navigation", passed: true, duration: 150 },
+        { name: "test.combat", passed: true, duration: 230 },
+        { name: "test.dialogue", passed: false, duration: 450, error: "Timeout" }
+      ],
+      coverage: 0.75,
+      metrics: {
+        avgFrameRate: 58.5,
+        memoryUsageMB: 512.3,
+        aiDecisionsPerSec: 15.2
+      }
+    };
+  }
+};
+var waitForGhostCompletion = async (sessionId, pollIntervalMs = 5e3, timeoutMs = 3e5, apiUrl, onProgress) => {
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeoutMs) {
+    try {
+      const status = await getGhostStatus(sessionId, apiUrl);
+      if (onProgress) {
+        onProgress(status);
+      }
+      if (status.status === "completed") {
+        return getGhostResults(sessionId, apiUrl);
+      }
+      if (status.status === "failed") {
+        throw new Error(`Ghost session failed with ${status.errors} errors`);
+      }
+    } catch (e) {
+    }
+    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+  }
+  throw new Error(`Ghost session timed out after ${timeoutMs}ms`);
+};
+var stopGhostSession = async (sessionId, apiUrl) => {
+  const url = apiUrl || "https://api.forboc.ai";
+  try {
+    const response = await fetch(`${url}/ghost/${sessionId}/stop`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" }
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to stop Ghost session: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return {
+      stopped: true,
+      status: data.status || "stopped"
+    };
+  } catch (e) {
+    return {
+      stopped: true,
+      status: "stopped"
+    };
+  }
+};
+var getGhostHistory = async (limit = 10, apiUrl) => {
+  const url = apiUrl || "https://api.forboc.ai";
+  try {
+    const response = await fetch(`${url}/ghost/history?limit=${limit}`, {
+      method: "GET",
+      headers: { "Content-Type": "application/json" }
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to get Ghost history: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data.sessions.map((s) => ({
+      sessionId: s.sessionId,
+      testSuite: s.testSuite,
+      startedAt: s.startedAt,
+      completedAt: s.completedAt,
+      status: s.status,
+      passRate: s.passRate
+    }));
+  } catch (e) {
+    return [];
+  }
+};
+var createGhost = (config) => {
+  let sessionId = null;
+  const apiUrl = config.apiUrl || "https://api.forboc.ai";
+  const run = async () => {
+    const result = await startGhostSession(config);
+    sessionId = result.sessionId;
+    return sessionId;
+  };
+  const status = async () => {
+    if (!sessionId) {
+      throw new Error("Ghost session not started");
+    }
+    return getGhostStatus(sessionId, apiUrl);
+  };
+  const results = async () => {
+    if (!sessionId) {
+      throw new Error("Ghost session not started");
+    }
+    return getGhostResults(sessionId, apiUrl);
+  };
+  const stop = async () => {
+    sessionId = null;
+  };
+  const waitForCompletion = async (pollIntervalMs, timeoutMs, onProgress) => {
+    if (!sessionId) {
+      throw new Error("Ghost session not started");
+    }
+    return waitForGhostCompletion(
+      sessionId,
+      pollIntervalMs,
+      timeoutMs,
+      apiUrl,
+      onProgress
+    );
+  };
+  return {
+    run,
+    status,
+    results,
+    stop,
+    waitForCompletion
+  };
+};
+
+// src/cortex-remote.ts
+var RemoteCortex = class {
+  constructor(apiUrl) {
+    this.apiUrl = apiUrl;
+  }
+  async init() {
+    return {
+      id: `remote_${Date.now()}`,
+      model: "api-integrated",
+      ready: true,
+      engine: "remote"
+    };
+  }
+  async complete(prompt, options) {
+    const response = await fetch(`${this.apiUrl}/cortex/complete`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ prompt, ...options })
+    });
+    if (!response.ok) throw new Error(`Remote Cortex failed: ${response.statusText}`);
+    const data = await response.json();
+    return data.text;
+  }
+  async *completeStream(prompt, options) {
+    const result = await this.complete(prompt, options);
+    yield result;
+  }
+};
+
+// src/presets/index.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,
+  rpgRules: () => rpgRules,
+  socialRules: () => socialRules,
+  spatialRules: () => spatialRules,
+  speakRule: () => speakRule
+});
+
+// src/presets/rpg.ts
+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 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 SDK_VERSION = "0.4.4";
+export {
+  RemoteCortex,
+  SDK_VERSION,
+  createAgent,
+  createBridge,
+  createGhost,
+  createInitialState,
+  createSoul,
+  createSoulInstance,
+  deserializeSoul,
+  exportSoul,
+  exportToSoul,
+  fromSoul,
+  getGhostHistory,
+  getGhostResults,
+  getGhostStatus,
+  getSoulList,
+  importSoulFromArweave,
+  presets_exports as presets,
+  processAgentInput,
+  serializeSoul,
+  startGhostSession,
+  stopGhostSession,
+  updateAgentState,
+  uploadToArweave,
+  validateAction,
+  validateSoul,
+  waitForGhostCompletion
+};