Correctover v1.1.0: 100 Public APIs, CircuitBreaker, and Benchmark Subpackage

Correctover v1.1.0 is Live

After months of production hardening, Correctover v1.1.0 is now available on PyPI. This release represents a significant expansion of the SDK's surface area while keeping the dependency footprint minimal.

pip install correctover==1.1.0

What Changed

From 1.0.1 to 1.1.0

Metric	v1.0.1	v1.1.0
Modules	12	37 + benchmark subpackage
Public API	28	100
Dependencies	6	2 (httpx + aiohttp)
Package Size	420 KB	308 KB
License	Apache-2.0 w/ restriction	Proprietary Commercial

CircuitBreaker

The most requested feature is here. The CircuitBreaker module implements the circuit breaker pattern specifically for LLM API calls:

from correctover import CircuitBreaker, CorrectoverEngine

breaker = CircuitBreaker(
    failure_threshold=5,
    recovery_timeout=30,
    half_open_max_calls=3
)

engine = CorrectoverEngine(
    providers=["openai", "deepseek", "anthropic"],
    circuit_breaker=breaker
)

result = engine.run("Analyze this sentiment")

When a provider starts failing, the circuit breaker opens — preventing wasted API calls to a degraded endpoint. After the recovery timeout, it enters half-open state and cautiously tests the provider before fully closing the circuit again.

This is different from simple retry logic. Retry tries again immediately. CircuitBreaker stops trying until there's evidence the provider has recovered. Combined with Correctover's 6-dimension contract validation, you get:

CircuitBreaker stops calling degraded providers
Failover routes to the next healthy provider
Contract validation verifies the response from the new provider
Self-healing rules handle edge cases (84 rules (62 high-confidence))

Benchmark Subpackage

Built-in performance benchmarking so you can measure Correctover's overhead in your own environment:

from correctover.benchmark import BenchmarkRunner

runner = BenchmarkRunner(
    providers=["openai", "anthropic", "deepseek"],
    iterations=1000
)

report = runner.run()
print(report.summary())
# CANON validation P50: 22µs
# MAPE-K decision P50: 78µs
# L3 failover E2E: 949ms

No more guessing. Run the benchmarks yourself and verify that the overhead is truly negligible.

Streamlined Dependencies

We cut dependencies from 6 to just 2: httpx for synchronous HTTP and aiohttp for async. This means:

Faster installs
Fewer supply chain risks
Smaller Docker images
No transitive dependency conflicts

100 Public API Exports

The full public surface now includes:

run() — One-call entry point
CorrectoverEngine — Main orchestration class
CircuitBreaker — Circuit breaker pattern
SelfHealingEngine — 84 self-healing rules
ContractValidator — 6-dimension validation
DriftDetector — Real-time model degradation detection
BenchmarkRunner — Performance benchmarking
...and 93 more

The Architecture: Why These Pieces Fit Together

Most LLM reliability tools give you one piece: retry logic, or load balancing, or monitoring. Correctover's value comes from how these pieces work together in a closed loop:

Request → Contract Validation → Response
              ↓ (failure)
         CircuitBreaker opens
              ↓
         Failover to next provider
              ↓
         Contract Validation (again)
              ↓ (still failing?)
         Self-Healing Rules (84 patterns)
              ↓
         MAPE-K Loop: detect → verify → heal → guarantee

Each layer catches what the previous layer missed. The circuit breaker prevents hammering dead endpoints. Contract validation catches silent failures. Self-healing rules handle the edge cases that simple retry can't.

BYOK: Your Keys, Your Providers

Nothing has changed about our core principle: we never proxy, resell, or intermediate your API keys. Your calls go directly from your infrastructure to OpenAI, Anthropic, DeepSeek, or any of our 7 supported providers. Correctover sits in your code, not in your network path.

This is the #1 question we get from enterprise teams: "Do you see our API keys?" The answer is and will remain: No.