Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.
Python agentagent-osaiai-agentsai-partnerchatopsclaudeclaude-codecodexdevtoolsdiscord-botlark-botllmlocal-firstlong-term-memoryopencodeslack-botvibe-codingvibeywechat
from __future__ import annotations
from vibe import tunnel_quality
def _sample(
now: float,
rtts: tuple[float, ...],
*,
connections: int = 4,
timeout_losses: tuple[tuple[str, float], ...] = (),
) -> tunnel_quality.MetricsSample:
return tunnel_quality.MetricsSample(
sampled_at=now,
ready=connections > 0,
ha_connections=connections,
edge_locations=("sin01", "sin02"),
smoothed_rtt_ms=rtts,
request_errors_total=0,
packet_loss_total=sum(value for _, value in timeout_losses),
closed_connections_total=0,
timeout_packet_loss_by_connection=timeout_losses,
)
def test_request_path_probe_rejects_redirects() -> None:
class RedirectResponse:
status_code = 302
def close(self) -> None:
pass
class RedirectSession:
def get(self, *args, **kwargs):
assert kwargs["allow_redirects"] is False
return RedirectResponse()
sample = tunnel_quality.probe_request_path(
RedirectSession(),
"https://example.avibe.bot/health",
attempts=1,
now=100,
)
assert sample.sampled_at == 100
assert sample.successes == (False,)
def test_ra_tq_001_parse_cloudflared_metrics_extracts_quality_inputs() -> None:
"""RA-TQ-001: Cloudflared metrics produce a bounded quality aggregate."""
sample = tunnel_quality.parse_metrics(
"""
# TYPE cloudflared_tunnel_ha_connections gauge
cloudflared_tunnel_ha_connections 4
# TYPE cloudflared_tunnel_request_errors counter
cloudflared_tunnel_request_errors 42
cloudflared_tunnel_server_locations{connection_id="0",edge_location="sin12"} 1
cloudflared_tunnel_server_locations{connection_id="1",edge_location="sin20"} 1
quic_client_smoothed_rtt{conn_index="0"} 67
quic_client_smoothed_rtt{conn_index="1"} 82
# TYPE quic_client_lost_packets counter
quic_client_lost_packets{conn_index="0",reason="timeout"} 3
quic_client_lost_packets{conn_index="1",reason="timeout"} 5
quic_client_lost_packets{conn_index="2",reason="reordering"} 100
# TYPE quic_client_closed_connections counter
quic_client_closed_connections 2
""",
now=100,
)
assert sample.ha_connections == 4
assert sample.edge_locations == ("sin12", "sin20")
assert sample.smoothed_rtt_ms == (67, 82)
assert sample.request_errors_total == 42
assert sample.packet_loss_total == 8
assert sample.timeout_packet_loss_by_connection == (("0", 3), ("1", 5))
assert sample.closed_connections_total == 2
def test_latency_grade_uses_median_and_worst_active_path() -> None:
assert tunnel_quality.latency_grade({"min": 60, "median": 119, "max": 249}) == "good"
assert tunnel_quality.latency_grade({"min": 60, "median": 120, "max": 249}) == "fair"
assert tunnel_quality.latency_grade({"min": 60, "median": 190, "max": 400}) == "poor"
assert tunnel_quality.latency_grade({"min": 60, "median": 349, "max": 700}) == "critical"
assert tunnel_quality.latency_grade(None) == "unknown"
def test_packet_loss_rate_requires_timeout_growth_on_two_connections() -> None:
evaluator = tunnel_quality.QualityEvaluator()
evaluator.update(_sample(100, (70, 75, 80, 85), timeout_losses=(("0", 0), ("1", 0))))
isolated = evaluator.update(_sample(160, (70, 75, 80, 85), timeout_losses=(("0", 12), ("1", 0))))
assert isolated["packet_loss_per_minute"] == 0
evaluator = tunnel_quality.QualityEvaluator()
evaluator.update(_sample(200, (70, 75, 80, 85), timeout_losses=(("0", 0), ("1", 0))))
distributed = evaluator.update(
_sample(260, (70, 75, 80, 85), timeout_losses=(("0", 6), ("1", 5)))
)
assert distributed["packet_loss_per_minute"] == 11
def test_ra_tq_002_high_rtt_requires_three_minutes_before_recovery() -> None:
"""RA-TQ-002: High RTT persists for three minutes before recovery eligibility."""
evaluator = tunnel_quality.QualityEvaluator()
now = 10_000.0
for minute in range(15):
snapshot = evaluator.update(_sample(now + minute * 60, (70, 75, 80, 85)))
assert snapshot["baseline_median_rtt_ms"] == 77.5
start = now + 15 * 60
for index in range(11):
snapshot = evaluator.update(_sample(start + index * 15, (210, 240, 260, 410)))
assert snapshot["state"] == "healthy"
snapshot = evaluator.update(_sample(start + 11 * 15, (210, 240, 260, 410)))
assert snapshot["state"] == "degraded"
assert snapshot["grade"] == "poor"
assert evaluator.recovery_trigger(snapshot) == "latency"
def test_zero_ready_connections_degrades_immediately() -> None:
evaluator = tunnel_quality.QualityEvaluator()
snapshot = evaluator.update(_sample(100, (), connections=0))
assert snapshot["state"] == "degraded"
assert evaluator.recovery_trigger(snapshot) == "availability"
def test_partial_availability_triggers_recovery_after_four_samples() -> None:
evaluator = tunnel_quality.QualityEvaluator()
for index in range(3):
snapshot = evaluator.update(_sample(100 + index * 15, (70, 75, 80), connections=3))
assert snapshot["state"] == "healthy"
snapshot = evaluator.update(_sample(145, (70, 75, 80), connections=3))
assert snapshot["state"] == "degraded"
assert evaluator.recovery_trigger(snapshot) == "availability"
def test_ra_tq_033_unavailable_request_path_is_an_availability_episode() -> None:
evaluator = tunnel_quality.QualityEvaluator()
# cloudflared still reports four ready connections while no request succeeds.
for index in range(12):
sampled_at = 100 + index * 15
snapshot = evaluator.update(
_sample(sampled_at, (70, 75, 80, 85)),
configured_protocol="auto",
effective_protocol="quic",
request_path_sample=tunnel_quality.RequestPathSample(
sampled_at=sampled_at,
latency_ms=(3500, 3500, 3500),
successes=(False, False, False),
),
)
assert snapshot["ha_connections"] == 4
assert snapshot["request_path"]["confidence"] == "high"
assert snapshot["request_path"]["status"] == "unavailable"
assert evaluator.recovery_trigger(snapshot) == "availability"
def test_ra_tq_003_metrics_failure_becomes_unknown_after_45_seconds() -> None:
"""RA-TQ-003: Missing metrics become unknown without causing route churn."""
evaluator = tunnel_quality.QualityEvaluator()
evaluator.update(_sample(100, (70, 75, 80, 85)))
assert evaluator.update(None, now=115)["state"] == "healthy"
assert evaluator.update(None, now=130)["state"] == "healthy"
assert evaluator.update(None, now=145)["state"] == "unknown"
def test_candidate_requires_material_absolute_and_relative_improvement() -> None:
active = {
"ha_connections": 4,
"rtt_ms": {"median": 250, "max": 420},
"request_errors_per_minute": 0,
"packet_loss_per_minute": 0,
}
better = {
"ha_connections": 4,
"rtt_ms": {"median": 180, "max": 260},
"request_errors_per_minute": 0,
"packet_loss_per_minute": 0,
}
marginal = {**better, "rtt_ms": {"median": 215, "max": 300}}
worse_tail = {**better, "rtt_ms": {"median": 180, "max": 430}}
with_errors = {**better, "request_errors_per_minute": 1}
assert tunnel_quality.candidate_is_better(active, better, trigger="latency") is True
assert tunnel_quality.candidate_is_better(active, marginal, trigger="latency") is False
assert tunnel_quality.candidate_is_better(active, worse_tail, trigger="latency") is False
assert tunnel_quality.candidate_is_better(active, with_errors, trigger="latency") is False
def test_error_candidate_requires_error_or_loss_improvement_not_rtt_improvement() -> None:
request_error_active = {
"ha_connections": 4,
"rtt_ms": {"median": 150, "max": 240},
"request_errors_per_minute": 3,
"packet_loss_per_minute": 0,
}
healthy_candidate = {
"ha_connections": 4,
"rtt_ms": {"median": 150, "max": 240},
"request_errors_per_minute": 0,
"packet_loss_per_minute": 0,
}
packet_loss_active = {**request_error_active, "request_errors_per_minute": 0, "packet_loss_per_minute": 10}
reduced_loss_candidate = {**healthy_candidate, "packet_loss_per_minute": 4}
worse_tail_candidate = {**healthy_candidate, "rtt_ms": {"median": 150, "max": 300}}
assert tunnel_quality.candidate_is_better(request_error_active, healthy_candidate, trigger="errors") is True
assert tunnel_quality.candidate_is_better(packet_loss_active, reduced_loss_candidate, trigger="errors") is True
assert tunnel_quality.candidate_is_better(packet_loss_active, packet_loss_active, trigger="errors") is False
assert tunnel_quality.candidate_is_better(request_error_active, worse_tail_candidate, trigger="errors") is False
def test_availability_candidate_restores_partial_connection_set_without_rtt() -> None:
active = {
"ha_connections": 3,
"rtt_ms": None,
"request_errors_per_minute": 0,
"packet_loss_per_minute": 0,
}
candidate = {**active, "ha_connections": 4}
assert tunnel_quality.candidate_is_better(active, candidate, trigger="availability") is True
def test_candidate_summary_requires_four_samples_and_keeps_worst_tail() -> None:
snapshots = [
{
"ha_connections": 4,
"rtt_ms": {"min": median - 20, "median": median, "max": maximum},
"request_errors_per_minute": errors,
"packet_loss_per_minute": loss,
}
for median, maximum, errors, loss in [
(100, 140, 0, 0),
(110, 150, 0, 1),
(120, 210, 0, 0),
(130, 170, 0, 0),
]
]
assert tunnel_quality.summarize_candidate_snapshots(snapshots[:3]) is None
summary = tunnel_quality.summarize_candidate_snapshots(snapshots)
assert summary is not None
assert summary["rtt_ms"] == {"min": 95.0, "median": 115.0, "max": 210.0}
assert summary["ha_connections"] == 4
assert summary["request_errors_per_minute"] == 0
assert summary["packet_loss_per_minute"] == 1
def test_baseline_state_round_trips_without_raw_samples() -> None:
evaluator = tunnel_quality.QualityEvaluator()
for minute in range(15):
evaluator.update(_sample(10_000 + minute * 60, (70, 75, 80, 85)))
restored = tunnel_quality.QualityEvaluator()
restored.load_state(evaluator.export_state(), now=10_000 + 15 * 60)
assert restored.baseline(10_000 + 15 * 60) == 77.5
def test_ra_tq_010_request_path_tail_overrides_good_connector_rtt() -> None:
"""RA-TQ-010: Request-path tails override a healthy connector RTT grade."""
evaluator = tunnel_quality.QualityEvaluator()
snapshot = None
for index in range(10):
sampled_at = 10_000 + index * 15
snapshot = evaluator.update(
_sample(sampled_at, (70, 75, 80, 85)),
configured_protocol="auto",
effective_protocol="quic",
request_path_sample=tunnel_quality.RequestPathSample(
sampled_at=sampled_at,
latency_ms=(120, 140, 1600),
successes=(True, True, True),
),
)
assert snapshot is not None
assert snapshot["schema_version"] == 2
assert snapshot["rtt_ms"]["median"] == 77.5
assert snapshot["request_path"]["confidence"] == "high"
assert snapshot["request_path"]["latency_ms"]["p95"] == 1600
assert snapshot["grade"] == "critical"
assert snapshot["state"] == "degraded"
assert evaluator.recovery_trigger(snapshot) == "tail_latency"
def test_request_path_twofold_baseline_regression_has_no_absolute_floor() -> None:
request_path = tunnel_quality.summarize_request_path_samples(
[
tunnel_quality.RequestPathSample(
sampled_at=1,
latency_ms=tuple([220.0] * 30),
successes=tuple([True] * 30),
)
],
baseline_p95_ms=100.0,
)
assert request_path is not None
assert request_path["latency_ms"]["p95"] == 220.0
assert request_path["status"] == "degraded"
def test_request_path_degradation_controls_state_when_connector_metrics_are_missing() -> None:
evaluator = tunnel_quality.QualityEvaluator()
snapshot = None
for index in range(10):
snapshot = evaluator.update(
None,
effective_protocol="quic",
request_path_sample=tunnel_quality.RequestPathSample(
sampled_at=1_000 + index * 15,
latency_ms=(120, 140, 1600),
successes=(True, True, True),
),
now=1_000 + index * 15,
)
assert snapshot is not None
assert snapshot["request_path"]["confidence"] == "high"
assert snapshot["request_path"]["status"] == "degraded"
assert snapshot["state"] == "degraded"
def test_ra_tq_015_sustained_request_failures_trigger_recovery() -> None:
"""RA-TQ-015: Sustained public request failures degrade the path and trigger recovery."""
evaluator = tunnel_quality.QualityEvaluator()
snapshot = None
for index in range(10):
sampled_at = 15_000 + index * 15
snapshot = evaluator.update(
_sample(sampled_at, (70, 75, 80, 85)),
configured_protocol="auto",
effective_protocol="quic",
request_path_sample=tunnel_quality.RequestPathSample(
sampled_at=sampled_at,
latency_ms=(80, 90, 100),
successes=(True, True, index % 3 != 0),
),
)
assert snapshot is not None
assert snapshot["request_path"]["confidence"] == "high"
assert snapshot["request_path"]["failure_rate"] >= 0.10
assert snapshot["request_path"]["status"] == "degraded"
assert snapshot["state"] == "degraded"
assert evaluator.recovery_trigger(snapshot) == "tail_latency"
def test_ra_tq_027_optimization_profiles_change_only_recovery_sensitivity() -> None:
"""RA-TQ-027: User optimization policies change recovery sensitivity without changing path measurements."""
evaluator = tunnel_quality.QualityEvaluator()
request_path = {
"status": "healthy",
"confidence": "high",
"success_count": 30,
"latency_ms": {"p50": 180, "p95": 560, "p99": 900, "max": 900},
"slow_request_rate": {
"over_500_ms": 0.25,
"over_1000_ms": 0.0,
"over_2000_ms": 0.0,
},
"failure_rate": 0.0,
"baseline_p95_ms": 400,
}
snapshot = {
"state": "healthy",
"ha_connections": 4,
"request_errors_per_minute": 0,
"packet_loss_per_minute": 0,
"request_path": request_path,
"rtt_ms": {"median": 100, "max": 150},
"baseline_median_rtt_ms": 90,
}
assert evaluator.recovery_trigger(snapshot, profile="low_latency") == "tail_latency"
assert evaluator.recovery_trigger(snapshot, profile="balanced") is None
assert evaluator.recovery_trigger(snapshot, profile="stable") is None
snapshot["state"] = "degraded"
request_path["latency_ms"] = {"p50": 200, "p95": 800, "p99": 1300, "max": 1300}
request_path["slow_request_rate"]["over_1000_ms"] = 0.06
assert evaluator.recovery_trigger(snapshot, profile="balanced") == "tail_latency"
assert evaluator.recovery_trigger(snapshot, profile="stable") is None
def test_ra_tq_011_http2_uses_request_path_grade_without_rtt() -> None:
"""RA-TQ-011: HTTP2 receives a request-path grade without QUIC RTT."""
evaluator = tunnel_quality.QualityEvaluator()
snapshot = None
for index in range(4):
sampled_at = 20_000 + index * 15
snapshot = evaluator.update(
_sample(sampled_at, (), connections=4),
configured_protocol="auto",
effective_protocol="http2",
request_path_sample=tunnel_quality.RequestPathSample(
sampled_at=sampled_at,
latency_ms=(180, 200, 220),
successes=(True, True, True),
),
)
assert snapshot is not None
assert snapshot["protocol"] == "http2"
assert snapshot["transport"] == {"configured": "auto", "effective": "http2"}
assert snapshot["rtt_ms"] is None
assert snapshot["request_path"]["confidence"] == "medium"
assert snapshot["grade"] == "good"
assert snapshot["state"] == "healthy"
def test_request_path_candidate_accepts_tail_improvement_despite_p50_regression() -> None:
active = tunnel_quality.summarize_request_path_samples(
[
tunnel_quality.RequestPathSample(
sampled_at=1,
latency_ms=tuple([100.0] * 93 + [324.0] * 5 + [1840.0] * 2),
successes=tuple([True] * 100),
)
]
)
candidate = tunnel_quality.summarize_request_path_samples(
[
tunnel_quality.RequestPathSample(
sampled_at=2,
latency_ms=tuple([170.0] * 93 + [386.0] * 5 + [621.0] * 2),
successes=tuple([True] * 100),
)
]
)
assert active is not None
assert candidate is not None
assert tunnel_quality.request_path_is_better(active, candidate) is True
def test_ra_tq_020_request_path_candidate_accepts_material_failure_reduction() -> None:
"""RA-TQ-020: Material request-failure reduction can accept a healthy candidate."""
active = tunnel_quality.summarize_request_path_samples(
[
tunnel_quality.RequestPathSample(
sampled_at=1,
latency_ms=tuple([100.0] * 100),
successes=tuple([True] * 90 + [False] * 10),
)
]
)
candidate = tunnel_quality.summarize_request_path_samples(
[
tunnel_quality.RequestPathSample(
sampled_at=2,
latency_ms=tuple([500.0] * 100),
successes=tuple([True] * 100),
)
]
)
assert active is not None
assert candidate is not None
assert tunnel_quality.request_path_is_better(active, candidate) is True
def test_unavailable_request_path_does_not_expose_latency_as_usable() -> None:
request_path = tunnel_quality.summarize_request_path_samples(
[
tunnel_quality.RequestPathSample(
sampled_at=1,
latency_ms=tuple([20.0] * 12),
successes=tuple([False] * 12),
)
]
)
assert request_path is not None
assert request_path["status"] == "unavailable"
assert tunnel_quality.request_path_has_usable_latency(request_path) is False