@tjamescouch/agentchat 0.8.0 → 0.10.0

package/bin/agentchat.js

@@ -679,14 +679,22 @@ program
       console.log(`  Instance: ${instanceName}`);
       console.log(`  Server: ${server}`);
       console.log(`  Identity: ${options.identity}`);
-      console.log(`  Channels: ${options.channels.join(', ')}`);
+
+      // Normalize channels: handle both comma-separated and space-separated formats
+      const normalizedChannels = options.channels
+        .flatMap(c => c.split(','))
+        .map(c => c.trim())
+        .filter(c => c.length > 0)
+        .map(c => c.startsWith('#') ? c : '#' + c);
+
+      console.log(`  Channels: ${normalizedChannels.join(', ')}`);
       console.log('');
 
       const daemon = new AgentChatDaemon({
         server,
         name: instanceName,
         identity: options.identity,
-        channels: options.channels,
+        channels: normalizedChannels,
         maxReconnectTime: parseInt(options.maxReconnectTime) * 60 * 1000 // Convert minutes to ms
       });
 
@@ -944,6 +952,155 @@ program
     }
   });
 
+// Skills command - skill discovery and announcement
+program
+  .command('skills <action> [server]')
+  .description('Manage skill discovery: announce, search, list')
+  .option('-c, --capability <capability>', 'Skill capability for announce/search')
+  .option('-r, --rate <rate>', 'Rate/price for the skill', parseFloat)
+  .option('--currency <currency>', 'Currency for rate (e.g., SOL, TEST)', 'TEST')
+  .option('--description <desc>', 'Description of skill')
+  .option('-f, --file <file>', 'YAML file with skill definitions')
+  .option('-i, --identity <file>', 'Path to identity file', DEFAULT_IDENTITY_PATH)
+  .option('--max-rate <rate>', 'Maximum rate for search', parseFloat)
+  .option('-l, --limit <n>', 'Limit search results', parseInt)
+  .option('--json', 'Output as JSON')
+  .action(async (action, server, options) => {
+    try {
+      if (action === 'announce') {
+        if (!server) {
+          console.error('Server URL required: agentchat skills announce <server>');
+          process.exit(1);
+        }
+
+        let skills = [];
+
+        // Load from file if provided
+        if (options.file) {
+          const yaml = await import('js-yaml');
+          const content = await fsp.readFile(options.file, 'utf-8');
+          const data = yaml.default.load(content);
+          skills = data.skills || [data];
+        } else if (options.capability) {
+          // Single skill from CLI args
+          skills = [{
+            capability: options.capability,
+            rate: options.rate,
+            currency: options.currency,
+            description: options.description
+          }];
+        } else {
+          console.error('Either --file or --capability required');
+          process.exit(1);
+        }
+
+        // Load identity and sign
+        const identity = await Identity.load(options.identity);
+        const skillsContent = JSON.stringify(skills);
+        const sig = identity.sign(skillsContent);
+
+        // Connect and announce
+        const client = new AgentChatClient({ server, identity: options.identity });
+        await client.connect();
+
+        await client.sendRaw({
+          type: 'REGISTER_SKILLS',
+          skills,
+          sig: sig.toString('base64')
+        });
+
+        // Wait for response
+        const response = await new Promise((resolve, reject) => {
+          const timeout = setTimeout(() => reject(new Error('Timeout')), 5000);
+          client.on('message', (msg) => {
+            if (msg.type === 'SKILLS_REGISTERED' || msg.type === 'ERROR') {
+              clearTimeout(timeout);
+              resolve(msg);
+            }
+          });
+        });
+
+        client.disconnect();
+
+        if (response.type === 'ERROR') {
+          console.error('Error:', response.message);
+          process.exit(1);
+        }
+
+        console.log(`Registered ${response.skills_count} skill(s) for ${response.agent_id}`);
+
+      } else if (action === 'search') {
+        if (!server) {
+          console.error('Server URL required: agentchat skills search <server>');
+          process.exit(1);
+        }
+
+        const query = {};
+        if (options.capability) query.capability = options.capability;
+        if (options.maxRate !== undefined) query.max_rate = options.maxRate;
+        if (options.currency) query.currency = options.currency;
+        if (options.limit) query.limit = options.limit;
+
+        // Connect and search
+        const client = new AgentChatClient({ server });
+        await client.connect();
+
+        const queryId = `q_${Date.now()}`;
+        await client.sendRaw({
+          type: 'SEARCH_SKILLS',
+          query,
+          query_id: queryId
+        });
+
+        // Wait for response
+        const response = await new Promise((resolve, reject) => {
+          const timeout = setTimeout(() => reject(new Error('Timeout')), 5000);
+          client.on('message', (msg) => {
+            if (msg.type === 'SEARCH_RESULTS' || msg.type === 'ERROR') {
+              clearTimeout(timeout);
+              resolve(msg);
+            }
+          });
+        });
+
+        client.disconnect();
+
+        if (response.type === 'ERROR') {
+          console.error('Error:', response.message);
+          process.exit(1);
+        }
+
+        if (options.json) {
+          console.log(JSON.stringify(response.results, null, 2));
+        } else {
+          console.log(`Found ${response.results.length} skill(s) (${response.total} total):\n`);
+          for (const skill of response.results) {
+            const rate = skill.rate !== undefined ? `${skill.rate} ${skill.currency || ''}` : 'negotiable';
+            console.log(`  ${skill.agent_id}`);
+            console.log(`    Capability: ${skill.capability}`);
+            console.log(`    Rate: ${rate}`);
+            if (skill.description) console.log(`    Description: ${skill.description}`);
+            console.log('');
+          }
+        }
+
+      } else if (action === 'list') {
+        // List own registered skills (if server supports it)
+        console.error('List action not yet implemented');
+        process.exit(1);
+
+      } else {
+        console.error(`Unknown action: ${action}`);
+        console.error('Valid actions: announce, search, list');
+        process.exit(1);
+      }
+
+    } catch (err) {
+      console.error('Error:', err.message);
+      process.exit(1);
+    }
+  });
+
 // Deploy command
 program
   .command('deploy')

