agentnet 0.0.1 → 0.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentnet",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "type": "module",
   "description": "Agent library used by Smartness",
   "main": "index.js",
@@ -15,7 +15,7 @@
     "@nats-io/transport-node": "^3.0.2",
     "colors": "^1.4.0",
     "openai": "^4.97.0",
-    "pg": "^8.15.6",
+    "pg-promise": "^11.13.0",
     "redis": "^5.0.1",
     "uuid": "^11.1.0",
     "yaml": "^2.7.1"

package/src/agent/agent.js

@@ -22,6 +22,7 @@ const DEFAULT_HOOKS = {
 const DEFAULT_CONFIG = {
     metadata: {
         name: "default",
+        namespace: "default",
         description: "A default agent"
     },
     runner: { 
@@ -39,9 +40,10 @@ const AGENT_CONFIG_SCHEMA = {
             type: 'object',
             properties: {
                 name: { type: 'string' },
+                namespace: { type: 'string' },
                 description: { type: 'string' }
             },
-            required: ['name']
+            required: ['name', 'namespace']
         },
         llm: {
             type: 'object',
@@ -118,6 +120,12 @@ export function Agent() {
                     metadata: config.metadata 
                 });
             }
+
+            if (!config.metadata.namespace.trim()) {
+                throw new ConfigurationError("Agent namespace cannot be empty", { 
+                    metadata: config.metadata 
+                });
+            }
             
             // LLM API validation
             if (typeof config.llm.api !== 'object' || config.llm.api === null) {

package/src/agent/runtime.js

@@ -8,7 +8,7 @@ export async function AgentRuntime(agentConfig) {
         toolsAndHandoffsMap,
         hooks,
         store,
-        metadata: { name: agentName },
+        metadata: { name: agentName, namespace },
         llm: { api: llmApi, config: llmConfig },
         runner,
         toolsSchemas: tools,
@@ -21,6 +21,7 @@ export async function AgentRuntime(agentConfig) {
     // Initialize IO runtime
     const natsInterfaces = ioInterfaces.filter(x => x.type === 'NatsIO')
     const { handleTask, discoveredAgents } = await NatsIOAgentRuntime(
+        namespace,
         agentName, 
         natsInterfaces, 
         discoverySchemas
@@ -94,7 +95,6 @@ export async function AgentRuntime(agentConfig) {
             
             // Execute agent runtime
             const result = await taskFunction(storeState.state, storeState.conversation, promptContent);
-
             // Process result through response hook
             const responseMessage = await response(storeState.state, storeState.conversation, result);
             // Save session state and session data

package/src/agent/runtimes/nats.js

@@ -16,10 +16,83 @@ const HEARTBEAT_INTERVAL = 1000;
 const TIMEOUT_TASK_REQUEST = 60000;
 const MAX_RECONNECT_ATTEMPTS = 5;
 
+/**
+ * Class representing a discovery message for agent capabilities
+ */
+class DiscoveryMessage {
+    /**
+     * Create a new discovery message
+     * @param {string} namespace - The agent namespace
+     * @param {string} agentName - The agent name
+     * @param {Array} schemas - The agent capability schemas
+     */
+    constructor(namespace, agentName, schemas) {
+        if (!namespace) throw new Error('Namespace is required');
+        if (!agentName) throw new Error('Agent name is required');
+        if (!Array.isArray(schemas)) throw new Error('Schemas must be an array');
+        
+        this.type = 'discovery';
+        this.network = `${namespace}.${agentName}`;
+        this.agentName = agentName;
+        this.schemas = schemas;
+    }
+    
+    /**
+     * Serialize the message to a JSON string
+     * @returns {string} The serialized message
+     */
+    serialize() {
+        return JSON.stringify({
+            type: this.type,
+            network: this.network,
+            agentName: this.agentName,
+            schemas: this.schemas
+        });
+    }
+    
+    /**
+     * Create a DiscoveryMessage from a serialized string
+     * @param {string} data - The serialized message data
+     * @returns {DiscoveryMessage} A new DiscoveryMessage instance
+     */
+    static fromString(data) {
+        const payload = JSON.parse(data);
+        
+        if (payload.type !== 'discovery') {
+            throw new Error('Not a discovery message');
+        }
+        
+        // Extract namespace from network (format: namespace.agentName)
+        const networkParts = payload.network.split('.');
+        if (networkParts.length !== 2) {
+            throw new Error('Invalid network format in discovery message');
+        }
+        
+        const namespace = networkParts[0];
+        return new DiscoveryMessage(namespace, payload.agentName, payload.schemas);
+    }
+    
+    /**
+     * Validate if a payload conforms to discovery message structure
+     * @param {Object} payload - The payload to validate
+     * @returns {boolean} Whether the payload is valid
+     */
+    static isValid(payload) {
+        return (
+            payload &&
+            typeof payload === 'object' &&
+            payload.type === 'discovery' &&
+            typeof payload.network === 'string' &&
+            typeof payload.agentName === 'string' &&
+            Array.isArray(payload.schemas)
+        );
+    }
+}
+
 /**
  * Sets up discovery subscription to find other agents
  */
-async function setupDiscoverySubscription(nc, discoveryTopic, agentName, discoveredAgents) {
+async function setupDiscoverySubscription(nc, discoveryTopic, namespace, agentName, discoveredAgents, acceptedNetworks) {
     let discoverySub;
     
     try {
@@ -35,27 +108,84 @@ async function setupDiscoverySubscription(nc, discoveryTopic, agentName, discove
     
     const handleDiscovery = async () => {
         try {
+            let nonAcceptedNetworks = {}
             for await (const m of discoverySub) {
                 try {
-                    const payloadSetup = JSON.parse(m.string());
-                    
-                    // Validate the payload structure
-                    if (!payloadSetup.agentName || !Array.isArray(payloadSetup.schemas)) {
-                        logger.warn('Invalid discovery payload received', { payload: payloadSetup });
+                    // Attempt to parse and validate the discovery message
+                    let discoveryMessage;
+                    try {
+                        discoveryMessage = DiscoveryMessage.fromString(m.string());
+                    } catch (parseError) {
+                        logger.warn('Invalid discovery message format', { error: parseError.message });
+                        continue;
+                    }
+
+                    const network = discoveryMessage.network;
+                    const networkNamespace = network.split(".")[0];
+                    const networkName = network.split(".")[1];
+
+                    // Skip self
+                    if (network === `${namespace}.${agentName}`) {
+                        continue;
+                    }
+
+                    // Skip if already processed
+                    if (nonAcceptedNetworks[network] === true) {
                         continue;
                     }
+
+                    let isAccepted = false;
+                    for (const acceptedNetwork of acceptedNetworks) {
+                        const acceptedNetworkNamespace = acceptedNetwork.split(".")[0];
+                        const acceptedNetworkName = acceptedNetwork.split(".")[1];
+
+                        if (acceptedNetworkNamespace === networkNamespace && acceptedNetworkName === networkName) {
+                            isAccepted = true;
+                            continue;
+                        }
+                        // Check for wildcard patterns in accepted networks
+                        
+                        if (acceptedNetworkNamespace === '*' && acceptedNetworkName === '*') {
+                            // Both namespace and name are wildcards, accept any network
+                            logger.debug(`Agent ${agentName} accepting network ${network} due to wildcard pattern *.*`);
+                            isAccepted = true;
+                            continue;
+                        }
+                        
+                        if (acceptedNetworkNamespace === '*' && acceptedNetworkName === networkName) {
+                            // Namespace is wildcard, but name matches
+                            logger.debug(`Agent ${agentName} accepting network ${network} due to wildcard pattern *.${networkName}`);
+                            isAccepted = true;
+                            continue;
+                        }
+                        
+                        if (acceptedNetworkNamespace === networkNamespace && acceptedNetworkName === '*') {
+                            // Name is wildcard, but namespace matches
+                            logger.debug(`Agent ${agentName} accepting network ${network} due to wildcard pattern ${networkNamespace}.*`);
+                            isAccepted = true;
+                            continue;
+                        }
+                    }
+
+                    // Skip if not accepted
+                    if (!isAccepted) {
+                        logger.warn(`Agent ${agentName} does not accept network ${network}`);
+                        nonAcceptedNetworks[network] = true;
+                        continue;
+                    }                
                     
-                    for (const schema of payloadSetup.schemas) {
+                    // Process the schemas from the discovery message
+                    for (const schema of discoveryMessage.schemas) {
                         // Skip invalid schemas
                         if (!schema || !schema.name) {
                             logger.warn('Invalid schema in discovery payload', { schema });
                             continue;
                         }
                         
-                        const agentKey = `${payloadSetup.agentName}-${schema.name}`;
+                        const agentKey = `${network}-${schema.name}`;
                         
-                        if (payloadSetup.agentName !== agentName && !discoveredAgents[agentKey]) {
-                            logger.info(`${agentName} discovered agent capability: ${payloadSetup.agentName} with capability ${schema.name}`);
+                        if (discoveryMessage.agentName !== agentName && !discoveredAgents[agentKey]) {
+                            logger.info(`${agentName} discovered agent capability: ${discoveryMessage.agentName} with capability ${schema.name}`);
                             
                             const handoffFunction = async (conversation, state, input) => {
                                 try {
@@ -70,7 +200,7 @@ async function setupDiscoverySubscription(nc, discoveryTopic, agentName, discove
                                                             content: input
                                                         })
                                                         const req = await nc.request(
-                                                            payloadSetup.agentName, 
+                                                            discoveryMessage.agentName, 
                                                             message.serialize(), 
                                                             { timeout: TIMEOUT_TASK_REQUEST }
                                                         );
@@ -79,7 +209,7 @@ async function setupDiscoverySubscription(nc, discoveryTopic, agentName, discove
                                                     {
                                                         maxRetries: 2,
                                                         onRetry: ({ attempt }) => {
-                                                            logger.warn(`Retrying handoff attempt ${attempt} to ${payloadSetup.agentName}`, {
+                                                            logger.warn(`Retrying handoff attempt ${attempt} to ${discoveryMessage.agentName}`, {
                                                                 schema: schema.name
                                                             });
                                                         }
@@ -88,18 +218,18 @@ async function setupDiscoverySubscription(nc, discoveryTopic, agentName, discove
                                                 return response;
                                             } catch (error) {
                                                 throw new HandoffError(
-                                                    `Handoff to agent ${payloadSetup.agentName} failed: ${error.message}`,
+                                                    `Handoff to agent ${discoveryMessage.agentName} failed: ${error.message}`,
                                                     agentName,
-                                                    payloadSetup.agentName,
+                                                    discoveryMessage.agentName,
                                                     { schemaName: schema.name }
                                                 );
                                             }
                                         },
                                         TIMEOUT_TASK_REQUEST,
-                                        `handoff to ${payloadSetup.agentName}`
+                                        `handoff to ${discoveryMessage.agentName}`
                                     );
                                 } catch (error) {
-                                    logger.error(`Handoff error to ${payloadSetup.agentName}`, {
+                                    logger.error(`Handoff error to ${discoveryMessage.agentName}`, {
                                         error,
                                         schema: schema.name
                                     });
@@ -141,18 +271,13 @@ async function setupDiscoverySubscription(nc, discoveryTopic, agentName, discove
 /**
  * Sets up a heartbeat to announce this agent's capabilities
  */
-function setupDiscoveryHeartbeat(nc, discoveryTopic, agentName, discoverySchemas) {
+function setupDiscoveryHeartbeat(nc, discoveryTopic, namespace, agentName, discoverySchemas) {
     let consecutiveErrors = 0;
     
     return setInterval(async () => {
         try {
-            const heartbeatPayload = {
-                type: 'discovery',
-                agentName: agentName,
-                schemas: discoverySchemas
-            };
-            
-            await nc.publish(discoveryTopic, JSON.stringify(heartbeatPayload));
+            const discoveryMessage = new DiscoveryMessage(namespace, agentName, discoverySchemas);
+            await nc.publish(discoveryTopic, discoveryMessage.serialize());
             
             // Reset error counter on success
             if (consecutiveErrors > 0) {
@@ -206,6 +331,7 @@ async function createTaskHandler(nc, agentName, processingFunction) {
                 if (!payload || typeof payload !== 'object') {
                     throw new Error('Invalid payload: not a JSON object');
                 }
+
                 const message = new Message(payload)
                 const input = message.getContent()
                 const session = message.getSession()
@@ -309,7 +435,7 @@ async function safeConnect(instance, options = {}) {
 /**
  * Creates a NATS-based runtime for agent communication
  */
-export async function NatsIOAgentRuntime(agentName, ioInterfaces, discoverySchemas) {
+export async function NatsIOAgentRuntime(namespace, agentName, ioInterfaces, discoverySchemas) {
     if (ioInterfaces.length > 1) {
         throw new TransportError(
             'Only one IO Nats interface is supported',
@@ -342,13 +468,14 @@ export async function NatsIOAgentRuntime(agentName, ioInterfaces, discoverySchem
         }
         
         const discoveryTopic = io.config.bindings.discoveryTopic;
+        const acceptedNetworks = io.config.bindings.acceptedNetworks || [];
         logger.info(`Agent ${agentName} initialized with discovery topic ${discoveryTopic}`);
 
         // Step 1. Subscribe to discovery topic
-        await setupDiscoverySubscription(nc, discoveryTopic, agentName, discoveredAgents);
+        await setupDiscoverySubscription(nc, discoveryTopic, namespace, agentName, discoveredAgents, acceptedNetworks);
 
         // Step 2. Publish discovery heartbeat
-        const interval = setupDiscoveryHeartbeat(nc, discoveryTopic, agentName, discoverySchemas);
+        const interval = setupDiscoveryHeartbeat(nc, discoveryTopic, namespace, agentName, discoverySchemas);
         intervals.push(interval);
 
         // Step 3. Create task handler

package/src/llm/gemini.js

@@ -97,8 +97,13 @@ const onResponse = async function (state, conversation, toolsAndHandoffsMap, res
             if (!toolsAndHandoffsMap[name] || !toolsAndHandoffsMap[name].function) {
                 throw new Error(`Tool "${name}" not found or has no function implementation`);
             }
-            
-            let result = await toolsAndHandoffsMap[name].function(conversation, state, args);
+
+            let result = null
+            if (toolsAndHandoffsMap[name].type === 'handoff') {
+                result = await toolsAndHandoffsMap[name].function(conversation, state, args);
+            } else {
+                result = await toolsAndHandoffsMap[name].function(state, args);
+            }
             if (toolsAndHandoffsMap[name].type === 'handoff') {
                 const resultParsed = JSON.parse(result)
                 // Update state with the result

package/src/llm/gpt.js

@@ -95,7 +95,12 @@ const onResponse = async function (state, conversation, toolsAndHandoffsMap, res
 				throw new Error(`Tool "${name}" not found or has no function implementation`);
 			}
 			
-			let result = await toolsAndHandoffsMap[name].function(conversation, state, args)
+			let result = null
+            if (toolsAndHandoffsMap[name].type === 'handoff') {
+                result = await toolsAndHandoffsMap[name].function(conversation, state, args);
+            } else {
+                result = await toolsAndHandoffsMap[name].function(state, args);
+            }			
 			conversation.push(toolCall)
             if (toolsAndHandoffsMap[name].type === 'handoff') {
                 console.log("GPT HANDOFF onResponse", name, result)

package/src/store/store.js

@@ -1,31 +1,6 @@
 import { v4 as uuid } from 'uuid'
 import { createClient } from 'redis'
-import pg from 'pg'
-
-let config = {
-    user: process.env.PG_USER || 'postgres',
-    host: process.env.PG_HOST || 'localhost', 
-    database: process.env.PG_DATABASE || 'postgres',
-    password: process.env.PG_PASSWORD || 'password',
-    port: process.env.PG_PORT || 5433
-}
-
-if (process.env.PG_USE_SSL == 'true' || process.env.PG_USE_SSL == true) {
-    config.ssl = {
-      rejectUnauthorized: false
-    }
-}
-
-const pool = new pg.Pool(config)
-
-pool.on('error', err => {
-    console.log(new Date(), 'Lost Postgres connection', err)
-})
-
-export async function getClient() {
-    const client = await pool.connect()
-    return client
-}
+import pgp from 'pg-promise'
 
 export function session (id) {
 	let state = {}
@@ -117,37 +92,96 @@ export function redisStore (_config = null) {
 	}
 }
 
-export function postgresStore (_config = null) {
-	let client = null
-	let config = _config
+export function postgresStore(config = null) {
+	let db = null;
+	const pgPromise = pgp(); // Initialize pg-promise
+	// Default connection config
+	const defaultConfig = {
+		host: process.env.PG_HOST || 'localhost',
+		port: process.env.PG_PORT || 5433,
+		database: process.env.PG_DATABASE || 'postgres',
+		user: process.env.PG_USER || 'postgres',
+		password: process.env.PG_PASSWORD || 'password',
+		max: 30, // max number of clients in the pool
+		ssl: process.env.PG_USE_SSL === 'true' ? { rejectUnauthorized: false } : null,
+		table: 'conversation_state',
+		schema: 'smartchat_agent'
+	};
+
+	const connectionConfig = config || defaultConfig;
 
 	return {
-		connect: async function () {
-			if (!client) {
-				client = await getClient()
+		connect: async function() {
+			if (!db) {				
+				// For URL-style connection string
+				if (typeof connectionConfig === 'string') {
+					db = pgPromise(connectionConfig);
+				} else {
+					db = pgPromise(connectionConfig);
+				}
+				
+				// Test connection
+				try {
+					await db.connect();
+					
+					// Create schema if not exists
+					await db.none('CREATE SCHEMA IF NOT EXISTS $1:name', [connectionConfig.schema]);
+					
+					// Create table if not exists
+					await db.none(`
+						CREATE TABLE IF NOT EXISTS $1:name.$2:name (
+							id UUID PRIMARY KEY,
+							state_id TEXT, 
+							state TEXT,
+							updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+						)
+					`, [connectionConfig.schema, connectionConfig.table]);
+					
+					// Create unique index if not exists
+					await db.none(`
+						CREATE UNIQUE INDEX IF NOT EXISTS idx_acc_agent_chat_id 
+						ON $1:name.$2:name(state_id)
+					`, [connectionConfig.schema, connectionConfig.table]);
+					
+				} catch (error) {
+					throw error;
+				}
 			}
 		},
-		disconnect: async function () {
-			if (client) {
-				await client.end()
-				client = null
+		
+		disconnect: async function() {
+			if (db) {
+				await pgPromise.end();
+				db = null;
 			}
 		},
-		set: async function (key, value) {
-			const id = uuid()
-			return await client.query('INSERT INTO smartchat_agent.conversation_state (state_id, state, id) VALUES ($1,$2,$3) ON CONFLICT (state_id) DO UPDATE SET state_id=$1, state=$2', [key, value, id])
-		},
-		get: async function (key) {
-			const res = await client.query('SELECT state FROM smartchat_agent.conversation_state WHERE state_id=$1', [key])
-			if (res.rows.length == 1) {
-				return res.rows[0].state
+		
+		set: async function(key, value) {
+			const id = uuid();
+			try {
+				return await db.one(
+					'INSERT INTO $1:name.$2:name (state_id, state, id) VALUES ($3, $4, $5) ON CONFLICT (state_id) DO UPDATE SET state=$4, updated_at=CURRENT_TIMESTAMP RETURNING id', 
+					[connectionConfig.schema, connectionConfig.table, key, value, id]
+				);
+			} catch (error) {
+				console.error('Error storing state:', error);
+				throw error;
 			}
-			if (res.rows.length > 1) {
-				throw 'Something went wrong at pg store'
+		},
+		
+		get: async function(key) {
+			try {
+				const result = await db.oneOrNone(
+					'SELECT state FROM $1:name.$2:name WHERE state_id = $3',
+					[connectionConfig.schema, connectionConfig.table, key]
+				);
+				return result ? result.state : null;
+			} catch (error) {
+				console.error('Error retrieving state:', error);
+				throw error;
 			}
-			return null
 		}
-	}
+	};
 }
 
 export function memoryStore () {