Civitai Model Management

import { CivitAIService, createCivitAIService } from '@oshun/civitai-service';

const service = createCivitAIService({
  apiKey: process.env.CIVITAI_API_KEY,
  rateLimitBuffer: 60, // requests per minute
  cacheTtl: 300, // cache TTL in seconds
  maxConcurrentDownloads: 3,
  enableCache: true,
  nsfwEnabled: true,
  contentLevel: 'R', // PG, PG13, R, X, XXX
});

interface CivitAIConfig {
  apiKey: string;
  baseUrl?: string; // default: 'https://civitai.com/api/v1'
  rateLimitBuffer?: number; // default: 60
  cacheTtl?: number; // default: 300
  retryAttempts?: number; // default: 3
  retryBaseDelay?: number; // default: 1000
  enableCache?: boolean; // default: true
  maxConcurrentDownloads?: number; // default: 3
  nsfwEnabled?: boolean; // default: true
  contentLevel?: ContentLevel; // default: 'R'
}

const response = await service.listModels({
  query: 'portrait', // search query
  types: ['Checkpoint'], // model types
  sort: 'Highest Rated', // sort order
  page: 1,
  limit: 20,
  nsfw: false,
});

for (const model of response.items) {
  console.log(`${model.name} (${model.type})`);
  console.log(`Creator: ${model.creator.username}`);
  console.log(`Downloads: ${model.stats.downloadCount}`);
  console.log(`Rating: ${model.stats.rating}/5`);
}

type ModelType =
  | 'Checkpoint'
  | 'TextualInversion'
  | 'Hypernetwork'
  | 'AestheticGradient'
  | 'LORA'
  | 'Controlnet'
  | 'Poses';

// Get model by ID
const model = await service.getModel(133005);

console.log('Model:', model.name);
console.log('Description:', model.description);
console.log('Tags:', model.tags);
console.log('NSFW:', model.nsfw);
console.log('Commercial Use:', model.allowCommercialUse);

// List versions
for (const version of model.modelVersions) {
  console.log(`Version: ${version.name}`);
  console.log(`Base Model: ${version.baseModel}`);
  console.log(`Trained Words: ${version.trainedWords.join(', ')}`);
}

// Useful for identifying models by file hash
const version = await service.getModelVersionByHash(
  'abc123def456...' // SHA256 hash
);

console.log('Model:', version.model.name);
console.log('Version:', version.name);

const creators = await service.listCreators({
  query: 'artist',
  limit: 20,
});

for (const creator of creators.items) {
  console.log(`Username: ${creator.username}`);
}

const tags = await service.listTags({
  query: 'style',
  limit: 50,
});

for (const tag of tags.items) {
  console.log(`${tag.name}: ${tag.modelCount} models`);
}

// Queue a download
const downloadId = service.queueDownload({
  modelVersionId: 348913,
  destinationPath: '/models/checkpoints/',
  customFilename: 'juggernaut-xl.safetensors',
  priority: 'normal',
  verifyHash: true,
  hashAlgorithm: 'SHA256',
  onProgress: (progress) => {
    console.log(`${progress.percentage}% - ${progress.speedBps / 1024} KB/s`);
  },
});

console.log('Download queued:', downloadId);

// Get single download progress
const progress = service.getDownloadProgress(downloadId);

if (progress) {
  console.log(`Status: ${progress.status}`);
  console.log(`Progress: ${progress.percentage}%`);
  console.log(
    `Downloaded: ${progress.downloadedBytes} / ${progress.totalBytes}`
  );
  console.log(`Speed: ${progress.speedBps / 1024} KB/s`);
  console.log(`ETA: ${progress.etaSeconds} seconds`);
}

// Get all downloads
const allDownloads = service.getAllDownloads();
for (const download of allDownloads) {
  console.log(
    `${download.id}: ${download.status} - ${download.progress.percentage}%`
  );
}

// Get queue statistics
const stats = service.getDownloadStats();
console.log(`Total: ${stats.totalItems}`);
console.log(`Queued: ${stats.queued}`);
console.log(`Downloading: ${stats.downloading}`);
console.log(`Completed: ${stats.completed}`);
console.log(`Failed: ${stats.failed}`);

// Pause download
service.pauseDownload(downloadId);

// Resume download
service.resumeDownload(downloadId);

// Cancel download
service.cancelDownload(downloadId);

queued → downloading → completed
                    → failed
         paused ↔ queued
         cancelled

// Check rate limit state
const rateLimitState = service.getRateLimitState();

console.log(`Remaining: ${rateLimitState.remaining}/${rateLimitState.limit}`);
console.log(`Reset at: ${rateLimitState.resetAt}`);
console.log(`Is limited: ${rateLimitState.isLimited}`);

if (rateLimitState.isLimited) {
  console.log(`Retry after: ${rateLimitState.retryAfter} seconds`);
}

closed → (failures exceed threshold) → open
  ↑                                      ↓
  └──────── (success threshold met) ← half_open
                                         ↑
                        (timeout elapsed) ┘

