agentnet 0.0.1 → 0.0.3

package/{src/examples/def3.js → examples/smartness/index.js}

@@ -1,4 +1,4 @@
-import { AgentLoaderFile, AgentClient, NatsIO, Bindings, Message, PostgresStore } from "../index.js"
+import { AgentLoaderFile, AgentClient, NatsIO, Bindings, Message, PostgresStore, RedisStore, MemoryStore } from "../../src/index.js"
 
 // NatsIO instance
 const io = NatsIO({
@@ -6,16 +6,16 @@ const io = NatsIO({
 })
 
 // Load the agents from the YAML file
-const agents = await AgentLoaderFile('./src/examples/agents-smartness.yaml', {
-    bindings: { [Bindings.NatsIO]: io, [Bindings.Postgres]: PostgresStore() }
+const agents = await AgentLoaderFile('./examples/smartness/agents-smartness.yaml', {
+    bindings: { [Bindings.NatsIO]: io, [Bindings.Postgres]: PostgresStore(), [Bindings.Redis]: RedisStore(), [Bindings.Memory]: MemoryStore() }
 })
 
 // Entry point
-const agentSmartness = await agents.smartnessAgent
+const agentSmartness = await agents.entrypoint
 await agentSmartness.compile()
 
 // Accomodation agent
-const agentAccomodation = await agents.accomodationAgent
+const agentAccomodation = await agents.accomodation
 agentAccomodation.tools.getRoomsListTool.bind(async (state, input) => {
     return { answer: "We have Double room with a view of the sea and a single room with a view of the pool, and a suite with a view of the city." }
 })
@@ -29,21 +29,21 @@ agentAccomodation.prompt(async (state, input) => {
 await agentAccomodation.compile()
 
 // Booking agent
-const agentBooking = await agents.bookingAgent
+const agentBooking = await agents.booking
 agentBooking.tools.bookRoomTool.bind(async (state, input) => {
     return { answer: "The room " + input.roomName + " has been booked for the dates " + input.checkinDate + " to " + input.checkoutDate + "." }
 })
 await agentBooking.compile()
 
 // Hotel review agent
-const agentHotelReview = await agents.hotelReviewAgent
+const agentHotelReview = await agents.review
 agentHotelReview.tools.getHotelReviewsTool.bind(async (state, input) => {
     return { answer: "The hotel " + input.hotelName + " has a 4.5 star rating and a 9.2 out of 10 guest satisfaction score." }
 })
 await agentHotelReview.compile()
 
 // Pricing agent
-const agentPricing = await agents.pricingAgent
+const agentPricing = await agents.pricing
 agentPricing.tools.getPricingTool.bind(async (state, input) => {
     return { answer: "The room " + input.roomName + " has a price of 200€ per night." }
 })
@@ -60,7 +60,7 @@ const message = new Message({
         id: "67a71e42-a7d8-1db2-ad17-64e1c8546b21"
     }
 })
-const res = await agentClient.queryIo(io, 'smartnessAgent', message)
+const res = await agentClient.queryIo(io, 'entrypoint', message)
 console.log("=======\n", res.getContent())
 console.log("=======\n", res.getSession())
 //const res2 = await agentClient.queryIo(io, 'smartnessAgent', "Quanto costa la camera doppia del Flora per il 10-05-2025 per due persone? Prenotala se costa meno di 100€ la camera double con vista mare per il 10-05-2025 al hotel Flora")

package/jest.config.js

@@ -0,0 +1 @@
+export default { transform: {} }

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "agentnet",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "type": "module",
   "description": "Agent library used by Smartness",
   "main": "index.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "node --experimental-vm-modules ./node_modules/.bin/jest --rootDir=src/tests"
   },
   "author": "",
   "license": "ISC",
@@ -15,9 +15,12 @@
     "@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"
+  },
+  "devDependencies": {
+    "jest": "^29.7.0"
   }
 }

package/src/agent/agent-loader.js

@@ -2,6 +2,18 @@ import fs from 'fs'
 import { parse } from 'yaml'
 import { Gemini } from "../index.js"
 import { Agent } from "./agent.js"
+import { logger } from "../utils/logger.js"
+import { ConfigurationError } from "../errors/index.js"
+import { validateApiVersion, DEFAULT_API_VERSION, API_VERSIONS } from '../utils/version.js'
+
+/**
+ * Version handlers for different API versions
+ */
+const VERSION_HANDLERS = {
+    'smartagent.io/v1alpha1': processV1Alpha1Definition,
+    'agentnet.io/v1alpha1': processV1Alpha1Definition
+    // Additional version handlers can be added here as the API evolves
+};
 
 /**
  * Loads agent definitions from a YAML file
@@ -47,10 +59,10 @@ function parseAgentDefinitionsFromYaml(yamlContent) {
             if (isValidAgentDefinition(definition)) {
                 agentDefinitions.push(definition);
             } else {
-                console.warn("Skipping invalid or non-AgentDefinition document in YAML.");
+                logger.warn("Skipping invalid or non-AgentDefinition document in YAML.");
             }
         } catch (error) {
-            console.warn(`Failed to parse YAML document: ${error.message}`);
+            logger.warn(`Failed to parse YAML document: ${error.message}`);
         }
     }
     
@@ -66,6 +78,58 @@ function isValidAgentDefinition(definition) {
     return definition && definition.kind === 'AgentDefinition' && definition.spec;
 }
 
+/**
+ * Gets the appropriate version handler for a definition
+ * @param {object} definition - Agent definition
+ * @returns {Function} Version handler function
+ * @throws {ConfigurationError} If version is unsupported
+ */
+function getVersionHandler(definition) {
+    // Validate the API version using our utility
+    const versionData = validateApiVersion(definition);
+    const apiVersion = versionData.version;
+    
+    // Get the appropriate handler for this version
+    const handler = VERSION_HANDLERS[apiVersion];
+    
+    if (!handler) {
+        throw new ConfigurationError(
+            `No implementation handler for apiVersion '${apiVersion}'`,
+            { apiVersion, supportedHandlers: Object.keys(VERSION_HANDLERS) }
+        );
+    }
+    
+    return handler;
+}
+
+/**
+ * Process a v1alpha1 agent definition
+ * @param {object} definition - Agent definition
+ * @param {object} agentBuilder - Agent builder
+ * @param {object} bindings - IO and store bindings
+ * @returns {object} Processed agent interface and tool map
+ */
+async function processV1Alpha1Definition(definition, agentBuilder, bindings) {
+    const spec = definition.spec;
+    
+    // Add apiVersion to agent metadata
+    agentBuilder.setMetadata({
+        ...agentBuilder._config.metadata,
+        apiVersion: definition.apiVersion || DEFAULT_API_VERSION
+    });
+    
+    // Configure different aspects of the agent
+    agentBuilder = configureIO(agentBuilder, spec.io, bindings);
+    agentBuilder = configureStore(agentBuilder, spec.store, bindings);
+    agentBuilder = await configureLLM(agentBuilder, spec.llm);
+    agentBuilder = configureDiscoverySchemas(agentBuilder, spec.discoverySchemas);
+    
+    // Set up tools
+    const toolMap = configureTools(agentBuilder, spec.tools);
+    
+    return { agentBuilder, toolMap };
+}
+
 /**
  * Loads an LLM provider instance
  * @param {string} providerName - Name of the provider
@@ -237,7 +301,6 @@ async function AgentLoader(agentsDefinitions, config = {}) {
                 throw new Error(`Invalid agent definition: missing spec`);
             }
             
-            const spec = definition.spec;
             const metadata = definition.metadata || { 
                 name: "default", 
                 description: "Agent from definition" 
@@ -250,21 +313,21 @@ async function AgentLoader(agentsDefinitions, config = {}) {
             // Initialize agent builder with metadata
             let agentBuilder = Agent().setMetadata(metadata);
             
-            // Configure different aspects of the agent
-            agentBuilder = configureIO(agentBuilder, spec.io, bindings);
-            agentBuilder = configureStore(agentBuilder, spec.store, bindings);
-            agentBuilder = await configureLLM(agentBuilder, spec.llm);
-            agentBuilder = configureDiscoverySchemas(agentBuilder, spec.discoverySchemas);
+            // Get the appropriate version handler
+            const versionHandler = getVersionHandler(definition);
             
-            // Set up tools
-            const toolMap = configureTools(agentBuilder, spec.tools);
+            // Process according to API version
+            const { agentBuilder: updatedBuilder, toolMap } = 
+                await versionHandler(definition, agentBuilder, bindings);
             
             // Create the agent interface
-            loadedAgents[metadata.name] = createAgentInterface(agentBuilder, toolMap);
+            loadedAgents[metadata.name] = createAgentInterface(updatedBuilder, toolMap);
+            
+            logger.info(`Agent '${metadata.name}' loaded successfully with apiVersion: ${definition.apiVersion || DEFAULT_API_VERSION}`);
             
         } catch (error) {
             const agentName = definition.metadata?.name || 'Unnamed Agent';
-            console.error(`Failed to load agent "${agentName}": ${error.message}`);
+            logger.error(`Failed to load agent "${agentName}": ${error.message}`, { error });
             // Optional: decide whether to throw or just log and continue
             // throw error;
         }

package/src/agent/agent.js

@@ -22,7 +22,9 @@ const DEFAULT_HOOKS = {
 const DEFAULT_CONFIG = {
     metadata: {
         name: "default",
-        description: "A default agent"
+        namespace: "default",
+        description: "A default agent",
+        apiVersion: "agentnet/v1alpha1" // Default API version
     },
     runner: { 
         maxRuns: 10
@@ -39,9 +41,11 @@ const AGENT_CONFIG_SCHEMA = {
             type: 'object',
             properties: {
                 name: { type: 'string' },
-                description: { type: 'string' }
+                namespace: { type: 'string' },
+                description: { type: 'string' },
+                apiVersion: { type: 'string' }
             },
-            required: ['name']
+            required: ['name', 'namespace']
         },
         llm: {
             type: 'object',
@@ -118,6 +122,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

@@ -1,14 +1,14 @@
 import { build, makeToolsAndHandoffsMap } from "./executor.js"
-import { NatsIOAgentRuntime } from "./runtimes/nats.js"
 import { logger } from "../utils/logger.js"
 import { Response, SessionStore } from "../index.js"
+import { createAgentRuntime } from "../transport/index.js"
 
 export async function AgentRuntime(agentConfig) {
     const {
         toolsAndHandoffsMap,
         hooks,
         store,
-        metadata: { name: agentName },
+        metadata: { name: agentName, namespace },
         llm: { api: llmApi, config: llmConfig },
         runner,
         toolsSchemas: tools,
@@ -19,10 +19,14 @@ export async function AgentRuntime(agentConfig) {
     } = agentConfig
     
     // Initialize IO runtime
-    const natsInterfaces = ioInterfaces.filter(x => x.type === 'NatsIO')
-    const { handleTask, discoveredAgents } = await NatsIOAgentRuntime(
+    const transportType = ioInterfaces.length > 0 ? ioInterfaces[0].type.replace('IO', '').toLowerCase() : 'nats';
+    logger.info(`Creating agent runtime with transport type: ${transportType}`);
+    
+    const { handleTask, discoveredAgents } = await createAgentRuntime(
+        transportType,
+        namespace,
         agentName, 
-        natsInterfaces, 
+        ioInterfaces, 
         discoverySchemas
     )
     
@@ -94,7 +98,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/llm/base.js

@@ -0,0 +1,131 @@
+import { logger } from '../utils/logger.js'
+import { LLMError } from '../errors/index.js'
+
+/**
+ * Base class for LLM implementations
+ * Provides common functionality and defines required interface
+ */
+export class BaseLLM {
+  /**
+   * @param {string} providerType - The LLM provider type (e.g., 'gemini', 'openai')
+   */
+  constructor(providerType) {
+    this.type = providerType;
+  }
+
+  /**
+   * Initialize and get the LLM client
+   * @returns {Promise<any>} Initialized LLM client
+   * @throws {LLMError} If initialization fails
+   */
+  async getClient() {
+    throw new Error('getClient() must be implemented by subclasses');
+  }
+
+  /**
+   * Call the LLM model with the provided configuration and context
+   * @param {Object} config - LLM-specific configuration
+   * @param {Object} context - Context containing client, tools map and conversation
+   * @returns {Promise<Object>} The model response
+   * @throws {LLMError} If the API call fails
+   */
+  async callModel(config, context) {
+    throw new Error('callModel() must be implemented by subclasses');
+  }
+
+  /**
+   * Process the model response, handling text responses and function calls
+   * @param {Object} state - Current application state
+   * @param {Array} conversation - The conversation history
+   * @param {Object} toolsAndHandoffsMap - Map of available tools
+   * @param {Object} response - The model response to process
+   * @returns {Promise<string|null>} Text response or null if processing tool calls
+   */
+  async onResponse(state, conversation, toolsAndHandoffsMap, response) {
+    throw new Error('onResponse() must be implemented by subclasses');
+  }
+
+  /**
+   * Add a user prompt to the conversation
+   * @param {Array} conversation - The conversation history
+   * @param {string} formattedPrompt - The formatted user prompt
+   * @returns {Promise<void>}
+   */
+  async prompt(conversation, formattedPrompt) {
+    logger.debug('Adding user prompt to conversation', {
+      promptPreview: formattedPrompt.substring(0, 100)
+    });
+    
+    // Subclasses must implement appropriate conversation format
+  }
+
+  /**
+   * Check if required API key is set in environment variables
+   * @param {string} keyName - Environment variable name for the API key
+   * @returns {void}
+   * @throws {LLMError} If API key is not set
+   */
+  checkApiKey(keyName) {
+    if (!process.env[keyName]) {
+      throw new LLMError(
+        `${keyName} environment variable is not set`,
+        this.type
+      );
+    }
+  }
+
+  /**
+   * Execute a tool call from the model response
+   * @param {Object} toolCall - The tool call to execute
+   * @param {Object} state - Current application state
+   * @param {Array} conversation - The conversation history
+   * @param {Object} toolsAndHandoffsMap - Map of available tools
+   * @returns {Promise<any>} Result of the tool execution
+   */
+  async executeToolCall(toolCall, name, args, state, conversation, toolsAndHandoffsMap) {
+    logger.debug(`Executing tool from ${this.type}`, { 
+      toolName: name,
+      argsPreview: JSON.stringify(args).substring(0, 100)
+    });
+    
+    try {
+      if (!toolsAndHandoffsMap[name] || !toolsAndHandoffsMap[name].function) {
+        throw new Error(`Tool "${name}" not found or has no function implementation`);
+      }
+
+      let result = null;
+      if (toolsAndHandoffsMap[name].type === 'handoff') {
+        result = await toolsAndHandoffsMap[name].function(conversation, state, args);
+        // Process handoff results if needed
+        this.processHandoffResult(result, state);
+      } else {
+        result = await toolsAndHandoffsMap[name].function(state, args);
+      }
+      
+      logger.debug('Tool execution successful', { toolName: name });
+      return result;
+      
+    } catch (error) {
+      logger.error(`Error executing tool "${name}"`, { error });
+      throw error;
+    }
+  }
+  
+  /**
+   * Process the result of a handoff operation
+   * @param {string} result - The JSON string result from handoff
+   * @param {Object} state - The state to update
+   */
+  processHandoffResult(result, state) {
+    try {
+      const resultParsed = JSON.parse(result);
+      if (resultParsed.session) {
+        Object.entries(resultParsed.session).forEach(([key, value]) => {
+          state[key] = value;
+        });
+      }
+    } catch (error) {
+      logger.error('Failed to process handoff result', { error });
+    }
+  }
+}