package/lib/client.js

@@ -534,7 +534,14 @@ export class AgentChatClient extends EventEmitter {
       this.ws.send(serialize(msg));
     }
   }
-  
+
+  /**
+   * Send a raw message (for protocol extensions)
+   */
+  sendRaw(msg) {
+    this._send(msg);
+  }
+
   _handleMessage(data) {
     let msg;
     try {
@@ -609,6 +616,17 @@ export class AgentChatClient extends EventEmitter {
       case ServerMessageType.DISPUTE:
         this.emit('dispute', msg);
         break;
+
+      // Skills discovery messages
+      case ServerMessageType.SKILLS_REGISTERED:
+        this.emit('skills_registered', msg);
+        this.emit('message', msg);
+        break;
+
+      case ServerMessageType.SEARCH_RESULTS:
+        this.emit('search_results', msg);
+        this.emit('message', msg);
+        break;
     }
   }
 }

package/lib/protocol.js

@@ -21,7 +21,10 @@ export const ClientMessageType = {
   ACCEPT: 'ACCEPT',
   REJECT: 'REJECT',
   COMPLETE: 'COMPLETE',
-  DISPUTE: 'DISPUTE'
+  DISPUTE: 'DISPUTE',
+  // Skill discovery message types
+  REGISTER_SKILLS: 'REGISTER_SKILLS',
+  SEARCH_SKILLS: 'SEARCH_SKILLS'
 };
 
 // Server -> Client message types
@@ -41,7 +44,10 @@ export const ServerMessageType = {
   ACCEPT: 'ACCEPT',
   REJECT: 'REJECT',
   COMPLETE: 'COMPLETE',
-  DISPUTE: 'DISPUTE'
+  DISPUTE: 'DISPUTE',
+  // Skill discovery message types
+  SKILLS_REGISTERED: 'SKILLS_REGISTERED',
+  SEARCH_RESULTS: 'SEARCH_RESULTS'
 };
 
 // Error codes
@@ -284,6 +290,33 @@ export function validateClientMessage(raw) {
       }
       break;
 
+    case ClientMessageType.REGISTER_SKILLS:
+      // Register skills requires: skills array and signature
+      if (!msg.skills || !Array.isArray(msg.skills)) {
+        return { valid: false, error: 'Missing or invalid skills array' };
+      }
+      if (msg.skills.length === 0) {
+        return { valid: false, error: 'Skills array cannot be empty' };
+      }
+      // Validate each skill has at least a capability
+      for (const skill of msg.skills) {
+        if (!skill.capability || typeof skill.capability !== 'string') {
+          return { valid: false, error: 'Each skill must have a capability string' };
+        }
+      }
+      if (!msg.sig) {
+        return { valid: false, error: 'Skill registration must be signed' };
+      }
+      break;
+
+    case ClientMessageType.SEARCH_SKILLS:
+      // Search skills requires: query object
+      if (!msg.query || typeof msg.query !== 'object') {
+        return { valid: false, error: 'Missing or invalid query object' };
+      }
+      // query_id is optional but useful for tracking responses
+      break;
+
     default:
       return { valid: false, error: `Unknown message type: ${msg.type}` };
   }

