AI System Disaster Recovery

/**
 * Multi-provider LLM failover.
 *
 * Automatically routes requests to a backup LLM provider
 * when the primary provider is unavailable or degraded.
 */

interface ProviderConfig {
  name: string;
  model: string;
  endpoint: string;
  apiKey: string;
  priority: number;     // Lower = higher priority
  healthCheckUrl: string;
  maxLatencyMs: number;
}

interface FailoverState {
  currentProvider: string;
  failoverActive: boolean;
  failoverStartedAt: number | null;
  consecutiveFailures: Map<string, number>;
}

class LLMFailoverRouter {
  private state: FailoverState;
  private readonly failureThreshold = 3;
  private readonly recoveryCheckIntervalMs = 30000; // 30 sec

  constructor(
    private readonly providers: ProviderConfig[],
  ) {
    this.providers.sort((a, b) => a.priority - b.priority);
    this.state = {
      currentProvider: providers[0].name,
      failoverActive: false,
      failoverStartedAt: null,
      consecutiveFailures: new Map(),
    };
  }

  async route(
    request: { prompt: string; maxTokens: number },
  ): Promise<{ response: string; provider: string }> {
    // Try providers in priority order
    for (const provider of this.providers) {
      try {
        const response = await this.callProvider(
          provider, request,
        );
        // Reset failure count on success
        this.state.consecutiveFailures.set(
          provider.name, 0,
        );
        return { response, provider: provider.name };
      } catch (error) {
        this.recordFailure(provider.name);
        // Try next provider
        continue;
      }
    }

    // All providers failed -- serve cached response if available
    throw new Error(
      "All LLM providers unavailable. "
      + "Activate cached response serving.",
    );
  }

  private recordFailure(providerName: string): void {
    const current =
      this.state.consecutiveFailures.get(providerName) || 0;
    this.state.consecutiveFailures.set(
      providerName, current + 1,
    );

    if (current + 1 >= this.failureThreshold) {
      console.warn(
        `Provider ${providerName} marked unhealthy after `
        + `${current + 1} consecutive failures`,
      );
    }
  }

  private async callProvider(
    provider: ProviderConfig,
    request: { prompt: string; maxTokens: number },
  ): Promise<string> {
    // Check if provider is healthy
    const failures =
      this.state.consecutiveFailures.get(provider.name) || 0;
    if (failures >= this.failureThreshold) {
      throw new Error(
        `Provider ${provider.name} is unhealthy`,
      );
    }

    // Implement actual API call here
    // This is a placeholder for the provider-specific logic
    const response = await fetch(provider.endpoint, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        Authorization: `Bearer ${provider.apiKey}`,
      },
      body: JSON.stringify(request),
      signal: AbortSignal.timeout(provider.maxLatencyMs),
    });

    if (!response.ok) {
      throw new Error(`Provider returned ${response.status}`);
    }

    const data = await response.json();
    return data.content || data.choices?.[0]?.message?.content;
  }
}