*   **Step 2: Implement Circuit Breaker Logic**
    *   Create a `CircuitBreaker` class to track consecutive failures and manage the circuit state:
    ```python
class CircuitBreaker:
    def __init__(self, failure_threshold, cooldown_minutes):
        self.failure_threshold = failure_threshold
        self.cooldown_minutes = cooldown_minutes
        self.failure_count = 0
        self.circuit_open = False
        self.cooldown_expires = None

    def is_circuit_open(self):
        return self.circuit_open

    def increment_failure_count(self):
        self.failure_count += 1
        if self.failure_count >= self.failure_threshold:
            self.open_circuit()

    def open_circuit(self):
        self.circuit_open = True
        self.cooldown_expires = datetime.now() + timedelta(minutes=self.cooldown_minutes)

    def reset(self):
        self.failure_count = 0
        self.circuit_open = False
        self.cooldown_expires = None

    def update(self):
        if self.circuit_open and datetime.now() > self.cooldown_expires:
            self.reset()
    ```
*   **Step 3: Integrate with Existing Code**
    *   Modify the `runWithModelFallback` function to check the circuit breaker state before making API calls:
    ```python
def runWithModelFallback(model, ...):
    circuit_breaker = CircuitBreaker(failure_threshold=3, cooldown_minutes=1440)
    if circuit_breaker.is_circuit_open():
        # Fallback to next model or return error
        return fallback_model(...)
    try:
        # Make API call
        response = make_api_call(model)
        circuit_breaker.reset()
        return response
    except Exception as e:
        circuit_breaker.increment_failure_count()
        circuit_breaker.update()
        # Fallback to next model or return error
        return fallback_model(...)
    ```
*   **Step 4: Add Error Classification and Metrics**
    *   Implement error classification to map errors to reasons (e.g., rate limit, overloaded, auth, network, timeout, etc.)
    *   Add metrics/logging for circuit state changes to monitor the effectiveness of the circuit breaker

### Verification
To verify that the fix worked:

*   Test the circuit breaker with a failing API endpoint and verify that it opens the circuit after the specified number of failures
*   Verify that the circuit breaker resets after a successful API call
*   Test