Error Handling

curl -X GET https://your-tenant.mindhunters.ai/api/v1/calls \
  -H "Authorization: Bearer YOUR_API_TOKEN"

{
  "participant": {
    "number": "+1234567890"  // ✓ Valid
  }
}

async function makeRequestWithRetry(url, options, maxRetries = 3) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      const response = await fetch(url, options);

      if (response.status === 429) {
        const data = await response.json();
        const retryAfter = data.error.retryAfter || Math.pow(2, attempt);

        console.log(`Rate limited. Retrying after ${retryAfter}s...`);
        await new Promise(resolve => setTimeout(resolve, retryAfter * 1000));
        continue;
      }

      return response;
    } catch (error) {
      if (attempt === maxRetries - 1) throw error;
      await new Promise(resolve => setTimeout(resolve, Math.pow(2, attempt) * 1000));
    }
  }
}

class MindhuntersAPIClient {
  constructor(tenant, apiToken) {
    this.baseUrl = `https://${tenant}.mindhunters.ai/api/v1`;
    this.apiToken = apiToken;
  }

  async makeRequest(endpoint, options = {}) {
    const url = `${this.baseUrl}${endpoint}`;
    const defaultOptions = {
      headers: {
        'Authorization': `Bearer ${this.apiToken}`,
        'Content-Type': 'application/json',
        ...options.headers
      }
    };

    const requestOptions = { ...defaultOptions, ...options };

    try {
      const response = await fetch(url, requestOptions);

      // Handle successful responses
      if (response.ok) {
        return await response.json();
      }

      // Parse error response
      const errorData = await response.json();

      // Handle specific error types
      switch (response.status) {
        case 400:
          throw new Error(`Bad Request: ${errorData.message}`);

        case 401:
          throw new Error('Authentication failed. Please check your API token.');

        case 403:
          throw new Error('Permission denied. Insufficient permissions.');

        case 404:
          throw new Error(`Not found: ${errorData.message}`);

        case 422:
          const field = errorData.error?.field || 'unknown';
          throw new Error(`Validation error in ${field}: ${errorData.message}`);

        case 429:
          const retryAfter = errorData.error?.retryAfter || 60;
          throw new Error(`Rate limit exceeded. Retry after ${retryAfter}s`);

        case 500:
        case 502:
        case 503:
          throw new Error('Server error. Please try again later.');

        default:
          throw new Error(`API Error: ${errorData.message}`);
      }

    } catch (error) {
      if (error instanceof TypeError) {
        throw new Error('Network error. Please check your connection.');
      }
      throw error;
    }
  }

  async initiateCall(agentId, phoneNumber, options = {}) {
    // Validate phone number format
    if (!/^\+[1-9]\d{1,14}$/.test(phoneNumber)) {
      throw new Error('Phone number must be in E.164 format (e.g., +1234567890)');
    }

    return await this.makeRequest('/call', {
      method: 'POST',
      body: JSON.stringify({
        agentId,
        participant: { number: phoneNumber },
        ...options
      })
    });
  }
}

// Usage
const client = new MindhuntersAPIClient('your-tenant', 'YOUR_API_TOKEN');

try {
  const result = await client.initiateCall(
    '550e8400-e29b-41d4-a716-446655440000',
    '+1234567890'
  );
  console.log('Call initiated:', result.data.id);
} catch (error) {
  console.error('Failed to initiate call:', error.message);
}