Integrate Cognitive Loop into Agent Class #7968

Author: tobiu

ai/Agent.mjs

@@ -1,8 +1,14 @@
-import Base   from '../src/core/Base.mjs';
-import Client from './mcp/client/Client.mjs';
+import Base             from '../src/core/Base.mjs';
+import Client           from './mcp/client/Client.mjs';
+import ContextAssembler from './context/Assembler.mjs';
+import GeminiProvider   from './provider/Gemini.mjs';
+import Loop             from './agent/Loop.mjs';
+import Scheduler        from './agent/Scheduler.mjs';
 
 /**
- * A base class for AI Agents that manages multiple MCP Client connections.
+ * A base class for AI Agents that manages multiple MCP Client connections
+ * and orchestrates the autonomous cognitive runtime.
+ *
  * @class Neo.ai.Agent
  * @extends Neo.core.Base
  */
@@ -13,6 +19,16 @@ class Agent extends Base {
          * @protected
          */
         className: 'Neo.ai.Agent',
+        /**
+         * The Loop instance.
+         * @member {Neo.ai.agent.Loop|null} loop=null
+         */
+        loop: null,
+        /**
+         * The AI Provider class or instance.
+         * @member {Neo.ai.provider.Base} modelProvider=GeminiProvider
+         */
+        modelProvider: GeminiProvider,
         /**
          * A list of server names (keys in ClientConfig) to connect to.
          * @member {String[]} servers=[]
@@ -28,12 +44,13 @@ class Agent extends Base {
 
     /**
      * Async initialization sequence.
-     * Creates and connects all configured clients.
+     * Creates and connects all configured clients, then initializes the Cognitive Runtime.
      * @returns {Promise<void>}
      */
     async initAsync() {
         await super.initAsync();
 
+        // 1. Connect to MCP Servers
         const readyPromises = [];
 
         for (const serverName of this.servers) {
@@ -48,19 +65,70 @@ class Agent extends Base {
         }
 
         await Promise.all(readyPromises);
+        console.log('[Agent] Connected to MCP servers:', Object.keys(this.clients));
+
+        // 2. Initialize Cognitive Runtime
+        console.log('[Agent] Initializing Cognitive Runtime...');
+
+        const provider = Neo.create(this.modelProvider);
 
-        console.log('[Agent] Final clients map:', Object.keys(this.clients));
+        const assembler = Neo.create(ContextAssembler);
+        await assembler.initAsync(); // Connects to Memory Core via Services SDK
+
+        const scheduler = Neo.create(Scheduler);
+
+        // Create the Loop
+        this.loop = Neo.create(Loop, {
+            provider,
+            assembler,
+            scheduler,
+            // Inject clients into the loop for Tool Execution (Future Phase)
+            // tools: this.clients
+        });
+
+        console.log('[Agent] Runtime Ready.');
     }
 
     /**
-     * Disconnects all clients.
+     * Disconnects all clients and stops the loop.
      */
     async disconnect() {
+        this.stop();
+
         for (const client of Object.values(this.clients)) {
             await client.destroy();
         }
         this.clients = {};
     }
+
+    /**
+     * Starts the autonomous loop.
+     */
+    start() {
+        this.loop?.start();
+    }
+
+    /**
+     * Stops the autonomous loop.
+     */
+    stop() {
+        this.loop?.stop();
+    }
+
+    /**
+     * Schedules an event for the agent to process.
+     * @param {Object} event
+     * @param {String} event.type
+     * @param {*} event.data
+     * @param {String} [event.priority]
+     */
+    schedule(event) {
+        if (!this.loop) {
+            console.warn('[Agent] Cannot schedule event: Loop not initialized.');
+            return;
+        }
+        this.loop.scheduler.add(event);
+    }
 }
 
 export default Neo.setupClass(Agent);

ai/agent/Scheduler.mjs

@@ -42,6 +42,9 @@ class Scheduler extends Base {
      */
     add(event) {
         const priority = event.priority || this.determinePriority(event.type);
+        
+        // Ensure priority is set on the stored event for downstream visibility
+        event.priority = priority;
 
         if (!this.queues[priority]) {
             console.warn(`[Scheduler] Unknown priority '${priority}' for event '${event.type}'. Defaulting to 'normal'.`);

ai/examples/test-agent.mjs

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+
+import Neo from '../../src/Neo.mjs';
+import * as core from '../../src/core/_export.mjs';
+import Agent from '../Agent.mjs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import dotenv from 'dotenv';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+dotenv.config({path: path.resolve(__dirname, '../.env'), quiet: true});
+
+async function run() {
+    console.log('🧪 Testing Neo.ai.Agent Integration...');
+
+    if (!process.env.GEMINI_API_KEY) {
+        console.error('❌ Skipped: GEMINI_API_KEY not found');
+        return;
+    }
+
+    // 1. Create Agent (connecting to memory-core via MCP for testing if needed, but Loop uses SDK)
+    // We don't strictly need MCP servers running for this test since the Loop uses "Thick Client" services.
+    // But let's pass an empty servers list to keep it fast.
+    const agent = Neo.create(Agent, {
+        servers: [] 
+    });
+    
+    await agent.initAsync();
+
+    // 2. Feed Event
+    console.log('📥 Scheduling: "Who is the CEO of Google?"');
+    agent.schedule({
+        type: 'user:input',
+        data: 'Who is the CEO of Google?'
+    });
+
+    // 3. Start
+    agent.start();
+
+    // 4. Wait
+    setTimeout(() => {
+        agent.stop();
+        process.exit(0);
+    }, 5000);
+}
+
+run();