package/lib/server.js

@@ -23,6 +23,7 @@ import {
   isProposalMessage
 } from './protocol.js';
 import { ProposalStore, formatProposal, formatProposalResponse } from './proposals.js';
+import { ReputationStore } from './reputation.js';
 
 export class AgentChatServer {
   constructor(options = {}) {
@@ -67,10 +68,17 @@ export class AgentChatServer {
     // Create default channels
     this._createChannel('#general', false);
     this._createChannel('#agents', false);
+    this._createChannel('#discovery', false);  // For skill announcements
 
     // Proposal store for structured negotiations
     this.proposals = new ProposalStore();
 
+    // Skills registry: agentId -> { skills: [], registered_at, sig }
+    this.skillsRegistry = new Map();
+
+    // Reputation store for ELO ratings
+    this.reputationStore = new ReputationStore();
+
     this.wss = null;
     this.httpServer = null;  // For TLS mode
   }
@@ -315,6 +323,13 @@ export class AgentChatServer {
       case ClientMessageType.DISPUTE:
         this._handleDispute(ws, msg);
         break;
+      // Skill discovery messages
+      case ClientMessageType.REGISTER_SKILLS:
+        this._handleRegisterSkills(ws, msg);
+        break;
+      case ClientMessageType.SEARCH_SKILLS:
+        this._handleSearchSkills(ws, msg);
+        break;
     }
   }
   
@@ -769,7 +784,7 @@ export class AgentChatServer {
     this._send(ws, outMsg);
   }
 
-  _handleComplete(ws, msg) {
+  async _handleComplete(ws, msg) {
     const agent = this.agents.get(ws);
     if (!agent) {
       this._send(ws, createError(ErrorCode.AUTH_REQUIRED, 'Must IDENTIFY first'));
@@ -796,9 +811,27 @@ export class AgentChatServer {
     const proposal = result.proposal;
     this._log('complete', { id: proposal.id, by: agent.id });
 
+    // Update reputation ratings
+    let ratingChanges = null;
+    try {
+      ratingChanges = await this.reputationStore.processCompletion({
+        type: 'COMPLETE',
+        from: proposal.from,
+        to: proposal.to,
+        amount: proposal.amount
+      });
+      this._log('reputation_updated', {
+        proposal_id: proposal.id,
+        changes: ratingChanges
+      });
+    } catch (err) {
+      this._log('reputation_error', { error: err.message });
+    }
+
     // Notify both parties
     const outMsg = createMessage(ServerMessageType.COMPLETE, {
-      ...formatProposalResponse(proposal, 'complete')
+      ...formatProposalResponse(proposal, 'complete'),
+      rating_changes: ratingChanges
     });
 
     // Notify the other party
@@ -812,7 +845,7 @@ export class AgentChatServer {
     this._send(ws, outMsg);
   }
 
-  _handleDispute(ws, msg) {
+  async _handleDispute(ws, msg) {
     const agent = this.agents.get(ws);
     if (!agent) {
       this._send(ws, createError(ErrorCode.AUTH_REQUIRED, 'Must IDENTIFY first'));
@@ -839,9 +872,28 @@ export class AgentChatServer {
     const proposal = result.proposal;
     this._log('dispute', { id: proposal.id, by: agent.id, reason: msg.reason });
 
+    // Update reputation ratings
+    let ratingChanges = null;
+    try {
+      ratingChanges = await this.reputationStore.processDispute({
+        type: 'DISPUTE',
+        from: proposal.from,
+        to: proposal.to,
+        amount: proposal.amount,
+        disputed_by: `@${agent.id}`
+      });
+      this._log('reputation_updated', {
+        proposal_id: proposal.id,
+        changes: ratingChanges
+      });
+    } catch (err) {
+      this._log('reputation_error', { error: err.message });
+    }
+
     // Notify both parties
     const outMsg = createMessage(ServerMessageType.DISPUTE, {
-      ...formatProposalResponse(proposal, 'dispute')
+      ...formatProposalResponse(proposal, 'dispute'),
+      rating_changes: ratingChanges
     });
 
     // Notify the other party
@@ -855,6 +907,130 @@ export class AgentChatServer {
     this._send(ws, outMsg);
   }
 
+  _handleRegisterSkills(ws, msg) {
+    const agent = this.agents.get(ws);
+    if (!agent) {
+      this._send(ws, createError(ErrorCode.AUTH_REQUIRED, 'Must IDENTIFY first'));
+      return;
+    }
+
+    if (!agent.pubkey) {
+      this._send(ws, createError(ErrorCode.SIGNATURE_REQUIRED, 'Skill registration requires persistent identity'));
+      return;
+    }
+
+    // Store skills for this agent
+    const registration = {
+      agent_id: `@${agent.id}`,
+      skills: msg.skills,
+      registered_at: Date.now(),
+      sig: msg.sig
+    };
+
+    this.skillsRegistry.set(agent.id, registration);
+
+    this._log('skills_registered', { agent: agent.id, count: msg.skills.length });
+
+    // Notify the registering agent
+    this._send(ws, createMessage(ServerMessageType.SKILLS_REGISTERED, {
+      agent_id: `@${agent.id}`,
+      skills_count: msg.skills.length,
+      registered_at: registration.registered_at
+    }));
+
+    // Optionally broadcast to #discovery channel if it exists
+    if (this.channels.has('#discovery')) {
+      this._broadcast('#discovery', createMessage(ServerMessageType.MSG, {
+        from: '@server',
+        to: '#discovery',
+        content: `Agent @${agent.id} registered ${msg.skills.length} skill(s): ${msg.skills.map(s => s.capability).join(', ')}`
+      }));
+    }
+  }
+
+  async _handleSearchSkills(ws, msg) {
+    const agent = this.agents.get(ws);
+    if (!agent) {
+      this._send(ws, createError(ErrorCode.AUTH_REQUIRED, 'Must IDENTIFY first'));
+      return;
+    }
+
+    const query = msg.query || {};
+    const results = [];
+
+    // Search through all registered skills
+    for (const [agentId, registration] of this.skillsRegistry) {
+      for (const skill of registration.skills) {
+        let matches = true;
+
+        // Filter by capability (substring match, case-insensitive)
+        if (query.capability) {
+          const cap = skill.capability.toLowerCase();
+          const search = query.capability.toLowerCase();
+          if (!cap.includes(search)) {
+            matches = false;
+          }
+        }
+
+        // Filter by max_rate
+        if (query.max_rate !== undefined && skill.rate !== undefined) {
+          if (skill.rate > query.max_rate) {
+            matches = false;
+          }
+        }
+
+        // Filter by currency
+        if (query.currency && skill.currency) {
+          if (skill.currency.toLowerCase() !== query.currency.toLowerCase()) {
+            matches = false;
+          }
+        }
+
+        if (matches) {
+          results.push({
+            agent_id: registration.agent_id,
+            ...skill,
+            registered_at: registration.registered_at
+          });
+        }
+      }
+    }
+
+    // Enrich results with reputation data
+    const uniqueAgentIds = [...new Set(results.map(r => r.agent_id))];
+    const ratingCache = new Map();
+    for (const agentId of uniqueAgentIds) {
+      const ratingInfo = await this.reputationStore.getRating(agentId);
+      ratingCache.set(agentId, ratingInfo);
+    }
+
+    // Add rating info to each result
+    for (const result of results) {
+      const ratingInfo = ratingCache.get(result.agent_id);
+      result.rating = ratingInfo.rating;
+      result.transactions = ratingInfo.transactions;
+    }
+
+    // Sort by rating (highest first), then by registration time
+    results.sort((a, b) => {
+      if (b.rating !== a.rating) return b.rating - a.rating;
+      return b.registered_at - a.registered_at;
+    });
+
+    // Limit results
+    const limit = query.limit || 50;
+    const limitedResults = results.slice(0, limit);
+
+    this._log('skills_search', { agent: agent.id, query, results_count: limitedResults.length });
+
+    this._send(ws, createMessage(ServerMessageType.SEARCH_RESULTS, {
+      query_id: msg.query_id || null,
+      query,
+      results: limitedResults,
+      total: results.length
+    }));
+  }
+
   _handleDisconnect(ws) {
     const agent = this.agents.get(ws);
     if (!agent) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tjamescouch/agentchat",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "Real-time IRC-like communication protocol for AI agents",
   "main": "lib/client.js",
   "files": [