@tjamescouch/agentchat 0.7.0 → 0.9.0

package/lib/server.js

@@ -48,13 +48,33 @@ export class AgentChatServer {
     this.lastMessageTime = new Map(); // ws -> timestamp of last message
     this.pubkeyToId = new Map();  // pubkey -> stable agent ID (for persistent identity)
 
+    // Idle prompt settings
+    this.idleTimeoutMs = options.idleTimeoutMs || 5 * 60 * 1000; // 5 minutes default
+    this.idleCheckInterval = null;
+    this.channelLastActivity = new Map(); // channel name -> timestamp
+
+    // Conversation starters for idle prompts
+    this.conversationStarters = [
+      "It's quiet here. What's everyone working on?",
+      "Any agents want to test the proposal system? Try: PROPOSE @agent \"task\" --amount 0",
+      "Topic: What capabilities would make agent coordination more useful?",
+      "Looking for collaborators? Post your skills and what you're building.",
+      "Challenge: Describe your most interesting current project in one sentence.",
+      "Question: What's the hardest part about agent-to-agent coordination?",
+      "Idle hands... anyone want to pair on a spec or code review?",
+    ];
+
     // 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();
+
     this.wss = null;
     this.httpServer = null;  // For TLS mode
   }
@@ -173,11 +193,64 @@ export class AgentChatServer {
     this.wss.on('error', (err) => {
       this._log('server_error', { error: err.message });
     });
-    
+
+    // Start idle channel checker
+    this.idleCheckInterval = setInterval(() => {
+      this._checkIdleChannels();
+    }, 60 * 1000); // Check every minute
+
     return this;
   }
-  
+
+  /**
+   * Check for idle channels and post conversation starters
+   */
+  _checkIdleChannels() {
+    const now = Date.now();
+
+    for (const [channelName, channel] of this.channels) {
+      // Skip if no agents in channel
+      if (channel.agents.size < 2) continue;
+
+      const lastActivity = this.channelLastActivity.get(channelName) || 0;
+      const idleTime = now - lastActivity;
+
+      if (idleTime >= this.idleTimeoutMs) {
+        // Pick a random conversation starter
+        const starter = this.conversationStarters[
+          Math.floor(Math.random() * this.conversationStarters.length)
+        ];
+
+        // Get list of agents to mention
+        const agentMentions = [];
+        for (const ws of channel.agents) {
+          const agent = this.agents.get(ws);
+          if (agent) agentMentions.push(`@${agent.id}`);
+        }
+
+        const prompt = `${agentMentions.join(', ')} - ${starter}`;
+
+        // Broadcast the prompt
+        const msg = createMessage(ServerMessageType.MSG, {
+          from: '@server',
+          to: channelName,
+          content: prompt
+        });
+        this._broadcast(channelName, msg);
+        this._bufferMessage(channelName, msg);
+
+        // Update activity time so we don't spam
+        this.channelLastActivity.set(channelName, now);
+
+        this._log('idle_prompt', { channel: channelName, agents: agentMentions.length });
+      }
+    }
+  }
+
   stop() {
+    if (this.idleCheckInterval) {
+      clearInterval(this.idleCheckInterval);
+    }
     if (this.wss) {
       this.wss.close();
     }
@@ -246,6 +319,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;
     }
   }
   
@@ -349,6 +429,38 @@ export class AgentChatServer {
 
     // Replay recent messages to the joining agent
     this._replayMessages(ws, msg.channel);
+
+    // Send welcome prompt to the new joiner
+    this._send(ws, createMessage(ServerMessageType.MSG, {
+      from: '@server',
+      to: msg.channel,
+      content: `Welcome to ${msg.channel}, @${agent.id}! Say hello to introduce yourself and start collaborating with other agents.`
+    }));
+
+    // Prompt existing agents to engage with the new joiner (if there are others)
+    const otherAgents = [];
+    for (const memberWs of channel.agents) {
+      if (memberWs !== ws) {
+        const member = this.agents.get(memberWs);
+        if (member) otherAgents.push({ ws: memberWs, id: member.id });
+      }
+    }
+
+    if (otherAgents.length > 0) {
+      // Send a prompt to existing agents to welcome the newcomer
+      const welcomePrompt = createMessage(ServerMessageType.MSG, {
+        from: '@server',
+        to: msg.channel,
+        content: `Hey ${otherAgents.map(a => `@${a.id}`).join(', ')} - new agent @${agent.id} just joined! Say hi and share what you're working on.`
+      });
+
+      for (const other of otherAgents) {
+        this._send(other.ws, welcomePrompt);
+      }
+    }
+
+    // Update channel activity
+    this.channelLastActivity.set(msg.channel, Date.now());
   }
 
   _handleLeave(ws, msg) {
@@ -419,6 +531,9 @@ export class AgentChatServer {
       // Buffer the message for replay to future joiners
       this._bufferMessage(msg.to, outMsg);
 
+      // Update channel activity timestamp (for idle detection)
+      this.channelLastActivity.set(msg.to, Date.now());
+
     } else if (isAgent(msg.to)) {
       // Direct message
       const targetId = msg.to.slice(1); // remove @
@@ -751,6 +866,112 @@ 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(', ')}`
+      }));
+    }
+  }
+
+  _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
+          });
+        }
+      }
+    }
+
+    // Sort by registration time (newest first)
+    results.sort((a, b) => 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.7.0",
+  "version": "0.9.0",
   "description": "Real-time IRC-like communication protocol for AI agents",
   "main": "lib/client.js",
   "files": [
@@ -14,7 +14,9 @@
   },
   "scripts": {
     "start": "node bin/agentchat.js serve",
-    "test": "node --test test/*.test.js"
+    "test": "node --test test/identity.test.js test/deploy.test.js test/daemon.test.js test/receipts.test.js test/reputation.test.js",
+    "test:integration": "node --test test/*.integration.test.js",
+    "test:all": "node --test test/*.test.js"
   },
   "keywords": [
     "ai",