@tjamescouch/agentchat 0.18.1 → 0.18.3

package/lib/server/handlers/proposal.js

@@ -0,0 +1,358 @@
+/**
+ * Proposal Handlers
+ * Handles proposal, accept, reject, complete, dispute operations
+ */
+
+import {
+  ServerMessageType,
+  ErrorCode,
+  createMessage,
+  createError,
+} from '../../protocol.js';
+import { formatProposal, formatProposalResponse } from '../../proposals.js';
+import {
+  EscrowEvent,
+  createEscrowCreatedPayload,
+  createCompletionPayload,
+  createDisputePayload,
+} from '../../escrow-hooks.js';
+
+/**
+ * Handle PROPOSAL command
+ */
+export function handleProposal(server, ws, msg) {
+  const agent = server.agents.get(ws);
+  if (!agent) {
+    server._send(ws, createError(ErrorCode.AUTH_REQUIRED, 'Must IDENTIFY first'));
+    return;
+  }
+
+  // Proposals require a persistent identity (signature verification)
+  if (!agent.pubkey) {
+    server._send(ws, createError(ErrorCode.SIGNATURE_REQUIRED, 'Proposals require persistent identity'));
+    return;
+  }
+
+  const targetId = msg.to.slice(1);
+  const targetWs = server.agentById.get(targetId);
+
+  if (!targetWs) {
+    server._send(ws, createError(ErrorCode.AGENT_NOT_FOUND, `Agent ${msg.to} not found`));
+    return;
+  }
+
+  // Create proposal in store
+  const proposal = server.proposals.create({
+    from: `@${agent.id}`,
+    to: msg.to,
+    task: msg.task,
+    amount: msg.amount,
+    currency: msg.currency,
+    payment_code: msg.payment_code,
+    terms: msg.terms,
+    expires: msg.expires,
+    sig: msg.sig,
+    elo_stake: msg.elo_stake || null
+  });
+
+  server._log('proposal', { id: proposal.id, from: agent.id, to: targetId });
+
+  // Send to target
+  const outMsg = createMessage(ServerMessageType.PROPOSAL, {
+    ...formatProposal(proposal)
+  });
+
+  server._send(targetWs, outMsg);
+  // Echo back to sender with the assigned ID
+  server._send(ws, outMsg);
+}
+
+/**
+ * Handle ACCEPT command
+ */
+export async function handleAccept(server, ws, msg) {
+  const agent = server.agents.get(ws);
+  if (!agent) {
+    server._send(ws, createError(ErrorCode.AUTH_REQUIRED, 'Must IDENTIFY first'));
+    return;
+  }
+
+  if (!agent.pubkey) {
+    server._send(ws, createError(ErrorCode.SIGNATURE_REQUIRED, 'Accepting proposals requires persistent identity'));
+    return;
+  }
+
+  // Get proposal first to check stakes
+  const existingProposal = server.proposals.get(msg.proposal_id);
+  if (!existingProposal) {
+    server._send(ws, createError(ErrorCode.PROPOSAL_NOT_FOUND, 'Proposal not found'));
+    return;
+  }
+
+  const proposerStake = existingProposal.proposer_stake || 0;
+  const acceptorStake = msg.elo_stake || 0;
+
+  // Validate proposer can stake (if they declared a stake)
+  if (proposerStake > 0) {
+    const canProposerStake = await server.reputationStore.canStake(existingProposal.from, proposerStake);
+    if (!canProposerStake.canStake) {
+      server._send(ws, createError(ErrorCode.INSUFFICIENT_REPUTATION, `Proposer: ${canProposerStake.reason}`));
+      return;
+    }
+  }
+
+  // Validate acceptor can stake (if they declared a stake)
+  if (acceptorStake > 0) {
+    const canAcceptorStake = await server.reputationStore.canStake(`@${agent.id}`, acceptorStake);
+    if (!canAcceptorStake.canStake) {
+      server._send(ws, createError(ErrorCode.INSUFFICIENT_REPUTATION, canAcceptorStake.reason));
+      return;
+    }
+  }
+
+  const result = server.proposals.accept(
+    msg.proposal_id,
+    `@${agent.id}`,
+    msg.sig,
+    msg.payment_code,
+    acceptorStake
+  );
+
+  if (result.error) {
+    server._send(ws, createError(ErrorCode.INVALID_PROPOSAL, result.error));
+    return;
+  }
+
+  const proposal = result.proposal;
+
+  // Create escrow if either party has a stake
+  if (proposerStake > 0 || acceptorStake > 0) {
+    const escrowResult = await server.reputationStore.createEscrow(
+      proposal.id,
+      { agent_id: proposal.from, stake: proposerStake },
+      { agent_id: proposal.to, stake: acceptorStake },
+      proposal.expires
+    );
+
+    if (escrowResult.success) {
+      proposal.stakes_escrowed = true;
+      server._log('escrow_created', {
+        proposal_id: proposal.id,
+        proposer_stake: proposerStake,
+        acceptor_stake: acceptorStake
+      });
+
+      // Emit escrow:created hook for external integrations
+      server.escrowHooks.emit(EscrowEvent.CREATED, createEscrowCreatedPayload(proposal, escrowResult))
+        .catch(err => server._log('escrow_hook_error', { event: 'created', error: err.message }));
+    } else {
+      server._log('escrow_error', { proposal_id: proposal.id, error: escrowResult.error });
+    }
+  }
+
+  server._log('accept', { id: proposal.id, by: agent.id, proposer_stake: proposerStake, acceptor_stake: acceptorStake });
+
+  // Notify the proposal creator
+  const creatorId = proposal.from.slice(1);
+  const creatorWs = server.agentById.get(creatorId);
+
+  const outMsg = createMessage(ServerMessageType.ACCEPT, {
+    ...formatProposalResponse(proposal, 'accept')
+  });
+
+  if (creatorWs) {
+    server._send(creatorWs, outMsg);
+  }
+  // Echo to acceptor
+  server._send(ws, outMsg);
+}
+
+/**
+ * Handle REJECT command
+ */
+export function handleReject(server, ws, msg) {
+  const agent = server.agents.get(ws);
+  if (!agent) {
+    server._send(ws, createError(ErrorCode.AUTH_REQUIRED, 'Must IDENTIFY first'));
+    return;
+  }
+
+  if (!agent.pubkey) {
+    server._send(ws, createError(ErrorCode.SIGNATURE_REQUIRED, 'Rejecting proposals requires persistent identity'));
+    return;
+  }
+
+  const result = server.proposals.reject(
+    msg.proposal_id,
+    `@${agent.id}`,
+    msg.sig,
+    msg.reason
+  );
+
+  if (result.error) {
+    server._send(ws, createError(ErrorCode.INVALID_PROPOSAL, result.error));
+    return;
+  }
+
+  const proposal = result.proposal;
+  server._log('reject', { id: proposal.id, by: agent.id });
+
+  // Notify the proposal creator
+  const creatorId = proposal.from.slice(1);
+  const creatorWs = server.agentById.get(creatorId);
+
+  const outMsg = createMessage(ServerMessageType.REJECT, {
+    ...formatProposalResponse(proposal, 'reject')
+  });
+
+  if (creatorWs) {
+    server._send(creatorWs, outMsg);
+  }
+  // Echo to rejector
+  server._send(ws, outMsg);
+}
+
+/**
+ * Handle COMPLETE command
+ */
+export async function handleComplete(server, ws, msg) {
+  const agent = server.agents.get(ws);
+  if (!agent) {
+    server._send(ws, createError(ErrorCode.AUTH_REQUIRED, 'Must IDENTIFY first'));
+    return;
+  }
+
+  if (!agent.pubkey) {
+    server._send(ws, createError(ErrorCode.SIGNATURE_REQUIRED, 'Completing proposals requires persistent identity'));
+    return;
+  }
+
+  const result = server.proposals.complete(
+    msg.proposal_id,
+    `@${agent.id}`,
+    msg.sig,
+    msg.proof
+  );
+
+  if (result.error) {
+    server._send(ws, createError(ErrorCode.INVALID_PROPOSAL, result.error));
+    return;
+  }
+
+  const proposal = result.proposal;
+  server._log('complete', { id: proposal.id, by: agent.id });
+
+  // Update reputation ratings (includes escrow settlement)
+  let ratingChanges = null;
+  try {
+    ratingChanges = await server.reputationStore.processCompletion({
+      type: 'COMPLETE',
+      proposal_id: proposal.id,
+      from: proposal.from,
+      to: proposal.to,
+      amount: proposal.amount
+    });
+    server._log('reputation_updated', {
+      proposal_id: proposal.id,
+      changes: ratingChanges,
+      escrow: ratingChanges?._escrow
+    });
+
+    // Emit settlement:completion hook for external integrations
+    if (ratingChanges?._escrow) {
+      server.escrowHooks.emit(EscrowEvent.COMPLETION_SETTLED, createCompletionPayload(proposal, ratingChanges))
+        .catch(err => server._log('escrow_hook_error', { event: 'completion', error: err.message }));
+    }
+  } catch (err) {
+    server._log('reputation_error', { error: err.message });
+  }
+
+  // Notify both parties
+  const outMsg = createMessage(ServerMessageType.COMPLETE, {
+    ...formatProposalResponse(proposal, 'complete'),
+    rating_changes: ratingChanges
+  });
+
+  // Notify the other party
+  const otherId = proposal.from === `@${agent.id}` ? proposal.to.slice(1) : proposal.from.slice(1);
+  const otherWs = server.agentById.get(otherId);
+
+  if (otherWs) {
+    server._send(otherWs, outMsg);
+  }
+  // Echo to completer
+  server._send(ws, outMsg);
+}
+
+/**
+ * Handle DISPUTE command
+ */
+export async function handleDispute(server, ws, msg) {
+  const agent = server.agents.get(ws);
+  if (!agent) {
+    server._send(ws, createError(ErrorCode.AUTH_REQUIRED, 'Must IDENTIFY first'));
+    return;
+  }
+
+  if (!agent.pubkey) {
+    server._send(ws, createError(ErrorCode.SIGNATURE_REQUIRED, 'Disputing proposals requires persistent identity'));
+    return;
+  }
+
+  const result = server.proposals.dispute(
+    msg.proposal_id,
+    `@${agent.id}`,
+    msg.sig,
+    msg.reason
+  );
+
+  if (result.error) {
+    server._send(ws, createError(ErrorCode.INVALID_PROPOSAL, result.error));
+    return;
+  }
+
+  const proposal = result.proposal;
+  server._log('dispute', { id: proposal.id, by: agent.id, reason: msg.reason });
+
+  // Update reputation ratings (includes escrow settlement)
+  let ratingChanges = null;
+  try {
+    ratingChanges = await server.reputationStore.processDispute({
+      type: 'DISPUTE',
+      proposal_id: proposal.id,
+      from: proposal.from,
+      to: proposal.to,
+      amount: proposal.amount,
+      disputed_by: `@${agent.id}`
+    });
+    server._log('reputation_updated', {
+      proposal_id: proposal.id,
+      changes: ratingChanges,
+      escrow: ratingChanges?._escrow
+    });
+
+    // Emit settlement:dispute hook for external integrations
+    if (ratingChanges?._escrow) {
+      server.escrowHooks.emit(EscrowEvent.DISPUTE_SETTLED, createDisputePayload(proposal, ratingChanges))
+        .catch(err => server._log('escrow_hook_error', { event: 'dispute', error: err.message }));
+    }
+  } catch (err) {
+    server._log('reputation_error', { error: err.message });
+  }
+
+  // Notify both parties
+  const outMsg = createMessage(ServerMessageType.DISPUTE, {
+    ...formatProposalResponse(proposal, 'dispute'),
+    rating_changes: ratingChanges
+  });
+
+  // Notify the other party
+  const otherId = proposal.from === `@${agent.id}` ? proposal.to.slice(1) : proposal.from.slice(1);
+  const otherWs = server.agentById.get(otherId);
+
+  if (otherWs) {
+    server._send(otherWs, outMsg);
+  }
+  // Echo to disputer
+  server._send(ws, outMsg);
+}

