Models Configuration

// Get complete model data
const modelData = MODELS_DATA['gpt-4o'];

console.log(modelData.name);          // "GPT-4o"
console.log(modelData.contextLimit);  // 128000
console.log(modelData.inputCost);     // 2.50

function calculateCost(modelId, inputTokens, outputTokens) {
  const model = MODELS_DATA[modelId];
  
  if (!model) {
    throw new Error(`Model ${modelId} not found`);
  }
  
  // Apply token ratio adjustment
  const adjustedInput = inputTokens * model.tokenRatio;
  const adjustedOutput = outputTokens * model.tokenRatio;
  
  // Calculate costs (prices are per 1M tokens)
  const inputCost = (adjustedInput / 1_000_000) * model.inputCost;
  const outputCost = (adjustedOutput / 1_000_000) * model.outputCost;
  
  return {
    input: inputCost,
    output: outputCost,
    total: inputCost + outputCost
  };
}

// Example usage
const cost = calculateCost('gpt-4o', 50000, 10000);
console.log(`Total cost: $${cost.total.toFixed(4)}`);

function buildModelSelector() {
  const modelsByCompany = {};
  
  // Group models by company
  Object.entries(MODELS_DATA).forEach(([id, model]) => {
    if (!modelsByCompany[model.company]) {
      modelsByCompany[model.company] = [];
    }
    modelsByCompany[model.company].push({ id, ...model });
  });
  
  // Build UI with company branding
  const selectorHTML = Object.entries(modelsByCompany).map(([company, models]) => {
    const branding = COMPANIES[company];
    
    return `
      <div class="company-group">
        <div class="company-header" style="color: ${branding.color}">
          <span class="logo">${branding.logo}</span>
          <span class="name">${company}</span>
        </div>
        <div class="models">
          ${models.map(m => `
            <div class="model-option" data-model-id="${m.id}">
              <span class="model-name">${m.name}</span>
              <span class="model-context">${(m.contextLimit / 1000).toFixed(0)}K</span>
              <span class="model-cost">$${m.inputCost}/$${m.outputCost}</span>
            </div>
          `).join('')}
        </div>
      </div>
    `;
  }).join('');
  
  return selectorHTML;
}

function validateContextLength(modelId, tokenCount) {
  const model = MODELS_DATA[modelId];
  
  if (!model) {
    return { valid: false, error: 'Model not found' };
  }
  
  // Apply token ratio
  const adjustedTokens = tokenCount * model.tokenRatio;
  
  if (adjustedTokens > model.contextLimit) {
    return {
      valid: false,
      error: `Token count (${adjustedTokens.toFixed(0)}) exceeds model's context limit (${model.contextLimit})`,
      limit: model.contextLimit,
      current: adjustedTokens
    };
  }
  
  return {
    valid: true,
    limit: model.contextLimit,
    current: adjustedTokens,
    remaining: model.contextLimit - adjustedTokens
  };
}

// Example usage
const validation = validateContextLength('claude-3.5-sonnet', 150000);
if (!validation.valid) {
  console.error(validation.error);
}

function compareModelCosts(inputTokens, outputTokens, modelIds) {
  return modelIds.map(modelId => {
    const model = MODELS_DATA[modelId];
    const cost = calculateCost(modelId, inputTokens, outputTokens);
    
    return {
      modelId,
      name: model.name,
      company: model.company,
      cost: cost.total,
      contextFit: inputTokens + outputTokens <= model.contextLimit
    };
  }).sort((a, b) => a.cost - b.cost);
}

// Example: Find cheapest model for a specific workload
const comparison = compareModelCosts(100000, 20000, [
  'gpt-4o',
  'claude-3.5-sonnet',
  'gemini-1.5-pro',
  'llama-3.1-70b'
]);

console.table(comparison);