forbocai 0.3.0 → 0.3.3

package/dist/index.d.mts

@@ -17,7 +17,14 @@ interface CortexStatus {
     id: string;
     model: string;
     ready: boolean;
-    engine: 'webllm' | 'mock' | 'remote';
+    engine: 'webllm' | 'mock' | 'remote' | 'node-llama-cpp';
+}
+interface ICortex {
+    init(): Promise<CortexStatus>;
+    complete(prompt: string, options?: CompletionOptions): Promise<string>;
+    completeStream(prompt: string, options?: CompletionOptions): AsyncGenerator<string>;
+    processObservation(observation: Observation): Promise<Directive>;
+    generateAction(directive: Directive): Promise<AgentAction>;
 }
 interface CompletionOptions {
     temperature?: number;
@@ -34,7 +41,9 @@ interface AgentState {
     [key: string]: unknown;
 }
 interface AgentConfig {
-    cortex: any;
+    id: string;
+    cortex: ICortex;
+    memory: any;
     persona: string;
     initialState?: Partial<AgentState>;
     memoryConfig?: MemoryConfig;
@@ -65,11 +74,12 @@ interface Observation {
     timestamp: number;
     agentId?: string;
     gameId?: string;
-    data: Record<string, unknown>;
+    content: string;
+    data?: Record<string, unknown>;
     context?: Record<string, unknown>;
 }
 interface Directive {
-    type: 'system-prompt' | 'action-constraints' | 'behavior-rules';
+    type: 'system-prompt' | 'action-constraints' | 'behavior-rules' | 'thought';
     content: string;
     constraints?: Record<string, unknown>;
     priority?: 'high' | 'normal' | 'low';
@@ -92,43 +102,9 @@ interface Soul {
     signature?: string;
 }
 
-/**
- * Interface for Cortex inference engine
- */
-interface ICortex {
-    init(): Promise<CortexStatus>;
-    complete(prompt: string, options?: CompletionOptions): Promise<string>;
-    completeStream(prompt: string, options?: CompletionOptions): AsyncGenerator<string>;
-    processObservation(observation: Observation): Promise<Directive>;
-    generateAction(directive: Directive): Promise<AgentAction>;
-}
-/**
- * Cortex factory function - creates a new Cortex instance
- */
-declare const createCortex: (config: CortexConfig) => ICortex;
-/**
- * Pure function to generate completion text (Fallback/Mock)
- * Deterministic output for same input (functional principle)
- */
-declare const generateCompletion: (prompt: string, options: CompletionOptions, modelId: string) => string;
-/**
- * Pure function to process observation and return directive
- */
-declare const processObservationToDirective: (observation: Observation) => Directive;
-/**
- * Pure function to generate action from directive
- */
-declare const generateActionFromDirective: (directive: Directive) => AgentAction;
-/**
- * Mock Cortex for testing
- */
-declare class MockCortex implements ICortex {
-    init(): Promise<CortexStatus>;
-    complete(prompt: string): Promise<string>;
-    completeStream(prompt: string): AsyncGenerator<string>;
-    processObservation(observation: Observation): Promise<Directive>;
-    generateAction(directive: Directive): Promise<AgentAction>;
-}
+declare const createCortex: (config: CortexConfig) => ICortex & {
+    embed: (text: string) => Promise<number[]>;
+};
 
 /**
  * Interface for Agent operations
@@ -157,70 +133,123 @@ declare const processAgentInput: (currentState: AgentState, input: string, conte
  */
 declare const exportToSoul: (agentId: string, name: string, persona: string, state: AgentState, memories: MemoryItem[]) => Soul;
 /**
- * Factory function to create Agent
+ * Factory function to create Agent (Functional/Closure based)
  */
 declare const createAgent: (config: AgentConfig) => IAgent;
 /**
  * Pure function to import Agent from Soul
  */
-declare const fromSoul: (soul: Soul, cortex: ICortex) => IAgent;
+declare const fromSoul: (soul: Soul, cortex: ICortex, memory?: any) => IAgent;
 
 /**
- * Interface for Memory operations (Local Vector DB)
+ * Soul export configuration
  */
-interface IMemory {
-    store(text: string, type?: MemoryType, importance?: number): Promise<MemoryItem>;
-    recall(query: string, limit?: number): Promise<MemoryItem[]>;
-    list(limit?: number, offset?: number): Promise<MemoryItem[]>;
-    clear(): Promise<void>;
-    export(): Promise<MemoryItem[]>;
-    import(memories: MemoryItem[]): Promise<void>;
+interface SoulExportConfig {
+    /** API URL for IPFS pinning */
+    apiUrl?: string;
+    /** Include memories in export */
+    includeMemories?: boolean;
+    /** Sign with wallet (for NFT minting) */
+    sign?: boolean;
+    /** Use local IPFS node (Helia) */
+    useLocalNode?: boolean;
 }
 /**
- * Configuration for the memory module
+ * Soul export result
  */
-interface MemoryModuleConfig extends MemoryConfig {
-    /** Storage key/Database name for IndexedDB persistence */
-    storageKey?: string;
-    /** API URL for optional cloud sync */
+interface SoulExportResult {
+    cid: string;
+    ipfsUrl: string;
+    signature?: string;
+    soul: Soul;
+}
+/**
+ * Soul import configuration
+ */
+interface SoulImportConfig {
+    /** API URL for IPFS retrieval */
     apiUrl?: string;
-    /** Agent ID for API calls */
-    agentId?: string;
+    /** Verify signature before import */
+    verifySignature?: boolean;
+    /** Use local IPFS node (Helia) */
+    useLocalNode?: boolean;
 }
 /**
- * Pure function to create a new memory item
+ * Interface for Soul operations
  */
-declare const createMemoryItem: (text: string, type?: MemoryType, importance?: number) => MemoryItem;
+interface ISoul {
+    export(config?: SoulExportConfig): Promise<SoulExportResult>;
+    toJSON(): Soul;
+}
 /**
- * Pure function to calculate temporal decay
- * Older memories become less important over time
+ * Pure function to create a Soul from agent data
  */
-declare const applyTemporalDecay: (memory: MemoryItem, currentTime: number, decayRate?: number) => MemoryItem;
+declare const createSoul: (id: string, name: string, persona: string, state: AgentState, memories?: MemoryItem[]) => Soul;
 /**
- * Pure function to compute simple text similarity (cosine-like)
- * In production, this would use actual embeddings
+ * Pure function to serialize Soul to JSON string
  */
-declare const computeSimilarity: (text1: string, text2: string) => number;
+declare const serializeSoul: (soul: Soul) => string;
 /**
- * Pure function to rank memories by relevance
+ * Pure function to deserialize Soul from JSON string
  */
-declare const rankMemoriesByRelevance: (memories: readonly MemoryItem[], query: string, limit?: number) => MemoryItem[];
+declare const deserializeSoul: (json: string) => Soul;
 /**
- * Factory function to create Memory instance
+ * Pure function to validate Soul schema
  */
-declare const createMemory: (config?: MemoryModuleConfig) => IMemory;
+declare const validateSoul: (soul: Soul) => {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Export agent Soul to IPFS (Helia or API)
+ */
+declare const exportSoulToIPFS: (agentId: string, soul: Soul, config?: SoulExportConfig) => Promise<SoulExportResult>;
+/**
+ * Import Soul from IPFS by CID (Helia or API)
+ */
+declare const importSoulFromIPFS: (cid: string, config?: SoulImportConfig) => Promise<Soul>;
 /**
- * Mock Memory for testing (In-Memory Fallback)
+ * Soul entry in the listing
  */
-declare class MockMemory implements IMemory {
-    private memories;
+interface SoulListEntry {
+    cid: string;
+    name: string;
+    agentId?: string;
+    exportedAt: string;
+    ipfsUrl: string;
+}
+/**
+ * Get list of all exported Souls
+ */
+declare const getSoulList: (limit?: number, apiUrl?: string) => Promise<SoulListEntry[]>;
+/**
+ * Create agent from imported Soul via API
+ */
+declare const createAgentFromSoul: (cid: string, cortexId: string, config?: SoulImportConfig) => Promise<{
+    agentId: string;
+    persona: string;
+}>;
+/**
+ * Factory function to create Soul instance (Functional/Closure based)
+ */
+declare const createSoulInstance: (id: string, name: string, persona: string, state: AgentState, memories?: MemoryItem[], initialApiUrl?: string) => ISoul;
+
+/**
+ * Interface
+ */
+interface IMemory {
     store(text: string, type?: MemoryType, importance?: number): Promise<MemoryItem>;
     recall(query: string, limit?: number): Promise<MemoryItem[]>;
     list(limit?: number, offset?: number): Promise<MemoryItem[]>;
     clear(): Promise<void>;
-    export(): Promise<MemoryItem[]>;
-    import(memories: MemoryItem[]): Promise<void>;
 }
+interface MemoryModuleConfig extends MemoryConfig {
+    storageKey?: string;
+    apiUrl?: string;
+    agentId?: string;
+}
+declare const createMemoryItem: (text: string, type?: MemoryType, importance?: number) => MemoryItem;
+declare const createMemory: (config?: MemoryModuleConfig) => IMemory;
 
 /**
  * Validation rule definition
@@ -286,112 +315,14 @@ declare const speakRule: ValidationRule;
  */
 declare const resourceRule: ValidationRule;
 /**
- * Factory function to create Bridge instance
+ * Factory function to create Bridge instance (Functional/Closure based)
  */
 declare const createBridge: (config?: BridgeConfig) => IBridge;
-/**
- * Mock Bridge for testing
- */
-declare class MockBridge implements IBridge {
-    validate(action: AgentAction): Promise<ValidationResult>;
-    registerRule(_rule: ValidationRule): void;
-    listRules(): ValidationRule[];
-    removeRule(_ruleId: string): boolean;
-}
 /**
  * Pure function to validate action (standalone, no class needed)
  */
 declare const validateAction: (action: AgentAction, rules: readonly ValidationRule[], context?: ValidationContext) => ValidationResult;
 
-/**
- * Soul export configuration
- */
-interface SoulExportConfig {
-    /** API URL for IPFS pinning */
-    apiUrl?: string;
-    /** Include memories in export */
-    includeMemories?: boolean;
-    /** Sign with wallet (for NFT minting) */
-    sign?: boolean;
-    /** Use local IPFS node (Helia) */
-    useLocalNode?: boolean;
-}
-/**
- * Soul export result
- */
-interface SoulExportResult {
-    cid: string;
-    ipfsUrl: string;
-    signature?: string;
-    soul: Soul;
-}
-/**
- * Soul import configuration
- */
-interface SoulImportConfig {
-    /** API URL for IPFS retrieval */
-    apiUrl?: string;
-    /** Verify signature before import */
-    verifySignature?: boolean;
-    /** Use local IPFS node (Helia) */
-    useLocalNode?: boolean;
-}
-/**
- * Interface for Soul operations
- */
-interface ISoul {
-    export(config?: SoulExportConfig): Promise<SoulExportResult>;
-    toJSON(): Soul;
-}
-/**
- * Pure function to create a Soul from agent data
- */
-declare const createSoul: (id: string, name: string, persona: string, state: AgentState, memories?: MemoryItem[]) => Soul;
-/**
- * Pure function to serialize Soul to JSON string
- */
-declare const serializeSoul: (soul: Soul) => string;
-/**
- * Pure function to deserialize Soul from JSON string
- */
-declare const deserializeSoul: (json: string) => Soul;
-/**
- * Pure function to validate Soul schema
- */
-declare const validateSoul: (soul: Soul) => {
-    valid: boolean;
-    errors: string[];
-};
-/**
- * Export agent Soul to IPFS (Helia or API)
- */
-declare const exportSoulToIPFS: (agentId: string, soul: Soul, config?: SoulExportConfig) => Promise<SoulExportResult>;
-/**
- * Import Soul from IPFS by CID (Helia or API)
- */
-declare const importSoulFromIPFS: (cid: string, config?: SoulImportConfig) => Promise<Soul>;
-/**
- * Create agent from imported Soul via API
- */
-declare const createAgentFromSoul: (cid: string, cortexId: string, config?: SoulImportConfig) => Promise<{
-    agentId: string;
-    persona: string;
-}>;
-/**
- * Soul class for object-oriented usage
- */
-declare class SoulImpl implements ISoul {
-    private soul;
-    private apiUrl;
-    constructor(id: string, name: string, persona: string, state: AgentState, memories?: MemoryItem[], apiUrl?: string);
-    export(config?: SoulExportConfig): Promise<SoulExportResult>;
-    toJSON(): Soul;
-}
-/**
- * Factory function to create Soul instance
- */
-declare const createSoulInstance: (id: string, name: string, persona: string, state: AgentState, memories?: MemoryItem[], apiUrl?: string) => ISoul;
-
 /**
  * Ghost test configuration
  */
@@ -471,35 +402,38 @@ declare const getGhostResults: (sessionId: string, apiUrl?: string) => Promise<G
  */
 declare const waitForGhostCompletion: (sessionId: string, pollIntervalMs?: number, timeoutMs?: number, apiUrl?: string, onProgress?: (status: GhostStatus) => void) => Promise<GhostResults>;
 /**
- * Ghost class for object-oriented usage
+ * Stop a running Ghost session
  */
-declare class GhostSession implements IGhost {
-    private config;
-    private sessionId;
-    private apiUrl;
-    constructor(config: GhostConfig);
-    run(): Promise<string>;
-    status(): Promise<GhostStatus>;
-    results(): Promise<GhostResults>;
-    stop(): Promise<void>;
-    waitForCompletion(pollIntervalMs?: number, timeoutMs?: number, onProgress?: (status: GhostStatus) => void): Promise<GhostResults>;
+declare const stopGhostSession: (sessionId: string, apiUrl?: string) => Promise<{
+    stopped: boolean;
+    status: string;
+}>;
+/**
+ * Get Ghost session history
+ */
+interface GhostHistoryEntry {
+    sessionId: string;
+    testSuite: string;
+    startedAt: string;
+    completedAt?: string;
+    status: string;
+    passRate: number;
 }
+declare const getGhostHistory: (limit?: number, apiUrl?: string) => Promise<GhostHistoryEntry[]>;
 /**
- * Factory function to create Ghost session
+ * Factory function to create Ghost session (Functional/Closure based)
  */
 declare const createGhost: (config: GhostConfig) => IGhost;
 
-/**
- * ForbocAI SDK
- * The Infrastructure Layer for Autonomous AI Characters
- *
- * Functional Programming Principles:
- * - Pure functions with deterministic outputs
- * - Immutability - state never mutated directly
- * - No side effects in core logic
- * - Factory pattern for object creation
- */
+interface VectorStatus {
+    ready: boolean;
+    backend: 'lancedb' | 'memory';
+}
+declare const initVectorEngine: () => Promise<void>;
+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>;
 
 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 GhostResults, GhostSession, type GhostStatus, type GhostTestResult, type IAgent, type IBridge, type ICortex, type IGhost, type IMemory, type ISoul, type MemoryConfig, type MemoryItem, type MemoryModuleConfig, type MemoryType, MockBridge, MockCortex, MockMemory, type Mood, type Observation, type Soul, type SoulExportConfig, type SoulExportResult, SoulImpl, type SoulImportConfig, type ValidationContext, type ValidationResult, type ValidationRule, applyTemporalDecay, attackRule, computeSimilarity, createAgent, createAgentFromSoul, createBridge, createCortex, createGhost, createInitialState, createMemory, createMemoryItem, createSoul, createSoulInstance, deserializeSoul, exportSoulToIPFS, exportToSoul, fromSoul, generateActionFromDirective, generateCompletion, getGhostResults, getGhostStatus, importSoulFromIPFS, init, interactRule, movementRule, processAgentInput, processObservationToDirective, rankMemoriesByRelevance, resourceRule, serializeSoul, speakRule, startGhostSession, 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, 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 };