package/lib/server/handlers/skills.js

@@ -0,0 +1,141 @@
+/**
+ * Skills Handlers
+ * Handles skill registration and search
+ */
+
+import {
+  ServerMessageType,
+  ErrorCode,
+  createMessage,
+  createError,
+} from '../../protocol.js';
+
+/**
+ * Handle REGISTER_SKILLS command
+ */
+export function handleRegisterSkills(server, ws, msg) {
+  const agent = server.agents.get(ws);
+  if (!agent) {
+    server._send(ws, createError(ErrorCode.AUTH_REQUIRED, 'Must IDENTIFY first'));
+    return;
+  }
+
+  if (!agent.pubkey) {
+    server._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
+  };
+
+  server.skillsRegistry.set(agent.id, registration);
+
+  server._log('skills_registered', { agent: agent.id, count: msg.skills.length });
+
+  // Notify the registering agent
+  server._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 (server.channels.has('#discovery')) {
+    server._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(', ')}`
+    }));
+  }
+}
+
+/**
+ * Handle SEARCH_SKILLS command
+ */
+export async function handleSearchSkills(server, ws, msg) {
+  const agent = server.agents.get(ws);
+  if (!agent) {
+    server._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 server.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 server.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);
+
+  server._log('skills_search', { agent: agent.id, query, results_count: limitedResults.length });
+
+  server._send(ws, createMessage(ServerMessageType.SEARCH_RESULTS, {
+    query_id: msg.query_id || null,
+    query,
+    results: limitedResults,
+    total: results.length
+  }));
+}