a2aService.js

/**
 * A2A Service (Agent-to-Agent)
 *
 * Handles autonomous commerce transactions between AI agents, ensuring
 * policy compliance, limit checks, and authorized counterparty validation.
 */

const MandateService = require("./mandate");
const logger = require("../utils/logger");

class A2AService {
  constructor(walletService, db, config = {}) {
    this.walletService = walletService;
    this.db = db;
    this.mandateService = config.mandateService || new MandateService(config.mandateConfig);
    this.strictMandateMode =
      config.strictMandateMode !== undefined
        ? config.strictMandateMode
        : process.env.STRICT_MANDATE_MODE === "true";
  }

  /**
   * Execute a transfer between two agents
   * @param {Object} params
   * @param {string} params.fromAgentId - Sender Agent ID
   * @param {string} params.toAgentId - Recipient Agent ID
   * @param {number} params.amount - Amount to transfer
   * @param {string} params.mandate - Optional signed Mandate (AP2) for Zero Trust validation
   * @param {Object} params.ucpPayload - The original UCP intent/payload
   */
  async executeTransfer({
    fromAgentId,
    toAgentId,
    amount,
    mandate,
    ucpPayload = {},
  }) {
    try {
      // 0. Zero Trust Mandate Validation
      if (mandate) {
        try {
          await this.mandateService.verifyMandate(mandate);
        } catch (error) {
          throw new Error(
            `Zero Trust Validation Failed: Mandate verification failed: ${error.message}`,
          );
        }
      } else if (this.strictMandateMode) {
        throw new Error(
          "Zero Trust Validation Failed: Mandate required for A2A transfer in strict mode",
        );
      }

      // 1. Validate Agents using Repository Pattern
      const fromAgent = await this.db.findAgentById(fromAgentId);
      if (!fromAgent || fromAgent.status !== "active") {
        throw new Error(
          `Zero Trust Validation Failed: Sender agent ${fromAgentId} not found or inactive`,
        );
      }

      const toAgent = await this.db.findAgentById(toAgentId);
      if (!toAgent || toAgent.status !== "active") {
        throw new Error(
          `Zero Trust Validation Failed: Recipient agent ${toAgentId} not found or inactive`,
        );
      }

      // 2. Policy Checks (Sender)
      await this._validateAgentPolicy(fromAgent, toAgentId, amount);

      // 3. Execute Wallet Transfer
      const transferResult = await this.walletService.transfer({
        fromWalletId: fromAgent.walletId,
        toWalletId: toAgent.walletId,
        amount,
        description: `A2A Transfer: ${fromAgent.name} -> ${toAgent.name}`,
        metadata: {
          // Pass metadata for Transaction creation
          agentId: fromAgentId,
          counterpartyAgentId: toAgentId,
          ucpPayload,
          type: "a2a_transfer",
          mandate,
        },
      });

      return {
        success: true,
        transferId: transferResult.transferId,
        timestamp: new Date(),
        fromAgent: fromAgent.name,
        toAgent: toAgent.name,
        amount,
      };
    } catch (error) {
      throw this._handleError("executeTransfer", error);
    }
  }

  /**
   * Validate agent policies
   * @private
   */
  async _validateAgentPolicy(agent, counterpartyId, amount) {
    const { config } = agent;
    if (!config) return;

    // Check Per Transaction Limit
    if (
      config.limits?.perTransaction > 0 &&
      amount > config.limits.perTransaction
    ) {
      throw new Error(
        `Zero Trust Validation Failed: Amount ${amount} exceeds agent per-transaction limit of ${config.limits.perTransaction}`,
      );
    }

    // Check Authorized Counterparties
    if (
      config.authorizedCounterparties &&
      config.authorizedCounterparties.length > 0
    ) {
      if (!config.authorizedCounterparties.includes(counterpartyId)) {
        throw new Error(
          `Zero Trust Validation Failed: Agent ${agent.id} is not authorized to trade with ${counterpartyId}`,
        );
      }
    }
  }

  /**
   * Handle and format errors
   * @private
   */
  _handleError(method, error) {
    logger.error(`A2AService.${method} error:`, error);
    return error instanceof Error ? error : new Error(error);
  }
}

module.exports = A2AService;