index.js

const fetch = require('node-fetch');

const DEFAULT_BASE_URL = 'https://api.agenticterminal.ai';
const DEFAULT_FALLBACK = 'review';

/**
 * Observer Protocol SDK for Node.js / Express
 * 
 * Provides reputation checks and middleware for agent-to-agent payments
 * Works with x402, Lightning, L402, and any payment rail
 */
class ObserverClient {
  constructor(options = {}) {
    this.apiKey = options.apiKey || null;
    this.baseUrl = options.baseUrl || DEFAULT_BASE_URL;
    this.cache = new Map();
  }

  /**
   * Get reputation for an agent by ID
   * @param {string} agentId - The Observer Protocol agent ID
   * @returns {Promise<Object>} Reputation data
   */
  async getReputation(agentId) {
    const cacheKey = `agent:${agentId}`;
    const cached = this.cache.get(cacheKey);
    
    if (cached && cached.expires > Date.now()) {
      return cached.data;
    }

    try {
      const headers = {};
      if (this.apiKey) {
        headers['Authorization'] = `Bearer ${this.apiKey}`;
      }

      const response = await fetch(
        `${this.baseUrl}/observer/reputation/${encodeURIComponent(agentId)}`,
        { headers }
      );

      if (response.status === 404) {
        const fallback = {
          agent_id: agentId,
          verified: false,
          reputation_score: 0,
          trust_tier: 'unknown',
          payment_history: null,
          risk_signals: { known_bad: false },
          suggested_action: 'review',
          cache_ttl_seconds: 60
        };
        this._setCache(cacheKey, fallback, fallback.cache_ttl_seconds);
        return fallback;
      }

      if (!response.ok) {
        throw new Error(`OP API error: ${response.status}`);
      }

      const data = await response.json();
      this._setCache(cacheKey, data, data.cache_ttl_seconds || 300);
      return data;
    } catch (error) {
      // Network error - return review fallback
      return {
        agent_id: agentId,
        verified: false,
        reputation_score: 0,
        trust_tier: 'unknown',
        payment_history: null,
        risk_signals: { known_bad: false },
        suggested_action: 'review',
        cache_ttl_seconds: 60,
        _error: error.message
      };
    }
  }

  /**
   * Get reputation for an agent by wallet address
   * @param {string} address - EVM wallet address
   * @returns {Promise<Object>} Reputation data
   */
  async getReputationByWallet(address) {
    const cacheKey = `wallet:${address.toLowerCase()}`;
    const cached = this.cache.get(cacheKey);
    
    if (cached && cached.expires > Date.now()) {
      return cached.data;
    }

    try {
      const headers = {};
      if (this.apiKey) {
        headers['Authorization'] = `Bearer ${this.apiKey}`;
      }

      const response = await fetch(
        `${this.baseUrl}/observer/reputation/wallet/${encodeURIComponent(address)}`,
        { headers }
      );

      if (response.status === 404) {
        const fallback = {
          wallet_address: address,
          verified: false,
          reputation_score: 0,
          trust_tier: 'unknown',
          payment_history: null,
          risk_signals: { known_bad: false },
          suggested_action: 'review',
          cache_ttl_seconds: 60
        };
        this._setCache(cacheKey, fallback, fallback.cache_ttl_seconds);
        return fallback;
      }

      if (!response.ok) {
        throw new Error(`OP API error: ${response.status}`);
      }

      const data = await response.json();
      this._setCache(cacheKey, data, data.cache_ttl_seconds || 300);
      return data;
    } catch (error) {
      return {
        wallet_address: address,
        verified: false,
        reputation_score: 0,
        trust_tier: 'unknown',
        payment_history: null,
        risk_signals: { known_bad: false },
        suggested_action: 'review',
        cache_ttl_seconds: 60,
        _error: error.message
      };
    }
  }

  _setCache(key, data, ttlSeconds) {
    this.cache.set(key, {
      data,
      expires: Date.now() + (ttlSeconds * 1000)
    });
  }

  /**
   * Express middleware for reputation checking
   * @param {Object} options - Middleware options
   * @param {string} options.fallback - Fallback action on error ('accept', 'review', 'reject')
   * @param {string} options.policy - Policy mode ('lenient', 'strict')
   * @returns {Function} Express middleware
   */
  reputationMiddleware(options = {}) {
    const fallback = options.fallback || DEFAULT_FALLBACK;
    const policy = options.policy || 'lenient';

    return async (req, res, next) => {
      // Extract agent identity from request
      const agentId = req.headers['x-observer-agent-id'];
      const walletAddress = req.headers['x-agent-wallet'];
      
      // For POST requests, check x402 payment proof body
      let x402From = null;
      if (req.method === 'POST' && req.body && typeof req.body === 'object') {
        x402From = req.body.from || req.body.payment?.from;
      }

      let identity = null;
      let identityType = null;

      if (agentId) {
        identity = agentId;
        identityType = 'agent';
      } else if (walletAddress) {
        identity = walletAddress;
        identityType = 'wallet';
      } else if (x402From) {
        identity = x402From;
        identityType = 'wallet';
      }

      // No identity found - proceed without reputation
      if (!identity) {
        req.observerReputation = null;
        return next();
      }

      // Fetch reputation
      let reputation;
      try {
        if (identityType === 'agent') {
          reputation = await this.getReputation(identity);
        } else {
          reputation = await this.getReputationByWallet(identity);
        }
      } catch (error) {
        // On error, use fallback
        reputation = {
          suggested_action: fallback,
          trust_tier: 'unknown',
          _error: error.message
        };
      }

      // Attach to request
      req.observerReputation = reputation;

      // Handle suggested actions
      const action = reputation.suggested_action || fallback;

      if (action === 'reject') {
        return res.status(403).json({
          error: 'Access denied',
          reason: 'Agent reputation insufficient',
          code: 'OP_REPUTATION_REJECT'
        });
      }

      if (action === 'review' && policy === 'strict') {
        return res.status(402).json({
          error: 'Payment requires review',
          reason: 'Agent not verified in Observer Protocol',
          code: 'OP_REPUTATION_REVIEW',
          registration_url: 'https://agenticterminal.ai/observer/register'
        });
      }

      // accept or (review + lenient policy) - proceed
      next();
    };
  }
}

/**
 * Standalone middleware factory (for simple usage)
 * @param {Object} options - Options
 * @returns {Function} Express middleware
 */
function reputationMiddleware(options = {}) {
  const client = new ObserverClient(options);
  return client.reputationMiddleware(options);
}

module.exports = {
  ObserverClient,
  reputationMiddleware
};