Table of Contents

Coverage Service

Check AI model availability across Civitai infrastructure before submitting jobs.

Check Single Model

var checkpointModel = new AirIdentifier(
    AirEcosystem.StableDiffusionXl,
    AirAssetType.Checkpoint,
    AirSource.Civitai,
    modelId: 4201,
    versionId: 130072);

var checkpointModelFromBuilder = new AirBuilder()
    .WithEcosystem(AirEcosystem.StableDiffusionXl)
    .WithAssetType(AirAssetType.Checkpoint)
    .WithSource(AirSource.Civitai)
    .WithModelId(4201)
    .WithVersionId(130072)
    .Build();

var coverageResult = await sdkClient.Coverage.GetAsync(checkpointModel, cancellationToken);

if (coverageResult is Result<ProviderAssetAvailability>.Success coverageSuccess)
{
    Console.WriteLine($"Availability: {coverageSuccess.Data.Availability}");
    Console.WriteLine($"Workers: {coverageSuccess.Data.Workers}");
    
    if (coverageSuccess.Data.Availability == AvailabilityStatus.Available)
    {
        Console.WriteLine($"Model is available with {coverageSuccess.Data.Workers} workers");
    }
}

Check Multiple Models

var checkpointModelBatch = new AirIdentifier(
    AirEcosystem.StableDiffusionXl,
    AirAssetType.Checkpoint,
    AirSource.Civitai,
    modelId: 4201,
    versionId: 130072);

var loraModel = new AirIdentifier(
    AirEcosystem.StableDiffusionXl,
    AirAssetType.Lora,
    AirSource.Civitai,
    modelId: 328553,
    versionId: 368189);

var vaeModel = new AirIdentifier(
    AirEcosystem.StableDiffusion1,
    AirAssetType.Vae,
    AirSource.Civitai,
    modelId: 22354,
    versionId: 123456);

AirIdentifier[] modelsToCheck = [checkpointModelBatch, loraModel, vaeModel];

var batchCoverageResult = await sdkClient.Coverage.GetAsync(modelsToCheck, cancellationToken);

if (batchCoverageResult is Result<IReadOnlyDictionary<AirIdentifier, ProviderAssetAvailability>>.Success batchSuccess)
{
    foreach (var (modelIdentifier, availability) in batchSuccess.Data)
    {
        Console.WriteLine($"{modelIdentifier}: {availability.Availability} (Workers: {availability.Workers})");
    }
}

Result Properties

ProviderAssetAvailability:

  • Availability - Status (Available, Unavailable, Degraded)
  • Workers - Worker count (0 = unavailable)

AvailabilityStatus:

  • Available - Ready for generation
  • Unavailable - Not available
  • Degraded - Limited capacity

JobSupport:

  • Unsupported - Provider doesn't support model
  • Unavailable - Temporarily unavailable
  • Available - Ready to process

Availability Checking

// Check if a model is available and get status
var availabilityModel = new AirIdentifier(
    AirEcosystem.StableDiffusionXl,
    AirAssetType.Checkpoint,
    AirSource.Civitai,
    modelId: 4201,
    versionId: 130072);

var availabilityResult = await sdkClient.Coverage.GetAsync(availabilityModel);

if (availabilityResult is Result<ProviderAssetAvailability>.Success availabilitySuccess)
{
    var status = availabilitySuccess.Data.Availability;
    
    switch (status)
    {
        case AvailabilityStatus.Available:
            Console.WriteLine($"Model is ready ({availabilitySuccess.Data.Workers} workers)");
            break;
        case AvailabilityStatus.Unavailable:
            Console.WriteLine("Model is not available");
            break;
        default:
            Console.WriteLine($"Model status: {status}");
            break;
    }
}

Error Handling

var errorHandlingModel = new AirIdentifier(
    AirEcosystem.StableDiffusionXl,
    AirAssetType.Checkpoint,
    AirSource.Civitai,
    modelId: 4201,
    versionId: 130072);

var errorResult = await sdkClient.Coverage.GetAsync(errorHandlingModel);

switch (errorResult)
{
    case Result<ProviderAssetAvailability>.Success success:
        if (success.Data.Availability == AvailabilityStatus.Available)
        {
            Console.WriteLine($"Model is available ({success.Data.Workers} workers)");
        }
        else
        {
            Console.WriteLine($"Model status: {success.Data.Availability}");
        }
        break;
        
    case Result<ProviderAssetAvailability>.Failure failure:
        Console.WriteLine($"Error: {failure.Error.Message}");
        // Proceed anyway - coverage check is optional
        break;
}

Best Practices

  • Cache coverage results
  • Batch checks when possible
  • Make coverage checks optional
  • Use for resource discovery

Next Steps

Edit this page