agentnet 0.0.7 → 0.1.0

package/README.md

@@ -179,25 +179,6 @@ When creating agent definitions, you should specify which API version you're tar
 
 If you don't specify an `apiVersion`, Agentnet will default to `agentnet/v1alpha1` but will log a warning.
 
-#### Version Migration Tool
-
-Agentnet includes a command-line tool to help migrate your agent definitions to newer API versions:
-
-```bash
-# Migrate a YAML file to the latest version
-node src/tools/migrate-version.js ./agents.yaml
-
-# Specify a target version
-node src/tools/migrate-version.js ./agents.yaml --version agentnet.io/v1alpha1
-
-# Write to a specific output file
-node src/tools/migrate-version.js ./agents.yaml --output ./agents-new.yaml
-
-# Just check if migration is needed without modifying
-node src/tools/migrate-version.js ./agents.yaml --check
-```
-
-This tool helps you keep your agent definitions up-to-date with the latest features while maintaining compatibility with the Agentnet platform.
 
 ### Dynamic Implementation (JavaScript)
 
@@ -286,7 +267,7 @@ const message = new Message({
 
 // Query the agent using the client
 console.log("Sending query to the entrypoint agent...");
-const response = await client.queryIo(natsIO, 'entrypointAgent', message);
+const response = await client.queryIo(natsIO, 'smartchat.entrypointAgent', message); // {namespace}.{name}
 
 // Process the response
 console.log("Agent Response:", response.getContent());

package/examples/customer-support/agents.yaml

@@ -1,5 +1,5 @@
 ---
-apiVersion: smartagent.io/v1alpha1
+apiVersion: agentnet/v1alpha1
 kind: AgentDefinition
 metadata:
   name: triageAgent
@@ -67,7 +67,7 @@ spec:
           - queryId
 
 ---
-apiVersion: smartagent.io/v1alpha1
+apiVersion: agentnet/v1alpha1
 kind: AgentDefinition
 metadata:
   name: productAgent
@@ -141,7 +141,7 @@ spec:
           - question
 
 ---
-apiVersion: smartagent.io/v1alpha1
+apiVersion: agentnet/v1alpha1
 kind: AgentDefinition
 metadata:
   name: technicalAgent
@@ -221,7 +221,7 @@ spec:
           - issue
 
 ---
-apiVersion: smartagent.io/v1alpha1
+apiVersion: agentnet/v1alpha1
 kind: AgentDefinition
 metadata:
   name: billingAgent
@@ -300,7 +300,7 @@ spec:
           - question
 
 ---
-apiVersion: smartagent.io/v1alpha1
+apiVersion: agentnet/v1alpha1
 kind: AgentDefinition
 metadata:
   name: escalationAgent
@@ -380,7 +380,7 @@ spec:
           - complexIssue
 
 ---
-apiVersion: smartagent.io/v1alpha1
+apiVersion: agentnet/v1alpha1
 kind: AgentDefinition
 metadata:
   name: followupAgent

package/examples/customer-support/index.js

@@ -349,7 +349,7 @@ async function main() {
   
   // Start with the triage agent
   const client = AgentClient();
-  const res = await client.queryIo(natsIO, 'triageAgent', new Message({
+  const res = await client.queryIo(natsIO, 'customerSupport.triageAgent', new Message({
     content: customerQuery,
     session: {
       id: caseId,
@@ -363,7 +363,7 @@ async function main() {
   
   // For demonstration purposes, let's simulate a complete flow through the technical agent
   console.log("\nRouting to Technical Agent...");
-  const res2 = await client.queryIo(natsIO, 'technicalAgent', new Message({
+  const res2 = await client.queryIo(natsIO, 'customerSupport.technicalAgent', new Message({
     content: customerQuery,
     session: {
         id: caseId,
@@ -388,7 +388,7 @@ async function main() {
   
   // Now follow up with the customer
   console.log("\nFollowing up with customer after resolution...");
-  const res3 = await client.queryIo(natsIO, 'followupAgent', new Message({
+  const res3 = await client.queryIo(natsIO, 'customerSupport.followupAgent', new Message({
     content: `Please follow up on case ${caseId}`,
       session: {
         id: caseId

package/examples/event-planner/agents.yaml

@@ -1,5 +1,5 @@
 ---
-apiVersion: smartagent.io/v1alpha1
+apiVersion: agentnet/v1alpha1
 kind: AgentDefinition
 metadata:
   name: plannerAgent
@@ -168,7 +168,7 @@ spec:
           - request
 
 ---
-apiVersion: smartagent.io/v1alpha1
+apiVersion: agentnet/v1alpha1
 kind: AgentDefinition
 metadata:
   name: eventFinderAgent

package/examples/event-planner/index.js

@@ -479,7 +479,7 @@ async function main() {
   const createRequest = "I need to schedule a design review meeting next Monday at 2pm for 1 hour with the design team. Today is 11th May 2025.";
   
   console.log(`User request: "${createRequest}"`);
-  const createResponse = await client.queryIo(natsIO, 'plannerAgent', new Message({
+  const createResponse = await client.queryIo(natsIO, 'eventPlanner.plannerAgent', new Message({
     content: createRequest,
     session: {
       id: uuidv4(),
@@ -495,7 +495,7 @@ async function main() {
   const searchRequest = "Show me all meetings with Bob next month. Today is october 2023.";
   
   console.log(`User request: "${searchRequest}"`);
-  const searchResponse = await client.queryIo(natsIO, 'eventFinderAgent', new Message({
+  const searchResponse = await client.queryIo(natsIO, 'eventPlanner.eventFinderAgent', new Message({
     content: searchRequest,
     session: {
       id: uuidv4(),
@@ -511,7 +511,7 @@ async function main() {
   const updateRequest = "Change the Weekly Team Meeting to start at 9:30am instead of 10am.";
   
   console.log(`User request: "${updateRequest}"`);
-  const updateResponse = await client.queryIo(natsIO, 'plannerAgent', new Message({
+  const updateResponse = await client.queryIo(natsIO, 'eventPlanner.plannerAgent', new Message({
     content: updateRequest,
     session: {
       id: uuidv4(),
@@ -527,7 +527,7 @@ async function main() {
   const conflictRequest = "Do I have any scheduling conflicts next week?";
   
   console.log(`User request: "${conflictRequest}"`);
-  const conflictResponse = await client.queryIo(natsIO, 'eventFinderAgent', new Message({
+  const conflictResponse = await client.queryIo(natsIO, 'eventPlanner.eventFinderAgent', new Message({
     content: conflictRequest,
     session: {
       id: uuidv4(),

package/examples/smartness/index.js

@@ -1,3 +1,4 @@
+import { v4 as uuidv4 } from 'uuid';
 import { AgentLoaderFile, AgentClient, NatsIO, Bindings, Message, PostgresStore, RedisStore, MemoryStore } from "../../src/index.js"
 
 // NatsIO instance
@@ -53,23 +54,24 @@ await agentPricing.compile()
 await new Promise(resolve => setTimeout(resolve, 2000))
 
 // Agent client
+const sessionId = 'f3f4dfe9-3ca2-4e10-956f-e8d19ece5592' //uuidv4()
 const agentClient = AgentClient()   
 const message = new Message({
     content: "What rooms do you have from 2025-05-25 to 2025-05-30 for 3 guests For the hotel Flora? Give me the review of the hotel Flora",
     session: {
-        id: "67a71e42-a7d8-1db2-ad17-64e1c8546b20"
+        id: sessionId
     }
 })
-const res = await agentClient.queryIo(io, 'entrypoint', message)
+const res = await agentClient.queryIo(io, 'smartexample.entrypoint', message)
 console.log("=======\n", res.getContent())
 console.log("=======\n", res.getSession())
 
 const message2 = new Message({
     content: "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",
     session: {
-        id: "67a71e42-a7d8-1db2-ad17-64e1c8546b20"
+        id: sessionId
     }
 })
-const res2 = await agentClient.queryIo(io, 'entrypoint', message2)
+const res2 = await agentClient.queryIo(io, 'smartexample.entrypoint', message2)
 console.log("=======\n", res2.getContent())
 console.log("=======\n", res2.getSession())

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentnet",
-  "version": "0.0.7",
+  "version": "0.1.0",
   "type": "module",
   "description": "Agent library used by Smartness",
   "main": "src/index.js",

package/src/agent/runtime.js

@@ -67,7 +67,8 @@ export async function AgentRuntime(agentConfig) {
             const content = message.getContent()
             const session = message.getSession()
             const sessionId = message.getSessionId()
-            const storeStateSessionId = agentName + "." + sessionId
+            const storeStateSessionId = namespace + "." + agentName + "." + sessionId
+            console.log("---->", storeStateSessionId)
 
             // Load and merge session state and session data
             let storeState = {

package/src/transport/nats.js

@@ -256,25 +256,24 @@ export class NatsTransport extends Transport {
                                                         content: input
                                                     });
                                                     const req = await this.request(
-                                                        discoveryMessage.agentName, 
+                                                        network, 
                                                         message.serialize(), 
                                                         { timeout: TIMEOUT_TASK_REQUEST }
                                                     );
                                                     return req.string();
                                                 } catch (error) {
                                                     throw new HandoffError(
-                                                        `Handoff to agent ${discoveryMessage.agentName} failed: ${error.message}`,
-                                                        agentName,
-                                                        discoveryMessage.agentName,
+                                                        `Handoff to agent ${network} failed: ${error.message}`,
+                                                        network,
                                                         { schemaName: schema.name }
                                                     );
                                                 }
                                             },
                                             TIMEOUT_TASK_REQUEST,
-                                            `handoff to ${discoveryMessage.agentName}`
+                                            `handoff to ${network}`
                                         );
                                     } catch (error) {
-                                        logger.error(`Handoff error to ${discoveryMessage.agentName}`, {
+                                        logger.error(`Handoff error to ${network}`, {
                                             error,
                                             schema: schema.name
                                         });
@@ -319,17 +318,18 @@ export class NatsTransport extends Transport {
      * @param {Function} processingFunction - The function to process requests
      * @returns {Promise<void>}
      */
-    async setupTaskHandler(agentName, processingFunction) {
+    async setupTaskHandler(namespace, agentName, processingFunction) {
         let taskSub;
         
         try {
-            taskSub = await this.subscribe(agentName, { queue: agentName });
+            const topic = `${namespace}.${agentName}`;
+            taskSub = await this.subscribe(topic, { queue: topic });
             logger.info(`Agent ${agentName} subscribed for task handling`);
         } catch (error) {
             throw new TransportError(
                 `Failed to subscribe for task handling: ${error.message}`,
                 this.transportType,
-                { agentName }
+                { agentName, topic }
             );
         }
         
@@ -395,7 +395,7 @@ export class NatsTransport extends Transport {
             if (this.connected) {
                 logger.info('Attempting to resubscribe for task handling');
                 try {
-                    await this.setupTaskHandler(agentName, processingFunction);
+                    await this.setupTaskHandler(namespace, agentName, processingFunction);
                 } catch (resubError) {
                     logger.error('Failed to resubscribe for task handling', { error: resubError });
                     throw new TransportError(
@@ -450,7 +450,7 @@ export class NatsTransport extends Transport {
                 if (typeof fn !== 'function') {
                     throw new Error('Task handler must be a function');
                 }
-                await this.setupTaskHandler(agentName, fn);
+                await this.setupTaskHandler(namespace, agentName, fn);
             };
 
             return { handleTask, discoveredAgents };

package/_OLD_README.md

@@ -1,554 +0,0 @@
-# Agentnet
-
-Agentnet is a flexible, extensible library for building and orchestrating LLM-powered agents that can communicate, collaborate, and leverage tools to solve complex tasks. It is specifically designed to develop autonomous networks of agents that can work together to accomplish sophisticated objectives with minimal human intervention.
-
-## Table of Contents
-
-- [Declarative Agent Definitions](#declarative-agent-definitions)
-  - [Static Definitions (YAML)](#static-definitions-yaml)
-  - [Dynamic Implementation (JavaScript)](#dynamic-implementation-javascript)
-  - [Multi-Agent Systems with YAML](#multi-agent-systems-with-yaml)
-- [Key Features](#key-features)
-- [Quick Start](#quick-start)
-- [Core Concepts](#core-concepts)
-  - [Agents](#agents)
-  - [Agent Configuration](#agent-configuration)
-  - [Tool Binding](#tool-binding)
-  - [Transport Mechanisms](#transport-mechanisms)
-  - [Agent Auto-Discovery](#agent-auto-discovery)
-  - [Agent Handoffs](#agent-handoffs)
-- [Advanced Usage](#advanced-usage)
-  - [Events and Hooks](#events-and-hooks)
-  - [Multi-Agent Systems](#multi-agent-systems)
-  - [Session State Management](#session-state-management)
-- [Installation](#installation)
-- [License](#license)
-
-## Declarative Agent Definitions
-
-A key feature of Agentnet is the ability to define agents declaratively using YAML files, separating the static definition of agents from their dynamic runtime behavior:
-
-### Static Definitions (YAML)
-
-Agents can be defined in YAML files that specify:
-- Metadata (name, description)
-- LLM configuration (provider, model, system instructions)
-- Transport mechanisms (NATS, etc.)
-- Tool schemas (name, description, parameters)
-- Discovery schemas for inter-agent communication
-
-Example YAML definition:
-
-```yaml
----
-apiVersion: agentnet.io/v1alpha1
-kind: AgentDefinition
-metadata:
-  name: bookingAgent
-  namespace: smartchat
-spec:
-  io:
-    - type: NatsIO
-      bindings:
-        discoveryTopic: smartness.discovery
-        acceptedNetworks: 
-          - "smartchat.*"
-
-  llm:
-    provider: Gemini
-    model: gemini-2.0-flash
-    systemInstruction: |
-      You are a highly advanced booking agent. 
-      Prioritize clarity and helpfulness.
-      Use tools effectively to gather information.
-    config:
-      temperature: 0.5
-      toolConfig:
-        functionCallingConfig:
-          mode: 'auto'
-
-  tools:
-    - name: bookRoomTool
-      description: Book a room to a specific hotel and room.
-      parameters:
-        type: object
-        properties:
-          hotelName:
-            type: string
-            description: The name of the hotel.
-          roomName:
-            type: string
-            description: The name of the room.
-          checkinDate:
-            type: string
-            description: The check-in date.
-          checkoutDate:
-            type: string
-            description: The check-out date.
-        required:
-          - hotelName
-          - roomName
-
-  discoverySchemas:
-    - name: booking_agent_query
-      description: Perform a booking to a specific hotel and room.
-      parameters:
-        type: object
-        properties:
-          hotelName:
-            type: string
-            description: The name of the hotel.
-          roomName:
-            type: string
-            description: The name of the room.
-```
-
-You can define multiple agents in a single YAML file using YAML document separators (`---`). Each agent can have its own specialized role in a multi-agent system.
-
-### Dynamic Implementation (JavaScript)
-
-The YAML definitions are loaded at runtime, and tool implementations are dynamically bound using JavaScript:
-
-```javascript
-// Load all agents from a YAML file
-const agents = await AgentLoaderFile('./agents.yaml', {
-  bindings: { [Bindings.NatsIO]: natsInstance }
-});
-
-// Access a specific agent
-const bookingAgent = agents.bookingAgent;
-const pricingAgent = agents.pricingAgent;
-
-// Bind tool implementations
-bookingAgent.tools.bookRoomTool.bind(async (state, input) => {
-  // Actual implementation to book a room
-  return { 
-    confirmation: `Room ${input.roomName} booked at ${input.hotelName} 
-                  from ${input.checkinDate} to ${input.checkoutDate}` 
-  };
-});
-
-// Customize prompt/response handling
-bookingAgent.prompt((state, input) => {
-  // Pre-process input before sending to LLM
-  console.log(`Received booking request: ${input}`);
-  return input;
-});
-
-bookingAgent.response((state, conversation, result) => {
-  // Post-process response from LLM
-  return `Booking confirmation: ${result}`;
-});
-
-// Compile all agents to make them ready for use
-await bookingAgent.compile();
-await pricingAgent.compile();
-```
-
-This separation of concerns allows for:
-- Version-controlled agent definitions
-- Reusable tool schemas
-- Dynamic runtime implementation
-- Easy testing and deployment
-- Clear separation between definition and implementation
-
-### Multi-Agent Systems with YAML
-
-The framework excels at creating autonomous multi-agent systems where specialized agents collaborate with minimal supervision. Each agent in the network can operate independently while maintaining awareness of other agents' capabilities. This creates a resilient, self-organizing system that can tackle complex tasks through agent collaboration. An example setup might include:
-
-```javascript
-// Load a set of specialized agents from YAML
-const agents = await AgentLoaderFile('./agents-smartness.yaml', {
-  bindings: { [Bindings.NatsIO]: natsIO }
-});
-
-// Configure each agent with specific tool implementations
-agents.accomodation.tools.getRoomsListTool.bind(async (state, input) => {
-  // Implementation for listing available rooms
-  return { rooms: ["Double room with sea view", "Single room with pool view"] };
-});
-
-agents.pricing.tools.getPricingTool.bind(async (state, input) => {
-  // Implementation for getting room prices
-  return { price: "200€ per night" };
-});
-
-agents.booking.tools.bookRoomTool.bind(async (state, input) => {
-  // Implementation for booking rooms
-  return { confirmation: "Booking confirmed" };
-});
-
-// Compile all agents
-await Promise.all(Object.values(agents).map(agent => agent.compile()));
-
-// Wait for agent discovery to complete
-await new Promise(resolve => setTimeout(resolve, 2000));
-
-// Query the main orchestrator agent
-const client = AgentClient();
-const response = await client.queryIo(
-  natsIO,
-  'entrypoint', 
-  "What rooms do you have available for next weekend and how much do they cost?"
-);
-```
-
-With this setup, the smartness agent will automatically discover and delegate to specialized agents for accommodation, pricing, and booking, creating an autonomous network that collectively solves the user's query.
-
-## Key Features
-
-- **Autonomous Agent Networks**: Create self-organizing networks of agents that can discover, communicate, and collaborate with minimal human intervention
-- **Modular Agent Architecture**: Create specialized agents with distinct capabilities and compose them to solve complex problems
-- **Transport Agnostic**: Work with agents directly or through transport mechanisms like NATS
-- **Auto-Discovery**: Agents can discover each other's capabilities dynamically at runtime
-- **Tool Binding**: Easily bind JavaScript functions to agent tools
-- **Agent Handoffs**: Seamlessly delegate tasks between agents
-- **LLM Provider Agnostic**: Support for multiple LLM providers (Gemini and extensible to others)
-- **Persistent Sessions**: Maintain conversation context and state across interactions
-
-## Quick Start
-
-```javascript
-import { Agent, Gemini, NatsIO } from "agentnet";
-
-// Create a simple agent
-const myAgent = Agent()
-  .setMetadata({
-    name: "myAgent",
-    description: "A helpful assistant"
-  })
-  .withLLM(Gemini, {
-    model: "gemini-pro",
-    systemInstruction: "You are a helpful assistant"
-  })
-  .addToolSchema({
-    name: "weatherTool",
-    description: "Get weather information",
-    parameters: {
-      location: "string"
-    }
-  });
-
-// Bind tool implementation
-const compiledAgent = await myAgent.compile();
-compiledAgent.tools.weatherTool.bind(async (state, input) => {
-  return { weather: "Sunny", temperature: 25 };
-});
-
-// Query the agent
-const response = await compiledAgent.query("What's the weather like in Paris?");
-console.log(response);
-```
-
-## Core Concepts
-
-### Agents
-
-Agents are the core building blocks of the framework. Each agent:
-
-- Has its own identity (name, description)
-- Can be configured with an LLM provider
-- Can define and implement tools
-- Can discover and communicate with other agents
-
-### Agent Configuration
-
-Agents can be configured programmatically or via YAML definitions:
-
-```javascript
-// Programmatic configuration
-const myAgent = Agent()
-  .setMetadata({ name: "myAgent" })
-  .withLLM(Gemini, { model: "gemini-pro" })
-  .addToolSchema(myToolSchema);
-
-// YAML-based configuration
-const agents = await AgentLoaderFile('./agents.yaml', {
-  bindings: { [Bindings.NatsIO]: natsInstance }
-});
-```
-
-### Tool Binding
-
-Tools allow agents to perform actions in the real world. Each tool:
-
-- Has a schema that defines its interface (name, description, parameters)
-- Has an implementation bound to it at runtime
-
-```javascript
-// Define tool schema
-agent.addToolSchema({
-  name: "fetchData",
-  description: "Fetch data from an API",
-  parameters: {
-    url: "string",
-    method: "string"
-  }
-});
-
-// Bind implementation
-agent.tools.fetchData.bind(async (state, input) => {
-  // Actual implementation
-  const response = await fetch(input.url, { method: input.method });
-  return await response.json();
-});
-```
-
-### Transport Mechanisms
-
-The framework supports different transport mechanisms for agent communication:
-
-#### Direct Communication
-
-Agents can be queried directly in the same process:
-
-```javascript
-const compiledAgent = await myAgent.compile();
-const response = await compiledAgent.query("Hello, agent!");
-```
-
-#### NATS-based Communication
-
-Agents can communicate through NATS for distributed deployments:
-
-```javascript
-// Initialize NATS transport
-const natsIO = NatsIO({ servers: ['nats://localhost:4222'] });
-
-// Configure agent with NATS transport
-const myAgent = Agent()
-  .setMetadata({ name: "distributedAgent" })
-  .addIO(natsIO, { 
-    bindings: { 
-      discoveryTopic: "smartness.discovery",
-      acceptedNetworks: ["smartchat.*"]
-    }
-  })
-  .withLLM(Gemini, { model: "gemini-pro" });
-
-// Query an agent through NATS
-const client = AgentClient();
-const response = await client.queryIo(natsIO, 'distributedAgent', "Hello!");
-```
-
-### Agent Auto-Discovery
-
-Agents can discover each other's capabilities at runtime through a discovery protocol:
-
-1. Agents publish their capabilities (available tools and schemas) to a discovery topic
-2. Other agents subscribe to the discovery topic and build a catalog of available agents
-3. Agents can then delegate tasks to the most appropriate agent
-
-```javascript
-// Auto-discovery happens automatically when agents share the same transport
-// Just wait for discovery to complete
-await new Promise(resolve => setTimeout(resolve, 2000));
-
-// Now agents can communicate with each other
-```
-
-### Network Filtering
-
-The framework provides a powerful network filtering mechanism that allows agents to control which other agents they communicate with. This is configured through the `acceptedNetworks` property:
-
-```javascript
-// Configure agent with network filtering
-const myAgent = Agent()
-  .setMetadata({ name: "filteredAgent" })
-  .addIO(natsIO, { 
-    network: "smartchat",
-    bindings: { 
-      discoveryTopic: "smartness.discovery",
-      acceptedNetworks: ["smartchat.*", "finance.pricing"]
-    }
-  })
-  .withLLM(Gemini, { model: "gemini-pro" });
-```
-
-#### Wildcard Patterns
-
-Network filtering supports various wildcard patterns:
-
-1. **Full wildcard** (`*.*`): Accept all networks regardless of namespace or name
-2. **Namespace wildcard** (`*.serviceName`): Accept any network with the specified service name, regardless of namespace
-3. **Service wildcard** (`namespace.*`): Accept any service within the specified namespace
-
-For example:
-
-```yaml
-io:
-  - type: NatsIO
-    network: smartchat
-    bindings:
-      discoveryTopic: smartness.discovery
-      acceptedNetworks: 
-        - "smartchat.*"     # Accept all services in smartchat namespace
-        - "finance.pricing" # Accept only the pricing service in finance namespace
-        - "*.analytics"     # Accept analytics services from any namespace
-```
-
-This filtering system allows for fine-grained control over agent communication, enhancing security and improving the efficiency of the agent network. Agents will only process discovery messages from networks that match their acceptance patterns.
-
-### Agent Handoffs
-
-Agents can delegate tasks to other agents with the right capabilities:
-
-1. An agent receives a task it can't handle directly
-2. It identifies another agent with the required capability
-3. It hands off the task to that agent
-4. The specialized agent processes the task and returns the result
-
-This happens transparently from the user's perspective, creating a seamless experience.
-
-## Advanced Usage
-
-### Events and Hooks
-
-Customize agent behavior with event hooks:
-
-```javascript
-agent.prompt((state, input) => {
-  // Customize input before it reaches the LLM
-  return `[Processed] ${input}`;
-});
-
-agent.response((state, conversation, result) => {
-  // Process the result before returning to the user
-  return `Agent says: ${result}`;
-});
-```
-
-### Multi-Agent Systems
-
-Create autonomous networks of specialized agents that collaborate without human intervention:
-
-```javascript
-// Create specialized agents
-const weatherAgent = Agent()
-  .setMetadata({ name: "weatherAgent" })
-  .addIO(NatsIO({ servers: ['nats://localhost:4222'] }), {
-    network: "smartchat",
-    bindings: { 
-      discoveryTopic: "smartness.discovery"
-    }
-  })
-  .addToolSchema(weatherToolSchema);
-
-const travelAgent = Agent()
-  .setMetadata({ name: "travelAgent" })
-  .addIO(NatsIO({ servers: ['nats://localhost:4222'] }), {
-    network: "smartchat",
-    bindings: { 
-      discoveryTopic: "smartness.discovery"
-    }
-  })
-  .addToolSchema(travelToolSchema);
-
-// The main agent that orchestrates others
-const smartAgent = Agent()
-  .setMetadata({ name: "smartAgent" })
-  .addIO(NatsIO({ servers: ['nats://localhost:4222'] }), {
-    network: "smartchat",
-    bindings: { 
-      discoveryTopic: "smartness.discovery",
-      acceptedNetworks: ["smartchat.*"]
-    }
-  })
-  .addDiscoverySchema(weatherDiscoverySchema)
-  .addDiscoverySchema(travelDiscoverySchema);
-
-// Compile and connect all agents
-await weatherAgent.compile();
-await travelAgent.compile();
-await smartAgent.compile();
-
-// Query through the main agent
-const response = await smartAgent.query(
-  "Plan a trip to Paris and tell me about the weather"
-);
-```
-
-In this autonomous network:
-- Each agent is responsible for a specific domain of expertise
-- The orchestrator agent (smartAgent) discovers and routes requests to appropriate specialists
-- The network can scale by adding more specialized agents without changing existing ones
-- Agents can be deployed across different environments while maintaining communication
-
-### Session State Management
-
-The Agentnet framework provides robust session management for maintaining state across conversations and agent interactions:
-
-```javascript
-// Creating a message with session information
-const message = new Message({
-  content: "What rooms do you have available?",
-  session: {
-    id: "67a71e42-a7d8-1db2-ad17-64e1c8546b21",  // Reserved system ID
-    propertySetId: "123",                         // Custom session data
-    userPreferences: { roomType: "suite" }        // Custom session data
-  }
-});
-
-// Query the agent with session context
-const result = await agentInstance.query(message);
-```
-
-#### Session ID
-
-The `id` keyword in the session object is reserved for the system. It's used to uniquely identify the session for:
-- Loading session state from persistent storage
-- Saving session state back to storage
-- Tracking conversation history
-
-#### State Propagation
-
-Session variables have different scopes:
-
-1. **Regular variables** (without underscore prefix) are propagated between agents during handoffs, ensuring continuity of context across the agent system.
-
-2. **Private variables** (with underscore prefix `_`) are agent-specific and not shared during handoffs. For example:
-   ```javascript
-   message.session._agentPrivateData = "This stays with the current agent";
-   message.session.sharedData = "This is passed between agents";
-   ```
-
-When a session is saved to storage, private variables (starting with `_`) are saved on the agent store, but removed from response to the calling agent to keep the session data clean and focused on shareable information.
-
-#### Stores Configuration
-
-Agentnet supports different storage backends for persisting session state:
-
-```javascript
-// Configure the agent with a Postgres store
-const agents = await AgentLoaderJSON(agentDefinition, {
-  bindings: {
-    [Bindings.Postgres]: PostgresStore({
-      url: "postgres://postgres:postgres@localhost:5432/postgres"
-    })
-  }
-});
-
-// Or with an in-memory store for testing
-const agents = await AgentLoaderJSON(agentDefinition, {
-  bindings: {
-    [Bindings.Memory]: MemoryStore()
-  }
-});
-```
-
-#### Session Life Cycle
-
-1. When an agent receives a query with a session ID, it attempts to load the existing session state
-2. The state is merged with any new session data provided in the query
-3. The agent processes the query with access to this state
-4. Before responding, the updated state is saved back to storage
-5. Private variables (with `_` prefix) are removed from the response
-
-This mechanism allows agents to maintain context across multiple interactions while keeping appropriate boundaries between agent-specific and shared data.
-
-## Installation
-
-```bash
-npm install agentnet
-```
-