const circuitState = service.getCircuitBreakerState();

console.log(`State: ${circuitState.state}`);
console.log(`Failures: ${circuitState.failures}`);
console.log(`Successes: ${circuitState.successes}`);

if (circuitState.state === 'open') {
  console.log(`Opened at: ${circuitState.openedAt}`);
}

// Cache is enabled by default
const service = createCivitAIService({
  apiKey: process.env.CIVITAI_API_KEY,
  enableCache: true,
  cacheTtl: 300, // 5 minutes
});

// Check cache statistics
const cacheStats = service.getCacheStats();
console.log(`Size: ${cacheStats.size}`);
console.log(`Hits: ${cacheStats.hits}`);
console.log(`Misses: ${cacheStats.misses}`);
console.log(
  `Hit Rate: ${(cacheStats.hits / (cacheStats.hits + cacheStats.misses)) * 100}%`
);

// Clear cache
service.clearCache();

// Force fresh request
const model = await service.request('/models/133005', {
  useCache: false,
});

const service = createCivitAIService({
  apiKey: process.env.CIVITAI_API_KEY,
  nsfwEnabled: true,
  contentLevel: 'R',
});

// Check if content is allowed
const isAllowed = service.isContentLevelAllowed('PG13');
console.log('PG13 allowed:', isAllowed);

// Subscribe to events
service.on('request_complete', (event) => {
  console.log(
    `${event.data.method} ${event.data.endpoint} - ${event.data.duration}ms`
  );
});

service.on('rate_limited', (event) => {
  console.warn(`Rate limited! Wait ${event.data.waitTime}ms`);
});

service.on('circuit_open', (event) => {
  console.error(`Circuit breaker opened for ${event.data.endpoint}`);
});

// Unsubscribe
const listener = (event) => console.log(event);
service.on('cache_hit', listener);
service.off('cache_hit', listener);

const analytics = service.getAnalytics();

console.log(`Total Requests: ${analytics.totalRequests}`);
console.log(`Successful: ${analytics.successfulRequests}`);
console.log(`Failed: ${analytics.failedRequests}`);
console.log(`Rate Limited: ${analytics.rateLimitedRequests}`);
console.log(`Avg Response Time: ${analytics.averageResponseTimeMs}ms`);

// Per-endpoint counts
for (const [endpoint, count] of Object.entries(analytics.endpointCounts)) {
  console.log(`${endpoint}: ${count} requests`);
}

// Error distribution
for (const [code, count] of Object.entries(analytics.errorCounts)) {
  console.log(`${code}: ${count} errors`);
}

// Reset analytics
service.resetAnalytics();

import { CivitaiLinkProvider } from '@oshun/civitai-link';

const link = new CivitaiLinkProvider({
  endpoint: process.env.CIVITAI_LINK_ENDPOINT,
  apiKey: process.env.CIVITAI_LINK_KEY,
  autoReconnect: true,
  reconnectDelay: 5000,
  heartbeatInterval: 30000,
});

await link.connect();

// Swap to a different model
await link.swapModel({
  modelVersionId: 348913,
  slot: 'checkpoint',
  priority: 'high',
});

// Check memory stats
const memory = await link.getMemoryStats();
console.log(`VRAM Used: ${memory.vramUsed / 1024 / 1024} MB`);
console.log(`VRAM Free: ${memory.vramFree / 1024 / 1024} MB`);
console.log(`RAM Used: ${memory.ramUsed / 1024 / 1024} MB`);

// Queue download with priority
link.queueDownload({
  modelVersionId: 348913,
  priority: 'high',
  onProgress: (progress) => {
    console.log(`${progress.filename}: ${progress.percentage}%`);
  },
});

// Get queue status
const queue = link.getDownloadQueue();
for (const item of queue) {
  console.log(`${item.id}: ${item.status}`);
}

// Enable predictive loading based on usage patterns
link.enablePredictiveLoading({
  analyzeUsagePatterns: true,
  preloadThreshold: 0.7, // 70% confidence
});

// Get preload recommendations
const recommendations = await link.getPreloadRecommendations();
for (const rec of recommendations) {
  console.log(`Recommend preloading: ${rec.modelName}`);
  console.log(`Usage frequency: ${rec.usageFrequency}`);
  console.log(`Confidence: ${rec.confidence}`);
}

// Analyze storage usage
const analysis = await link.analyzeStorage();

console.log(`Total models: ${analysis.totalModels}`);
console.log(`Total size: ${analysis.totalSize / 1024 / 1024 / 1024} GB`);
console.log(`Duplicates: ${analysis.duplicates.length}`);

// Get cleanup suggestions
const suggestions = await link.getCleanupSuggestions();
for (const suggestion of suggestions) {
  console.log(`Suggest removing: ${suggestion.modelName}`);
  console.log(`Reason: ${suggestion.reason}`);
  console.log(`Space savings: ${suggestion.sizeSaved / 1024 / 1024} MB`);
}

// Execute cleanup
await link.executeCleanup(suggestions.map((s) => s.modelVersionId));