genesis-ai-cli 7.15.11 → 7.17.0

package/dist/src/consciousness/conscious-agent.d.ts

@@ -0,0 +1,218 @@
+/**
+ * Genesis 7.16 - Conscious Agent
+ *
+ * Unified orchestration of consciousness, perception, memory, and action.
+ *
+ * Architecture:
+ * ```
+ *                     ┌─────────────────────────────────────┐
+ *                     │          CONSCIOUS AGENT            │
+ *                     └─────────────────────────────────────┘
+ *                                      │
+ *          ┌───────────────────────────┼───────────────────────────┐
+ *          │                           │                           │
+ *          ▼                           ▼                           ▼
+ * ┌─────────────────┐       ┌─────────────────┐       ┌─────────────────┐
+ * │   PERCEPTION    │       │   COGNITION     │       │    ACTION       │
+ * │    STREAM       │       │                 │       │   SELECTION     │
+ * │                 │       │  ┌───────────┐  │       │                 │
+ * │  MCP Inputs:    │──────▶│  │ Cognitive │  │──────▶│  MCP Outputs:   │
+ * │  - Search       │       │  │ Workspace │  │       │  - GitHub       │
+ * │  - ArXiv        │       │  └───────────┘  │       │  - AWS          │
+ * │  - Memory       │       │        │        │       │  - Filesystem   │
+ * │  - Filesystem   │       │        ▼        │       │  - Stability    │
+ * │                 │       │  ┌───────────┐  │       │                 │
+ * └─────────────────┘       │  │  Global   │  │       └─────────────────┘
+ *                           │  │ Workspace │  │
+ *          ┌────────────────│  └───────────┘  │────────────────┐
+ *          │                │        │        │                │
+ *          ▼                │        ▼        │                ▼
+ * ┌─────────────────┐       │  ┌───────────┐  │       ┌─────────────────┐
+ * │   PHI MONITOR   │◀──────│  │   Active  │  │──────▶│    MEMORY       │
+ * │                 │       │  │ Inference │  │       │    SYSTEM       │
+ * │  - IIT φ calc   │       │  └───────────┘  │       │                 │
+ * │  - Integration  │       │                 │       │  - Episodic     │
+ * │  - Anomalies    │       └─────────────────┘       │  - Semantic     │
+ * │                 │                                 │  - Procedural   │
+ * └─────────────────┘                                 └─────────────────┘
+ * ```
+ *
+ * The ConsciousAgent:
+ * 1. Receives perceptions from MCP servers
+ * 2. Integrates them in the CognitiveWorkspace
+ * 3. Competes for conscious access in GlobalWorkspace
+ * 4. Monitors integration via φ (PhiMonitor)
+ * 5. Selects actions via Active Inference to minimize free energy
+ * 6. Executes actions through MCP servers
+ */
+import { EventEmitter } from 'events';
+import { MCPClientManager, MCPTool } from '../mcp/client-manager.js';
+import { ConsciousnessSystem, ConsciousnessSnapshot, ConsciousnessState } from './index.js';
+import { PerceptionStream, Perception } from './perception-stream.js';
+import { CognitiveWorkspace } from '../memory/cognitive-workspace.js';
+export interface ActionCandidate {
+    id: string;
+    type: 'mcp_tool' | 'internal' | 'query';
+    server?: string;
+    tool?: string;
+    args?: Record<string, unknown>;
+    description: string;
+    expectedUtility: number;
+    expectedCost: number;
+    uncertaintyReduction: number;
+    source: 'goal' | 'perception' | 'inference';
+}
+export interface ActionResult {
+    action: ActionCandidate;
+    success: boolean;
+    result?: unknown;
+    error?: Error;
+    duration: number;
+    perception?: Perception;
+}
+export interface ConsciousAgentConfig {
+    /** Agent name */
+    name: string;
+    /** Update interval for consciousness cycle (ms) */
+    cycleIntervalMs: number;
+    /** Enable auto-perception from MCP calls */
+    autoPerceive: boolean;
+    /** Enable φ-based action modulation */
+    phiModulation: boolean;
+    /** Minimum φ to take actions */
+    minPhiForAction: number;
+    /** Maximum actions per cycle */
+    maxActionsPerCycle: number;
+    /** Enable verbose logging */
+    verbose: boolean;
+}
+export declare const DEFAULT_CONSCIOUS_AGENT_CONFIG: ConsciousAgentConfig;
+export type AgentEventType = 'cycle:start' | 'cycle:end' | 'perception:received' | 'action:selected' | 'action:executed' | 'phi:changed' | 'state:changed' | 'goal:set';
+export type AgentEventHandler = (event: {
+    type: AgentEventType;
+    data?: unknown;
+}) => void;
+/**
+ * Conscious Agent - Orchestrates perception, cognition, and action
+ */
+export declare class ConsciousAgent extends EventEmitter {
+    private config;
+    readonly mcpManager: MCPClientManager;
+    readonly consciousness: ConsciousnessSystem;
+    readonly perceptions: PerceptionStream;
+    readonly workspace: CognitiveWorkspace;
+    private currentGoal;
+    private actionQueue;
+    private actionHistory;
+    private cycleCount;
+    private cycleTimer?;
+    private running;
+    constructor(mcpManager: MCPClientManager, config?: Partial<ConsciousAgentConfig>);
+    /**
+     * Wire all systems together for integrated operation
+     */
+    private wireSystemsTogether;
+    /**
+     * Get current system state for φ calculation
+     */
+    private getSystemState;
+    /**
+     * Calculate connection strength between two elements
+     */
+    private calculateConnectionStrength;
+    /**
+     * Start the conscious agent
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the conscious agent
+     */
+    stop(): Promise<void>;
+    isRunning(): boolean;
+    /**
+     * Run one consciousness cycle
+     */
+    runCycle(): Promise<void>;
+    /**
+     * Generate action candidates based on current context
+     */
+    private generateActionCandidates;
+    /**
+     * Generate actions to achieve a goal
+     */
+    private generateGoalActions;
+    /**
+     * Generate actions based on a perception
+     */
+    private generatePerceptionActions;
+    /**
+     * Generate actions to reduce uncertainty (Active Inference)
+     */
+    private generateInferenceActions;
+    /**
+     * Select best actions using Active Inference principles
+     *
+     * Minimizes Expected Free Energy:
+     * G = Risk + Ambiguity
+     *   = D_KL[Q(o|π) || P(o)] + E_Q[-log P(o|s)]
+     *
+     * In practice: prefer actions that:
+     * 1. Reduce uncertainty (high uncertaintyReduction)
+     * 2. Achieve goals (high expectedUtility)
+     * 3. Have low cost (low expectedCost)
+     */
+    private selectActions;
+    /**
+     * Calculate Expected Free Energy for an action
+     */
+    private calculateEFE;
+    /**
+     * Execute an action
+     */
+    executeAction(action: ActionCandidate): Promise<ActionResult>;
+    /**
+     * Set the current goal
+     */
+    setGoal(goal: string): void;
+    /**
+     * Get current goal
+     */
+    getGoal(): string;
+    /**
+     * Queue an action for execution
+     */
+    queueAction(action: Omit<ActionCandidate, 'id'>): string;
+    /**
+     * Call an MCP tool directly (bypasses action selection)
+     */
+    callTool<T = unknown>(server: string, tool: string, args: Record<string, unknown>): Promise<T>;
+    /**
+     * Get available MCP tools
+     */
+    getAvailableTools(): MCPTool[];
+    /**
+     * Get consciousness snapshot
+     */
+    getConsciousnessSnapshot(): ConsciousnessSnapshot;
+    /**
+     * Get agent statistics
+     */
+    stats(): {
+        name: string;
+        running: boolean;
+        cycles: number;
+        phi: number;
+        state: ConsciousnessState;
+        perceptions: number;
+        workingMemory: number;
+        queuedActions: number;
+        executedActions: number;
+        successRate: number;
+        connectedMCPs: string[];
+    };
+    private log;
+}
+export declare function createConsciousAgent(mcpManager: MCPClientManager, config?: Partial<ConsciousAgentConfig>): ConsciousAgent;
+export declare function getConsciousAgent(mcpManager: MCPClientManager, config?: Partial<ConsciousAgentConfig>): ConsciousAgent;
+export declare function initializeConsciousAgent(mcpManager: MCPClientManager, config?: Partial<ConsciousAgentConfig>): Promise<ConsciousAgent>;
+export declare function resetConsciousAgent(): void;