Error handling

import {
  AspError,
  AspTimeoutError,
  AspSessionError,
} from '@npayload/asp-sdk';

try {
  const session = await asp.createSession({
    targetAgent: 'agent://partner.example/sales/bot',
    purpose: 'Negotiate compute',
    schemas: ['compute-offer-v2'],
    maxDuration: 3600000,
  });
} catch (error) {
  if (error instanceof AspTimeoutError) {
    // The target agent did not respond to the invitation in time
    console.log('Invitation timed out:', error.message);
  } else if (error instanceof AspSessionError) {
    // Session-specific error (state violation, participant issue)
    console.log('Session error:', error.code, error.message);
  } else if (error instanceof AspError) {
    // General ASP protocol error
    console.log('ASP error:', error.message);
  }
}

try {
  const session = await asp.createSession({
    targetAgent: 'agent://partner.example/sales/bot',
    purpose: 'Negotiate compute',
    schemas: ['compute-offer-v2'],
    maxDuration: 3600000,
  });
} catch (error) {
  if (error instanceof AspTimeoutError) {
    console.log('Target agent did not respond to invitation');
    // Try a different agent or retry later
  }
}

try {
  await session.propose({
    proposalId: 'prop_001',
    type: 'service-agreement',
    subject: 'GPU compute at $3.50/hr',
    terms: { gpu: 'a100', quantity: 2, pricePerHour: 3.50 },
    maxResponseTimeMs: 30000, // 30 seconds
  });
} catch (error) {
  if (error instanceof AspTimeoutError) {
    console.log('Counterparty did not respond within 30 seconds');
    // Decide: retry, escalate, or close
  }
}

session.on('state', (newState) => {
  if (newState === 'CLOSED' && session.closeReason === 'timeout') {
    console.log('Session expired due to maxDuration');
  }
});

session.on('message', async (msg) => {
  if (msg.performative !== 'REJECT') return;

  const { code, reason, retryable } = msg.body;
  console.log(`Rejected (${code}): ${reason}`);

  switch (code) {
    case 'budget_exceeded':
      if (retryable) {
        // Retry with a lower amount
        await session.propose({
          proposalId: 'prop_002',
          type: 'service-agreement',
          subject: 'GPU compute (revised)',
          terms: { ...originalTerms, pricePerHour: originalTerms.pricePerHour * 0.8 },
        });
      }
      break;

    case 'capacity_unavailable':
      if (retryable) {
        // Wait and retry with exponential backoff
        await delay(60000);
        await session.propose({
          proposalId: 'prop_002',
          type: 'service-agreement',
          subject: 'GPU compute (retry)',
          terms: originalTerms,
        });
      }
      break;

    case 'escalation_required':
      // The counterparty needs human approval first
      console.log('Waiting for human approval on the other side');
      break;

    case 'insufficient_trust_score':
      // Cannot retry without improving trust
      console.log('Trust score too low for this counterparty');
      await session.close({ summary: 'Insufficient trust for this negotiation' });
      break;

    case 'unauthorized':
    case 'policy_violation':
    case 'duplicate':
      // Non-retryable rejections
      await session.close({ summary: `Closed due to ${code}` });
      break;

    default:
      console.log(`Unhandled rejection: ${code}`);
      await session.close({ summary: 'Proposal rejected' });
  }
});

session.on('state', (newState) => {
  if (newState === 'FAILED') {
    console.log('Session failed:', session.failureReason);
    // Log for debugging. FAILED sessions do not affect trust scores.
  }
});

await session.send({
  performative: 'ESCALATE',
  body: {
    reason: 'authority-limit',
    urgency: 'high',
    context: 'Proposed commitment of $15,000/month exceeds my authorized spending limit of $5,000/month',
    suggestedAction: 'Approve the commitment or provide a revised budget ceiling',
  },
});

session.on('integrity-error', async (error) => {
  console.error(`Integrity violation in session ${session.id}:`, {
    type: error.type,
    sequenceNumber: error.sequenceNumber,
    expectedHash: error.expected,
    actualHash: error.actual,
  });

  switch (error.type) {
    case 'hash-mismatch':
      // The computed hash does not match the declared hash.
      // Discard the message. Do not process it.
      // The discarded message does not break the chain
      // because it was never accepted into it.
      console.log('Message discarded due to hash mismatch');
      break;

    case 'chain-broken':
      // The previousHash field does not match the hash
      // of the most recent accepted message.
      // This indicates potential tampering or message reordering.
      await session.send({
        performative: 'INFORM',
        recipient: '*',
        body: {
          type: 'integrity-violation',
          data: {
            sequenceNumber: error.sequenceNumber,
            expected: error.expected,
            actual: error.actual,
          },
        },
      });
      // Consider ESCALATE if commitments or financial terms are involved
      break;

    case 'signature-invalid':
      // The Ed25519 signature does not verify against the
      // sender's public key. This may indicate impersonation.
      // Close immediately.
      await session.send({
        performative: 'CLOSE',
        body: { reason: 'integrity-violation' },
      });
      break;
  }
});

async function retryWithBackoff<T>(
  fn: () => Promise<T>,
  maxRetries: number = 5,
  baseDelayMs: number = 1000,
  maxDelayMs: number = 60000,
): Promise<T> {
  let lastError: Error | undefined;

  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      return await fn();
    } catch (error) {
      lastError = error as Error;

      // Do not retry non-retryable errors
      if (error instanceof AspSessionError) throw error;
      if (error instanceof AspError && !isRetryable(error)) throw error;

      const delay = Math.min(baseDelayMs * Math.pow(2, attempt), maxDelayMs);
      const jitter = delay * 0.1 * Math.random();
      await new Promise((resolve) => setTimeout(resolve, delay + jitter));
    }
  }

  throw lastError;
}

function isRetryable(error: AspError): boolean {
  // Transport errors and timeouts are retryable
  return error instanceof AspTimeoutError || error.message.includes('transport');
}

class RetryBudget {
  private attempts: number[] = [];
  constructor(
    private maxRetries: number,
    private windowMs: number,
  ) {}

  canRetry(): boolean {
    const now = Date.now();
    this.attempts = this.attempts.filter((t) => now - t < this.windowMs);
    return this.attempts.length < this.maxRetries;
  }

  record(): void {
    this.attempts.push(Date.now());
  }
}

// Allow at most 10 retries per 5-minute window
const budget = new RetryBudget(10, 300000);

session.on('message', async (msg) => {
  if (msg.performative === 'REJECT' && msg.body.retryable) {
    if (budget.canRetry()) {
      budget.record();
      // Retry the proposal
    } else {
      console.log('Retry budget exhausted');
      await session.close({ summary: 'Retry budget exhausted' });
    }
  }
});

// Graceful early termination
await session.close({
  summary: 'Unable to meet counterparty requirements after 3 proposals',
});