Error Handling

interface ABPError {
  code: string;              // Machine-readable error code
  message: string;           // Human-readable message
  details?: unknown;         // Additional context
  retryable: boolean;        // Can this operation be retried?
  retryAfter?: number;       // Suggested retry delay in ms
  alternatives?: string[];   // Alternative capabilities to try
}

async function callCapability(capability, params) {
  try {
    const result = await abp.call(capability, params);

    if (result.success) {
      return result.data;
    }

    // Handle error
    const error = result.error;

    if (error.retryable) {
      // Retry with exponential backoff
      const delay = error.retryAfter || 1000;
      await sleep(delay);
      return await callCapability(capability, params);
    }

    // Check for alternatives
    if (error.alternatives && error.alternatives.length > 0) {
      console.log(`Try alternative: ${error.alternatives[0]}`);
    }

    throw new Error(`Capability failed: ${error.message}`);
  } catch (err) {
    console.error('Failed to call capability:', err);
    throw err;
  }
}

async convertMarkdownToHtml({ markdown, options }) {
  try {
    // Attempt operation
    const html = await renderMarkdown(markdown, options);

    return {
      success: true,
      data: { html }
    };
  } catch (error) {
    // Map browser errors to ABP error codes
    let code = 'OPERATION_FAILED';
    let retryable = false;

    if (error.name === 'NotAllowedError') {
      code = 'PERMISSION_DENIED';
      retryable = true;
    } else if (error.name === 'SecurityError') {
      code = 'PERMISSION_REQUIRED';
      retryable = true;
    }

    return {
      success: false,
      error: {
        code,
        message: error.message,
        retryable
      }
    };
  }
}

async function callWithFallback(capability, params) {
  const result = await abp.call(capability, params);

  if (result.success) {
    return result.data;
  }

  const error = result.error;

  // Try alternatives if available
  if (error.alternatives && error.alternatives.length > 0) {
    for (const alternative of error.alternatives) {
      console.log(`Primary capability failed, trying alternative: ${alternative}`);
      const fallback = await abp.call(alternative, params);

      if (fallback.success) {
        return fallback.data;
      }
    }
  }

  throw new Error(`Capability ${capability} failed with no viable alternatives: ${error.message}`);
}

async function callWithRetry(capability, params, maxRetries = 3) {
  let lastError;

  for (let attempt = 0; attempt < maxRetries; attempt++) {
    const result = await abp.call(capability, params);

    if (result.success) {
      return result.data;
    }

    lastError = result.error;

    if (!lastError.retryable) {
      throw new Error(`Not retryable: ${lastError.message}`);
    }

    // Exponential backoff: 1s, 2s, 4s
    const delay = (lastError.retryAfter || 1000) * Math.pow(2, attempt);
    console.log(`Retry ${attempt + 1}/${maxRetries} after ${delay}ms`);
    await sleep(delay);
  }

  throw new Error(`Max retries exceeded: ${lastError.message}`);
}