forbocai 0.3.13 → 0.3.15

package/README.md

@@ -59,8 +59,8 @@ The **ForbocAI SDK** is an **Engine-Agnostic** toolkit for creating autonomous A
 
 - **Local SLM Cortex** — Run **WebLLM** (SmolLM2, Llama3) directly in-browser via WebGPU.
 - **Autonomous NPCs** — Create agents with persona, memory, and validated actions.
-- **Persistent Memory** — **IndexedDB** vector storage for 10k+ memories.
-- **Portable Souls** — P2P **IPFS** pinning via integrated Helia node.
+- **Persistent Memory** — Local vector storage for semantic recall.
+- **Portable Souls** — Permanent storage (Arweave) + Solana NFTs for tradeable agent identities.
 - **Automated QA** — Ghost Agents for headless testing at scale.
 
 **Requirements**:
@@ -133,13 +133,13 @@ See [full CLI documentation](https://docs.forboc.ai/docs/pages/cli).
 `Quíck_Stárt // Éxample`
 
 ```typescript
-import { Cortex, Agent } from 'forbocai';
+import { createCortex, createAgent } from 'forbocai';
 
 // Córtex_Init // Loćal_Inférence
-const cortex = await Cortex.init({ model: 'smollm2-135m' });
+const cortex = await createCortex({ model: 'smollm2-135m' });
 
 // Agént_Créate // NPC_Entíty
-const npc = await Agent.create({
+const npc = await createAgent({
   cortex,
   persona: 'A suspicious merchant who was once cheated by adventurers.',
   state: { inventory: ['rusty_key', 'healing_potion'], mood: 'suspicious' }
@@ -168,41 +168,55 @@ console.log(response.dialogue);
 | **Agent** | Autonomous entities with persona, state, memory | ✅ Complete |
 | **Memory** | Local Vector DB (IndexedDB / FS) | ✅ Complete |
 | **Bridge** | Neuro-symbolic action validation | ✅ Complete |
-| **Soul** | Portable agent state on IPFS/Solana | ✅ Complete |
+| **Soul** | Portable agent state on Arweave/Solana | ✅ Complete |
 | **Ghost** | Headless QA testing at scale | ✅ Complete |
 
 ---
 
-## The Neural Grid
+## Architecture Overview
 
-`Systém_Architécture // Cónnection`
+`Systém_Architécture // Round_Tríp`
 
-The **ForbocAI Protocol** strictly separates **State** (SDK) from **Logic** (API).
+The **ForbocAI SDK** orchestrates a **7-Step Round-Trip** between the Game, the Local Infrastructure, and the Cloud Mind.
 
 ```
-┌────────────────────────────────────────────────────────────────┐
-│                         THE NEURAL GRID                        │
-├────────────────────────────────────────────────────────────────┤
-│                                                                │
-│   ┌──────────────┐          ┌──────────────┐                   │
-│   │     SDK      │          │     API      │                   │
-│   │ (Container)  │◄────────►│ (Pure Logic) │                   │
-│   └──────────────┘          └──────────────┘                   │
-│          │                          │                          │
-│     The VESSEL                  The TRUTH                      │
-│   [SLM + VectorDB]           [Stateless Rules]                 │
-│   [Memory + Soul]            [No Database]                     │
-│                                                                │
-└────────────────────────────────────────────────────────────────┘
+┌─────────────────────────────────────────────────────────────┐
+│                      YOUR APPLICATION                       │
+├─────────────────────────────────────────────────────────────┤
+│   ┌──────────────┐   ┌──────────────┐   ┌──────────────┐    │
+│   │    Agent     │   │    Memory    │   │    Bridge    │    │
+│   └──────┬───────┘   └──────────────┘   └──────────────┘    │
+│          │ (1) Request                                      │
+│          ▼                                                  │
+│   ┌──────────────┐                                          │
+│   │   SDK Core   │ <────── (7) Execute ─────────────────┐   │
+│   └──────┬───────┘                                      │   │
+│          │ (2) Bundle                  (6) Verdict      │   │
+│          ▼                             (Signed)         │   │
+│   ┌──────────────┐  (3) Directive      ┌──────────────┐ │   │
+│   │  Cloud API   │ ──────────────────► │  Cloud API   │ │   │
+│   │  (The Law)   │                     │ (Validation) │ │   │
+│   └──────────────┘                     └──────▲───────┘ │   │
+│                                               │         │   │
+│          (4) Input                            │ (5)     │   │
+│          ▼                                    │ Submit  │   │
+│   ┌──────────────┐                            │         │   │
+│   │    Cortex    │ ───────────────────────────┘         │   │
+│   │  (SLM/LLM)   │      Generation                      │   │
+│   └──────────────┘                                      │   │
+└─────────────────────────────────────────────────────────────┘
 ```
 
-1.  **SDK is the Body**: It contains the *entire* existence of the Agent.
-    *   **SLM Cortex**: The brain (Local Inference).
-    *   **Vector Memory**: The memory (Local Storage).
-    *   **Self-Contained**: Runs locally (Browser/Node/Python/Rust) without external dependencies.
-2.  **API is the Law**: It is a stateless oracle that validates reality.
-    *   **No Database**: The API never stores agent state.
-    *   **Pure Functions**: Input (Action) → Output (Validation).
+**The Loop:**
+1.  **Game -> SDK**: Request Action.
+2.  **SDK -> API**: Send State/Memory.
+3.  **API -> SDK**: Return **Directive** (The Law).
+4.  **SDK -> Cortex**: Generate creative content based on Directive.
+5.  **SDK -> API**: Submit content for validation.
+6.  **API -> SDK**: Return **Verdict** (Signed Action).
+7.  **SDK -> Game**: Execute final action.
+
+*Note: For Enterprise usage, Step 4 can be replaced by a Cloud LLM provider, unifying the architecture for low-end (SLM) and high-end (LLM) devices.*
 
 
 `Mémory_Módule // Sémantic_Récall`
@@ -291,14 +305,14 @@ bridge.registerRule({
 
 ---
 
-## Module: Soul (IPFS Portability)
+## Module: Soul (Portable Agent Identity)
 
 `Sóul_Módule // Pórtal_Idéntity`
 
-The Soul module enables **cross-game agent portability** via IPFS.
+The Soul module enables **cross-game agent portability** via permanent storage (Arweave) and Solana NFTs.
 
 ```typescript
-import { createSoulInstance, importSoulFromIPFS } from 'forbocai';
+import { createSoulInstance, importSoulFromUri } from 'forbocai';
 
 // Create a Soul from agent data
 const soul = createSoulInstance(
@@ -309,13 +323,12 @@ const soul = createSoulInstance(
   memories  // From Memory module
 );
 
-// Export to IPFS
-const { cid, ipfsUrl, signature } = await soul.export();
-console.log(`Soul pinned: ${ipfsUrl}`);
-// ipfs://QmXyz...
+// Export to Arweave (permanent, pay-once storage)
+const { cid, uri, signature } = await soul.export();
+console.log(`Soul stored: ${uri}`);
 
 // Import Soul in another game
-const importedSoul = await importSoulFromIPFS(cid);
+const importedSoul = await importSoulFromUri(cid);
 console.log(importedSoul.persona);
 // "A suspicious merchant who distrusts adventurers"
 
@@ -325,9 +338,9 @@ const { agentId, persona } = await createAgentFromSoul(cid, cortexId);
 ```
 
 **Features:**
-- **IPFS Pinning**: Decentralized storage via Pinata/Helia
-- **Signature**: Cryptographic proof of ownership
-- **NFT-Ready**: Soul CID can be referenced in Metaplex NFT metadata
+- **Arweave Storage**: Permanent, pay-once (no pinning fees)
+- **Encryption**: Soul content encrypted; key transfers with NFT ownership
+- **NFT-Ready**: Metaplex Core on Solana for tradeable agent identities
 
 ---
 
@@ -396,7 +409,7 @@ In the ForbocAI ecosystem, an NFT is not just a receipt—it is an **Encapsulate
 
 *   **The Container**: A standardized bundle containing the Agent's Personality, Memories, and State.
 *   **The Chain**: The NFT is the *Deed of Ownership* pointing to this digital life.
-*   **Portability**: Take your trained NPC from *Forboc* to a sequel or entirely different world. Uses IPFS for decentralized persistence.
+*   **Portability**: Take your trained NPC from *Forboc* to a sequel or entirely different world. Uses Arweave for permanent, pay-once storage.
 *   **Economy**: Train a specialist NPC and sell it on the open market. The value is in the *Experience*, not just the skin.
 
 <!-- T̵h̷e̶ ̷s̸o̷u̷l̴ ̶i̶s̵ ̶n̵o̸t̵ ̵f̸o̵r̶ ̵s̷a̸l̶e̷.̶ ̴I̸t̸ ̴i̵s̷ ̶l̶e̷a̵s̵e̶d̴.̷ -->

package/dist/cli.js

@@ -293,22 +293,25 @@ async function agentState(agentId) {
     console.log(`
   Agent State:
 `);
-    console.log(`  Mood: \x1B[33m${data.stateMood || data.mood || "unknown"}\x1B[0m`);
-    if (data.stateInventory || data.inventory) {
-      const inv = data.stateInventory || data.inventory;
-      console.log(`  Inventory: ${inv.length > 0 ? inv.join(", ") : "(empty)"}`);
+    const mood = data.mood || data.stateMood || "unknown";
+    console.log(`  Mood: \x1B[33m${mood}\x1B[0m`);
+    const inventory = data.inventory || data.stateInventory;
+    if (Array.isArray(inventory)) {
+      console.log(`  Inventory: ${inventory.length > 0 ? inventory.join(", ") : "(empty)"}`);
+    } else if (inventory) {
+      console.log(`  Inventory: ${JSON.stringify(inventory)}`);
     }
-    if (data.stateSkills || data.skills) {
+    const skills = data.skills || data.stateSkills;
+    if (skills && typeof skills === "object") {
       console.log(`  Skills:`);
-      const skills = data.stateSkills || data.skills || {};
       for (const [skill, level] of Object.entries(skills)) {
         console.log(`    ${skill}: ${level}`);
       }
     }
-    if (data.stateRelationships || data.relationships) {
+    const relationships = data.relationships || data.stateRelationships;
+    if (relationships && typeof relationships === "object") {
       console.log(`  Relationships:`);
-      const rels = data.stateRelationships || data.relationships || {};
-      for (const [entity, value] of Object.entries(rels)) {
+      for (const [entity, value] of Object.entries(relationships)) {
         const indicator = value > 0 ? "\x1B[32m+" : "\x1B[31m";
         console.log(`    ${entity}: ${indicator}${value}\x1B[0m`);
       }

package/dist/cli.mjs

@@ -270,22 +270,25 @@ async function agentState(agentId) {
     console.log(`
   Agent State:
 `);
-    console.log(`  Mood: \x1B[33m${data.stateMood || data.mood || "unknown"}\x1B[0m`);
-    if (data.stateInventory || data.inventory) {
-      const inv = data.stateInventory || data.inventory;
-      console.log(`  Inventory: ${inv.length > 0 ? inv.join(", ") : "(empty)"}`);
+    const mood = data.mood || data.stateMood || "unknown";
+    console.log(`  Mood: \x1B[33m${mood}\x1B[0m`);
+    const inventory = data.inventory || data.stateInventory;
+    if (Array.isArray(inventory)) {
+      console.log(`  Inventory: ${inventory.length > 0 ? inventory.join(", ") : "(empty)"}`);
+    } else if (inventory) {
+      console.log(`  Inventory: ${JSON.stringify(inventory)}`);
     }
-    if (data.stateSkills || data.skills) {
+    const skills = data.skills || data.stateSkills;
+    if (skills && typeof skills === "object") {
       console.log(`  Skills:`);
-      const skills = data.stateSkills || data.skills || {};
       for (const [skill, level] of Object.entries(skills)) {
         console.log(`    ${skill}: ${level}`);
       }
     }
-    if (data.stateRelationships || data.relationships) {
+    const relationships = data.relationships || data.stateRelationships;
+    if (relationships && typeof relationships === "object") {
       console.log(`  Relationships:`);
-      const rels = data.stateRelationships || data.relationships || {};
-      for (const [entity, value] of Object.entries(rels)) {
+      for (const [entity, value] of Object.entries(relationships)) {
         const indicator = value > 0 ? "\x1B[32m+" : "\x1B[31m";
         console.log(`    ${entity}: ${indicator}${value}\x1B[0m`);
       }

package/dist/index.d.mts

@@ -32,12 +32,8 @@ interface CompletionOptions {
     stop?: string[];
     jsonSchema?: object;
 }
-type Mood = 'hostile' | 'suspicious' | 'neutral' | 'friendly' | 'loyal';
+type Mood = string;
 interface AgentState {
-    inventory: string[];
-    skills: Record<string, number>;
-    relationships: Record<string, number>;
-    mood: Mood;
     [key: string]: unknown;
 }
 interface AgentConfig {
@@ -48,13 +44,18 @@ interface AgentConfig {
     initialState?: Partial<AgentState>;
     memoryConfig?: MemoryConfig;
     apiUrl?: string;
+    /** Strategy to determine action when API/network fails */
+    fallbackStrategy?: (state: AgentState, context: Record<string, unknown>) => {
+        instruction: string;
+        directive: string;
+    };
 }
 interface AgentResponse {
     dialogue: string;
     action?: AgentAction;
     thought?: string;
 }
-type MemoryType = 'observation' | 'experience' | 'knowledge' | 'emotion';
+type MemoryType = string;
 interface MemoryConfig {
     /** Decay strategy: 'none' | 'temporal' */
     decay?: 'none' | 'temporal';
@@ -294,26 +295,6 @@ interface IBridge {
     listRules(): ValidationRule[];
     removeRule(ruleId: string): boolean;
 }
-/**
- * Rule: Movement must have valid coordinates
- */
-declare const movementRule: ValidationRule;
-/**
- * Rule: Attack must have valid target
- */
-declare const attackRule: ValidationRule;
-/**
- * Rule: Interact must have valid object
- */
-declare const interactRule: ValidationRule;
-/**
- * Rule: Speak must have non-empty text
- */
-declare const speakRule: ValidationRule;
-/**
- * Rule: Agent must have sufficient resources for action
- */
-declare const resourceRule: ValidationRule;
 /**
  * Factory function to create Bridge instance (Functional/Closure based)
  */
@@ -434,6 +415,60 @@ declare const generateEmbedding: (text: string) => Promise<number[]>;
 declare const getVectorTable: (dbPath: string, tableName?: string) => Promise<any>;
 declare const createTable: (dbPath: string, tableName: string, data: any[]) => Promise<any>;
 
+interface RPGAgentState extends AgentState {
+    inventory: string[];
+    hp: number;
+    mana: number;
+    skills: Record<string, number>;
+    relationships: Record<string, number>;
+    mood: string;
+}
+declare const RPG_MOODS: {
+    readonly hostile: "hostile";
+    readonly suspicious: "suspicious";
+    readonly neutral: "neutral";
+    readonly friendly: "friendly";
+    readonly loyal: "loyal";
+};
+declare const RPG_MEMORY_TYPES: {
+    readonly observation: "observation";
+    readonly experience: "experience";
+    readonly knowledge: "knowledge";
+    readonly emotion: "emotion";
+};
+declare const createRPGState: (partial?: Partial<RPGAgentState>) => RPGAgentState;
+declare const rpgFallbackStrategy: (state: AgentState, context: Record<string, unknown>) => {
+    instruction: string;
+    directive: string;
+};
+declare const movementRule: ValidationRule;
+declare const attackRule: ValidationRule;
+declare const interactRule: ValidationRule;
+declare const speakRule: ValidationRule;
+declare const resourceRule: ValidationRule;
+declare const rpgRules: ValidationRule[];
+declare const spatialRules: ValidationRule[];
+declare const socialRules: ValidationRule[];
+declare const puzzleRules: ValidationRule[];
+
+type presets_RPGAgentState = RPGAgentState;
+declare const presets_RPG_MEMORY_TYPES: typeof RPG_MEMORY_TYPES;
+declare const presets_RPG_MOODS: typeof RPG_MOODS;
+declare const presets_attackRule: typeof attackRule;
+declare const presets_createRPGState: typeof createRPGState;
+declare const presets_interactRule: typeof interactRule;
+declare const presets_movementRule: typeof movementRule;
+declare const presets_puzzleRules: typeof puzzleRules;
+declare const presets_resourceRule: typeof resourceRule;
+declare const presets_rpgFallbackStrategy: typeof rpgFallbackStrategy;
+declare const presets_rpgRules: typeof rpgRules;
+declare const presets_socialRules: typeof socialRules;
+declare const presets_spatialRules: typeof spatialRules;
+declare const presets_speakRule: typeof speakRule;
+declare namespace presets {
+  export { type presets_RPGAgentState as RPGAgentState, presets_RPG_MEMORY_TYPES as RPG_MEMORY_TYPES, presets_RPG_MOODS as RPG_MOODS, presets_attackRule as attackRule, presets_createRPGState as createRPGState, presets_interactRule as interactRule, presets_movementRule as movementRule, presets_puzzleRules as puzzleRules, presets_resourceRule as resourceRule, presets_rpgFallbackStrategy as rpgFallbackStrategy, presets_rpgRules as rpgRules, presets_socialRules as socialRules, presets_spatialRules as spatialRules, presets_speakRule as speakRule };
+}
+
 declare const init: () => void;
 
-export { type AgentAction, type AgentConfig, type AgentResponse, type AgentState, type BridgeConfig, type CompletionOptions, type CortexConfig, type CortexStatus, type Directive, type GhostConfig, type GhostHistoryEntry, type GhostResults, type GhostStatus, type GhostTestResult, type IAgent, type IBridge, type ICortex, type IGhost, type IMemory, type ISoul, type MemoryConfig, type MemoryItem, type MemoryModuleConfig, type MemoryType, type Mood, type Observation, type Soul, type SoulExportConfig, type SoulExportResult, type SoulImportConfig, type SoulListEntry, type ValidationContext, type ValidationResult, type ValidationRule, type VectorStatus, attackRule, createAgent, createAgentFromSoul, createBridge, createCortex, createGhost, createInitialState, createMemory, createMemoryItem, createSoul, createSoulInstance, createTable, deserializeSoul, exportSoulToIPFS, exportToSoul, fromSoul, generateEmbedding, getGhostHistory, getGhostResults, getGhostStatus, getSoulList, getVectorTable, importSoulFromIPFS, init, initVectorEngine, interactRule, movementRule, processAgentInput, resourceRule, serializeSoul, speakRule, startGhostSession, stopGhostSession, updateAgentState, validateAction, validateSoul, waitForGhostCompletion };
+export { type AgentAction, type AgentConfig, type AgentResponse, type AgentState, type BridgeConfig, type CompletionOptions, type CortexConfig, type CortexStatus, type Directive, type GhostConfig, type GhostHistoryEntry, type GhostResults, type GhostStatus, type GhostTestResult, type IAgent, type IBridge, type ICortex, type IGhost, type IMemory, type ISoul, type MemoryConfig, type MemoryItem, type MemoryModuleConfig, type MemoryType, type Mood, type Observation, type Soul, type SoulExportConfig, type SoulExportResult, type SoulImportConfig, type SoulListEntry, type ValidationContext, type ValidationResult, type ValidationRule, type VectorStatus, createAgent, createAgentFromSoul, createBridge, createCortex, createGhost, createInitialState, createMemory, createMemoryItem, createSoul, createSoulInstance, createTable, deserializeSoul, exportSoulToIPFS, exportToSoul, fromSoul, generateEmbedding, getGhostHistory, getGhostResults, getGhostStatus, getSoulList, getVectorTable, importSoulFromIPFS, init, initVectorEngine, presets, processAgentInput, serializeSoul, startGhostSession, stopGhostSession, updateAgentState, validateAction, validateSoul, waitForGhostCompletion };

package/dist/index.d.ts

@@ -32,12 +32,8 @@ interface CompletionOptions {
     stop?: string[];
     jsonSchema?: object;
 }
-type Mood = 'hostile' | 'suspicious' | 'neutral' | 'friendly' | 'loyal';
+type Mood = string;
 interface AgentState {
-    inventory: string[];
-    skills: Record<string, number>;
-    relationships: Record<string, number>;
-    mood: Mood;
     [key: string]: unknown;
 }
 interface AgentConfig {
@@ -48,13 +44,18 @@ interface AgentConfig {
     initialState?: Partial<AgentState>;
     memoryConfig?: MemoryConfig;
     apiUrl?: string;
+    /** Strategy to determine action when API/network fails */
+    fallbackStrategy?: (state: AgentState, context: Record<string, unknown>) => {
+        instruction: string;
+        directive: string;
+    };
 }
 interface AgentResponse {
     dialogue: string;
     action?: AgentAction;
     thought?: string;
 }
-type MemoryType = 'observation' | 'experience' | 'knowledge' | 'emotion';
+type MemoryType = string;
 interface MemoryConfig {
     /** Decay strategy: 'none' | 'temporal' */
     decay?: 'none' | 'temporal';
@@ -294,26 +295,6 @@ interface IBridge {
     listRules(): ValidationRule[];
     removeRule(ruleId: string): boolean;
 }
-/**
- * Rule: Movement must have valid coordinates
- */
-declare const movementRule: ValidationRule;
-/**
- * Rule: Attack must have valid target
- */
-declare const attackRule: ValidationRule;
-/**
- * Rule: Interact must have valid object
- */
-declare const interactRule: ValidationRule;
-/**
- * Rule: Speak must have non-empty text
- */
-declare const speakRule: ValidationRule;
-/**
- * Rule: Agent must have sufficient resources for action
- */
-declare const resourceRule: ValidationRule;
 /**
  * Factory function to create Bridge instance (Functional/Closure based)
  */
@@ -434,6 +415,60 @@ declare const generateEmbedding: (text: string) => Promise<number[]>;
 declare const getVectorTable: (dbPath: string, tableName?: string) => Promise<any>;
 declare const createTable: (dbPath: string, tableName: string, data: any[]) => Promise<any>;
 
+interface RPGAgentState extends AgentState {
+    inventory: string[];
+    hp: number;
+    mana: number;
+    skills: Record<string, number>;
+    relationships: Record<string, number>;
+    mood: string;
+}
+declare const RPG_MOODS: {
+    readonly hostile: "hostile";
+    readonly suspicious: "suspicious";
+    readonly neutral: "neutral";
+    readonly friendly: "friendly";
+    readonly loyal: "loyal";
+};
+declare const RPG_MEMORY_TYPES: {
+    readonly observation: "observation";
+    readonly experience: "experience";
+    readonly knowledge: "knowledge";
+    readonly emotion: "emotion";
+};
+declare const createRPGState: (partial?: Partial<RPGAgentState>) => RPGAgentState;
+declare const rpgFallbackStrategy: (state: AgentState, context: Record<string, unknown>) => {
+    instruction: string;
+    directive: string;
+};
+declare const movementRule: ValidationRule;
+declare const attackRule: ValidationRule;
+declare const interactRule: ValidationRule;
+declare const speakRule: ValidationRule;
+declare const resourceRule: ValidationRule;
+declare const rpgRules: ValidationRule[];
+declare const spatialRules: ValidationRule[];
+declare const socialRules: ValidationRule[];
+declare const puzzleRules: ValidationRule[];
+
+type presets_RPGAgentState = RPGAgentState;
+declare const presets_RPG_MEMORY_TYPES: typeof RPG_MEMORY_TYPES;
+declare const presets_RPG_MOODS: typeof RPG_MOODS;
+declare const presets_attackRule: typeof attackRule;
+declare const presets_createRPGState: typeof createRPGState;
+declare const presets_interactRule: typeof interactRule;
+declare const presets_movementRule: typeof movementRule;
+declare const presets_puzzleRules: typeof puzzleRules;
+declare const presets_resourceRule: typeof resourceRule;
+declare const presets_rpgFallbackStrategy: typeof rpgFallbackStrategy;
+declare const presets_rpgRules: typeof rpgRules;
+declare const presets_socialRules: typeof socialRules;
+declare const presets_spatialRules: typeof spatialRules;
+declare const presets_speakRule: typeof speakRule;
+declare namespace presets {
+  export { type presets_RPGAgentState as RPGAgentState, presets_RPG_MEMORY_TYPES as RPG_MEMORY_TYPES, presets_RPG_MOODS as RPG_MOODS, presets_attackRule as attackRule, presets_createRPGState as createRPGState, presets_interactRule as interactRule, presets_movementRule as movementRule, presets_puzzleRules as puzzleRules, presets_resourceRule as resourceRule, presets_rpgFallbackStrategy as rpgFallbackStrategy, presets_rpgRules as rpgRules, presets_socialRules as socialRules, presets_spatialRules as spatialRules, presets_speakRule as speakRule };
+}
+
 declare const init: () => void;
 
-export { type AgentAction, type AgentConfig, type AgentResponse, type AgentState, type BridgeConfig, type CompletionOptions, type CortexConfig, type CortexStatus, type Directive, type GhostConfig, type GhostHistoryEntry, type GhostResults, type GhostStatus, type GhostTestResult, type IAgent, type IBridge, type ICortex, type IGhost, type IMemory, type ISoul, type MemoryConfig, type MemoryItem, type MemoryModuleConfig, type MemoryType, type Mood, type Observation, type Soul, type SoulExportConfig, type SoulExportResult, type SoulImportConfig, type SoulListEntry, type ValidationContext, type ValidationResult, type ValidationRule, type VectorStatus, attackRule, createAgent, createAgentFromSoul, createBridge, createCortex, createGhost, createInitialState, createMemory, createMemoryItem, createSoul, createSoulInstance, createTable, deserializeSoul, exportSoulToIPFS, exportToSoul, fromSoul, generateEmbedding, getGhostHistory, getGhostResults, getGhostStatus, getSoulList, getVectorTable, importSoulFromIPFS, init, initVectorEngine, interactRule, movementRule, processAgentInput, resourceRule, serializeSoul, speakRule, startGhostSession, stopGhostSession, updateAgentState, validateAction, validateSoul, waitForGhostCompletion };
+export { type AgentAction, type AgentConfig, type AgentResponse, type AgentState, type BridgeConfig, type CompletionOptions, type CortexConfig, type CortexStatus, type Directive, type GhostConfig, type GhostHistoryEntry, type GhostResults, type GhostStatus, type GhostTestResult, type IAgent, type IBridge, type ICortex, type IGhost, type IMemory, type ISoul, type MemoryConfig, type MemoryItem, type MemoryModuleConfig, type MemoryType, type Mood, type Observation, type Soul, type SoulExportConfig, type SoulExportResult, type SoulImportConfig, type SoulListEntry, type ValidationContext, type ValidationResult, type ValidationRule, type VectorStatus, createAgent, createAgentFromSoul, createBridge, createCortex, createGhost, createInitialState, createMemory, createMemoryItem, createSoul, createSoulInstance, createTable, deserializeSoul, exportSoulToIPFS, exportToSoul, fromSoul, generateEmbedding, getGhostHistory, getGhostResults, getGhostStatus, getSoulList, getVectorTable, importSoulFromIPFS, init, initVectorEngine, presets, processAgentInput, serializeSoul, startGhostSession, stopGhostSession, updateAgentState, validateAction, validateSoul, waitForGhostCompletion };