Provider Integration

public interface IChatProvider
{
    Task<ChatResponse> ChatCompletionAsync(ChatRequest request);
    Task ChatCompletionStreamAsync(ChatRequest request, Func<string, Task> onChunk);
    string ProviderName { get; }
}

public class ChatProviderFactory
{
    public IChatProvider GetProvider(string providerName)
    {
        return providerName.ToLower() switch {
            "groq" => _serviceProvider.GetRequiredService<GroqProvider>(),
            "bytez" => _serviceProvider.GetRequiredService<BytezProvider>(),
            _ => throw new ArgumentException($"Unknown provider: {providerName}")
        };
    }
}

llama-*     → Groq
mixtral-*   → Groq
gemma-*     → Groq
Others      → Bytez

private readonly HttpClient _httpClient;
private const string BaseUrl = "https://api.groq.com/openai/v1";
private readonly string _apiKey;

public GroqProvider(IConfiguration config)
{
    _apiKey = config["GROQ_API_KEY"];
    _httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {_apiKey}");
}

public async Task<ChatResponse> ChatCompletionAsync(ChatRequest request)
{
    var payload = new {
        model = request.Model,
        messages = new[] {
            new { role = "system", content = request.SystemMessage ?? "You are a helpful assistant." },
            new { role = "user", content = request.Prompt }
        },
        temperature = request.Temperature ?? 0.7,
        max_tokens = request.MaxTokens,
        stream = false
    };
    
    var cts = new CancellationTokenSource(TimeSpan.FromSeconds(45));
    
    var response = await _httpClient.PostAsJsonAsync(
        $"{BaseUrl}/chat/completions",
        payload,
        cts.Token
    );
    
    response.EnsureSuccessStatusCode();
    
    var result = await response.Content.ReadFromJsonAsync<GroqResponse>();
    
    return new ChatResponse {
        Message = result.Choices[0].Message.Content,
        Usage = result.Usage,
        ResponseTimeMs = (int)(DateTime.UtcNow - startTime).TotalMilliseconds
    };
}

public async Task ChatCompletionStreamAsync(
    ChatRequest request,
    Func<string, Task> onChunk,
    CancellationToken cancellationToken)
{
    var payload = new { /* same as above but stream = true */ };
    
    var httpRequest = new HttpRequestMessage(HttpMethod.Post, $"{BaseUrl}/chat/completions") {
        Content = JsonContent.Create(payload)
    };
    
    using var response = await _httpClient.SendAsync(
        httpRequest,
        HttpCompletionOption.ResponseHeadersRead,
        cancellationToken
    );
    
    using var stream = await response.Content.ReadAsStreamAsync();
    using var reader = new StreamReader(stream);
    
    while (!reader.EndOfStream && !cancellationToken.IsCancellationRequested) {
        var line = await reader.ReadLineAsync();
        
        if (string.IsNullOrWhiteSpace(line) || !line.StartsWith("data: "))
            continue;
            
        var json = line.Substring(6); // Remove "data: " prefix
        
        if (json == "[DONE]")
            break;
            
        var chunk = JsonSerializer.Deserialize<GroqStreamChunk>(json);
        var delta = chunk.Choices[0]?.Delta?.Content;
        
        if (!string.IsNullOrEmpty(delta))
            await onChunk(delta);
    }
}

try {
    return await ChatCompletionAsync(request);
}
catch (TaskCanceledException) {
    throw new ProviderTimeoutException("Groq API timeout after 45 seconds");
}
catch (HttpRequestException ex) when (ex.StatusCode == HttpStatusCode.TooManyRequests) {
    throw new ProviderRateLimitException("Groq rate limit exceeded");
}
catch (HttpRequestException ex) {
    throw new ProviderException($"Groq API error: {ex.Message}");
}

private const string BaseUrl = "https://api.bytez.com/v1";
private readonly string _apiKey;

public BytezProvider(IConfiguration config)
{
    _apiKey = config["BYTEZ_API_KEY"];
}

public async Task<ChatResponse> ExecuteWithFallbackAsync(ChatRequest request)
{
    // Attempt 1: Primary provider with selected model
    try {
        var provider = _providerFactory.GetProvider(request.Provider);
        return await provider.ChatCompletionAsync(request);
    }
    catch (ProviderException ex) {
        _logger.LogWarning($"Primary attempt failed: {ex.Message}");
    }
    
    // Attempt 2: Groq with fallback model
    try {
        request.Model = "llama-3.3-70b-versatile";
        var groqProvider = _providerFactory.GetProvider("groq");
        return await groqProvider.ChatCompletionAsync(request);
    }
    catch (ProviderException ex) {
        _logger.LogWarning($"Groq retry failed: {ex.Message}");
    }
    
    // Attempt 3: Bytez provider
    try {
        var bytezProvider = _providerFactory.GetProvider("bytez");
        return await bytezProvider.ChatCompletionAsync(request);
    }
    catch (ProviderException ex) {
        _logger.LogError($"All providers failed: {ex.Message}");
        throw new AllProvidersFailedException("All providers exhausted");
    }
}

var task1 = ExecuteWithFallbackAsync(new ChatRequest { Model = model1 });
var task2 = ExecuteWithFallbackAsync(new ChatRequest { Model = model2 });

await Task.WhenAll(task1, task2);

public async Task<AIModel> GetModelByNameAsync(string modelName)
{
    return await _supabaseClient
        .From<AIModel>()
        .Where(m => m.ModelName == modelName)
        .Single();
}

public class AIModel
{
    public Guid ModelId { get; set; }
    public string ModelName { get; set; }
    public string DisplayName { get; set; }
    public string ProviderName { get; set; }  // "groq" or "bytez"
    public string ApiUrl { get; set; }
    public string Status { get; set; }        // "active" or "inactive"
}

string provider = model.ModelName switch {
    var m when m.StartsWith("llama-") => "groq",
    var m when m.StartsWith("mixtral-") => "groq",
    var m when m.StartsWith("gemma-") => "groq",
    _ => "bytez"
};

string provider = model.ProviderName; // From ai_models.provider_name

_metrics.IncrementCounter("provider.success", tags: new[] { $"provider:{providerName}" });
_metrics.IncrementCounter("provider.failure", tags: new[] { $"provider:{providerName}" });

_metrics.IncrementCounter("provider.timeout", tags: new[] { $"provider:{providerName}" });

# Groq Configuration
GROQ_API_KEY=gsk_...
GROQ_API_URL=https://api.groq.com/openai/v1

# Bytez Configuration
BYTEZ_API_KEY=btz_...
BYTEZ_API_URL=https://api.bytez.com/v1

# Timeout Configuration
PROVIDER_TIMEOUT_SECONDS=45

services.AddHttpClient<GroqProvider>(client => {
    client.BaseAddress = new Uri(Configuration["GROQ_API_URL"]);
    client.Timeout = TimeSpan.FromSeconds(45);
    client.DefaultRequestHeaders.Add("User-Agent", "DualMind/1.0");
});

if (_groqCircuitBreaker.IsOpen) {
    // Skip Groq, go directly to Bytez
    return await _bytezProvider.ChatCompletionAsync(request);
}

var cacheKey = HashPrompt(request.Prompt + request.Model);
if (_cache.TryGetValue(cacheKey, out var cachedResponse))
    return cachedResponse;