get-models.js

/**
 * Rahyana API - Get Available Models Example
 * 
 * This example demonstrates how to retrieve the list of available models
 * from the Rahyana API.
 * 
 * Usage:
 *   Set your API key: export RAHYANA_API_KEY="your_api_key_here"
 *   Run: node get-models.js
 * 
 * @file models/get-models.js
 */

// Configuration - supports environment variable or placeholder
const API_KEY = process.env.RAHYANA_API_KEY || 'YOUR_API_KEY_HERE'; // کلید API خود را اینجا قرار دهید یا از متغیر محیطی RAHYANA_API_KEY استفاده کنید
const BASE_URL = process.env.RAHYANA_BASE_URL || 'https://rahyana.ir/api/v1';

/**
 * Retrieves the list of available models from the Rahyana API
 * 
 * @returns {Promise<Object>} The API response containing the list of models
 * @throws {Error} If the API request fails or response is invalid
 * 
 * @example
 *   const models = await getAvailableModels();
 *   console.log(`Found ${models.data.length} models`);
 */
async function getAvailableModels() {
  try {
    const response = await fetch(`${BASE_URL}/models`, {
      method: 'GET',
      headers: {
        'Authorization': `Bearer ${API_KEY}`,
        'Content-Type': 'application/json',
        'HTTP-Referer': 'https://example-app.com',
        'X-Title': 'Rahyana Models Example'
      }
    });

    // Handle HTTP errors
    if (!response.ok) {
      let errorMessage = `HTTP error! Status: ${response.status}`;
      try {
        const errorData = await response.json();
        if (errorData.error && errorData.error.message) {
          errorMessage = `API Error: ${errorData.error.message} (Status: ${response.status})`;
        }
      } catch (e) {
        errorMessage = `HTTP error! Status: ${response.status} ${response.statusText}`;
      }
      throw new Error(errorMessage);
    }

    // Parse JSON response
    let data;
    try {
      data = await response.json();
    } catch (parseError) {
      throw new Error(`Failed to parse JSON response: ${parseError.message}`);
    }

    // Validate response structure
    if (!data || typeof data !== 'object') {
      throw new Error('Invalid response: Expected JSON object');
    }

    if (data.data && Array.isArray(data.data)) {
      console.log(`✅ Found ${data.data.length} models:`);
      console.log('='.repeat(50));
      
      data.data.forEach((model, index) => {
        console.log(`${index + 1}. ${model.id}`);
        if (model.name) console.log(`   Name: ${model.name}`);
        if (model.provider) console.log(`   Provider: ${model.provider}`);
        if (model.type) console.log(`   Type: ${model.type}`);
        if (model.context_length) console.log(`   Context Length: ${model.context_length}`);
        if (model.pricing) console.log(`   Pricing: ${JSON.stringify(model.pricing)}`);
        console.log('   ' + '-'.repeat(48));
      });
    } else {
      console.warn('⚠️  Warning: Response does not contain models array');
    }

    return data;
  } catch (error) {
    // Handle network errors
    if (error instanceof TypeError && error.message.includes('fetch')) {
      console.error('❌ Network Error: Failed to connect to API. Check your internet connection and API endpoint.');
      throw new Error(`Network error: ${error.message}`);
    }

    // Handle other errors
    console.error('❌ Error:', error.message);
    throw error;
  }
}

/**
 * Filters models by their capabilities
 * 
 * @param {string} capability - The capability to filter by ('text', 'image', 'audio', 'function_calling')
 * @returns {Promise<Array>} Array of models with the specified capability
 * @throws {Error} If filtering fails
 */
async function filterModelsByCapability(capability) {
  try {
    const models = await getAvailableModels();
    
    if (models.data && Array.isArray(models.data)) {
      const filteredModels = models.data.filter(model => {
        // Check if model has the specified capability
        if (capability === 'text') {
          return model.type === 'text' || model.type === 'chat';
        } else if (capability === 'image') {
          return model.capabilities && model.capabilities.includes('image');
        } else if (capability === 'audio') {
          return model.capabilities && model.capabilities.includes('audio');
        } else if (capability === 'function_calling') {
          return model.capabilities && model.capabilities.includes('function_calling');
        }
        return false;
      });

      console.log(`\n📋 Models with ${capability} capability:`);
      console.log('='.repeat(50));
      filteredModels.forEach((model, index) => {
        console.log(`${index + 1}. ${model.id}`);
      });

      return filteredModels;
    }

    return [];
  } catch (error) {
    console.error('❌ Error filtering models:', error.message);
    throw error;
  }
}

/**
 * Gets a specific model by its ID
 * 
 * @param {string} modelId - The model ID to search for
 * @returns {Promise<Object|null>} The model object if found, null otherwise
 * @throws {Error} If the search fails
 */
async function getModelById(modelId) {
  try {
    const models = await getAvailableModels();
    
    if (models.data && Array.isArray(models.data)) {
      const model = models.data.find(m => m.id === modelId);
      
      if (model) {
        console.log(`\n🔍 Model Details for ${modelId}:`);
        console.log('='.repeat(50));
        console.log(JSON.stringify(model, null, 2));
        return model;
      } else {
        console.log(`❌ Model ${modelId} not found`);
        return null;
      }
    }

    return null;
  } catch (error) {
    console.error('❌ Error getting model by ID:', error.message);
    throw error;
  }
}

/**
 * Gets all models from a specific provider
 * 
 * @param {string} provider - The provider name to filter by
 * @returns {Promise<Array>} Array of models from the specified provider
 * @throws {Error} If the search fails
 */
async function getModelsByProvider(provider) {
  try {
    const models = await getAvailableModels();
    
    if (models.data && Array.isArray(models.data)) {
      const providerModels = models.data.filter(model => 
        model.provider && model.provider.toLowerCase().includes(provider.toLowerCase())
      );

      console.log(`\n🏢 Models from ${provider}:`);
      console.log('='.repeat(50));
      providerModels.forEach((model, index) => {
        console.log(`${index + 1}. ${model.id} (${model.name || 'N/A'})`);
      });

      return providerModels;
    }

    return [];
  } catch (error) {
    console.error('❌ Error getting models by provider:', error.message);
    throw error;
  }
}

// Execute the example if run directly
if (import.meta.url === `file://${process.argv[1]}`) {
  console.log('🚀 Getting all available models...');
  getAvailableModels()
    .then(result => {
      console.log('\n📋 Filtering models by text capability...');
      return filterModelsByCapability('text');
    })
    .then(result => {
      console.log('\n📋 Filtering models by image capability...');
      return filterModelsByCapability('image');
    })
    .then(result => {
      console.log('\n🔍 Getting specific model details...');
      return getModelById('openai/gpt-4o');
    })
    .then(result => {
      console.log('\n🏢 Getting models by provider...');
      return getModelsByProvider('openai');
    })
    .then(result => {
      console.log('\n✅ All model examples completed!');
      process.exit(0);
    })
    .catch(error => {
      console.error('❌ Failed:', error.message);
      process.exit(1);
    });
}

// Export functions for use in other modules
export { getAvailableModels, filterModelsByCapability, getModelById, getModelsByProvider };