Model Registry

import { ModelRegistry } from '@/models/ModelRegistry';

const WhisperModelPicker = () => {
  const whisperModels = ModelRegistry.getWhisperModels();
  
  return (
    <Select>
      {Object.entries(whisperModels).map(([id, model]) => (
        <SelectItem key={id} value={id}>
          <div>
            <span>{model.name}</span>
            <span className="text-xs text-muted">{model.size}</span>
            {model.recommended && <Badge>Recommended</Badge>}
          </div>
        </SelectItem>
      ))}
    </Select>
  );
};

const { whisperModels } = require('../models/modelRegistryData.json');

async downloadModel(modelName) {
  const model = whisperModels[modelName];
  if (!model) throw new Error(`Unknown model: ${modelName}`);
  
  const modelPath = path.join(this.modelDir, model.fileName);
  
  // Download with progress tracking
  await this.downloadFile(
    model.downloadUrl,
    modelPath,
    model.expectedSizeBytes
  );
  
  // Verify file size
  const actualSize = fs.statSync(modelPath).size;
  if (actualSize !== model.expectedSizeBytes) {
    throw new Error('Download corrupted');
  }
}

const { localProviders } = require('../models/modelRegistryData.json');

function getDownloadUrl(providerId, modelId) {
  const provider = localProviders.find(p => p.id === providerId);
  const model = provider.models.find(m => m.id === modelId);
  
  // Construct HuggingFace URL
  return `${provider.baseUrl}/${model.hfRepo}/resolve/main/${model.fileName}`;
}

// Example output:
// https://huggingface.co/Qwen/Qwen3-8B-GGUF/resolve/main/Qwen3-8B-Q4_K_M.gguf

const provider = localProviders.find(p => p.id === 'qwen');
const promptTemplate = provider.promptTemplate;

// Template: "<|im_start|>system\n{system}<|im_end|>\n..."
const formattedPrompt = promptTemplate
  .replace('{system}', systemMessage)
  .replace('{user}', userMessage);

// Result:
// <|im_start|>system
// You are a helpful assistant.
// <|im_end|>
// <|im_start|>user
// What is 2+2?
// <|im_end|>
// <|im_start|>assistant

// src/helpers/whisper.js
class WhisperManager {
  async downloadModel(modelName, onProgress) {
    const model = whisperModels[modelName];
    const modelPath = path.join(this.modelDir, model.fileName);
    
    // Check if already downloaded
    if (fs.existsSync(modelPath)) {
      const size = fs.statSync(modelPath).size;
      if (size === model.expectedSizeBytes) {
        return { success: true, path: modelPath };
      }
    }
    
    // Download with retry
    const response = await fetch(model.downloadUrl);
    const total = parseInt(response.headers.get('content-length'));
    
    const fileStream = fs.createWriteStream(modelPath);
    const reader = response.body.getReader();
    let downloaded = 0;
    
    while (true) {
      const { done, value } = await reader.read();
      if (done) break;
      
      fileStream.write(value);
      downloaded += value.length;
      
      // Notify renderer
      onProgress({
        downloaded,
        total,
        percent: (downloaded / total) * 100
      });
    }
    
    fileStream.close();
    return { success: true, path: modelPath };
  }
}

// src/helpers/modelManagerBridge.js
class ModelManager {
  async download(modelId, onProgress) {
    const { provider, model } = this.findModel(modelId);
    const url = `${provider.baseUrl}/${model.hfRepo}/resolve/main/${model.fileName}`;
    const destPath = path.join(this.modelDir, model.fileName);
    
    // Use custom download utility with resume support
    await downloadWithResume(url, destPath, {
      expectedSize: model.sizeBytes,
      onProgress: (downloaded, total) => {
        onProgress({ modelId, downloaded, total });
      },
      onError: (error) => {
        fs.unlinkSync(destPath); // Cleanup partial download
        throw error;
      }
    });
  }
}

checkModelStatus(modelName) {
  const model = whisperModels[modelName];
  const modelPath = path.join(this.modelDir, model.fileName);
  
  if (!fs.existsSync(modelPath)) {
    return { downloaded: false, size: 0 };
  }
  
  const actualSize = fs.statSync(modelPath).size;
  const isValid = actualSize === model.expectedSizeBytes;
  
  return {
    downloaded: true,
    size: actualSize,
    valid: isValid,
    path: modelPath
  };
}

import modelData from './modelRegistryData.json';

export class ModelRegistry {
  static getWhisperModels() {
    return modelData.whisperModels;
  }
  
  static getParakeetModels() {
    return modelData.parakeetModels;
  }
  
  static getLocalProviders() {
    return modelData.localProviders;
  }
  
  static getCloudProviders() {
    return modelData.cloudProviders;
  }
  
  static findLocalModel(modelId: string) {
    for (const provider of modelData.localProviders) {
      const model = provider.models.find(m => m.id === modelId);
      if (model) return { provider, model };
    }
    return null;
  }
  
  static getPromptTemplate(providerId: string) {
    const provider = modelData.localProviders.find(p => p.id === providerId);
    return provider?.promptTemplate || '';
  }
}

// modelRegistryData.json
"base": {
  "descriptionKey": "models.descriptions.whisper.base"
}

// src/locales/en/translation.json
{
  "models": {
    "descriptions": {
      "whisper": {
        "base": "Good balance"
      }
    }
  }
}

// Component usage
import { useTranslation } from 'react-i18next';

const { t } = useTranslation();
const description = model.descriptionKey 
  ? t(model.descriptionKey) 
  : model.description;