Skip to content

CubeLoop — a Pythonic, async-native agent harness core designed for high performance, readability, and production-grade persistence.

test(providers): cover remaining fallback and error-classifier branches

P.N. Beta3974f8a8f6c0
diff --git a/tests/providers/test_fallback.py b/tests/providers/test_fallback.py
index 1b36926..d66a17c 100644
--- a/tests/providers/test_fallback.py
+++ b/tests/providers/test_fallback.py
@@ -905,3 +905,213 @@ async def test_exhaustion_errors_are_one_per_leg() -> None:
with pytest.raises(ProviderUnavailable) as ei:
await fbm.generate(_messages())
assert len(ei.value.errors) == 2
+
+
+async def test_generate_skips_too_small_middle_leg() -> None:
+ err = ContextLengthExceeded(
+ "too long", provider="p", model="a", tokens_in=200_000, context_window=8_000
+ )
+ a = BoundModel(
+ provider=_RaisingProvider(err),
+ spec=Model(id="a", provider_id="p", context_window=8_000),
+ )
+ mid_p = _CountingRaiseProvider(
+ ContextLengthExceeded("mid", tokens_in=200_000, context_window=16_000),
+ fail_times=99,
+ provider_id="mid",
+ )
+ b = BoundModel(
+ provider=mid_p, spec=Model(id="b", provider_id="p", context_window=16_000)
+ )
+ big = _faux("big", "ok")
+ big = BoundModel(
+ provider=big.provider,
+ spec=Model(id="c", provider_id="big", context_window=400_000),
+ )
+ fbm = FallbackBoundModel(chain=(a, b, big), retry_backoff=0.0)
+ result = await fbm.generate(_messages())
+ assert mid_p.calls == 0
+ assert result.provider_id == "big"
+
+
+async def test_content_filtered_does_not_hop_unless_listed() -> None:
+ from cubepi.errors import ContentFiltered
+
+ err = ContentFiltered("blocked", provider="primary", model="m")
+ primary = _raising(err)
+ fallback = _faux("fallback", "ok")
+ fbm = FallbackBoundModel(chain=(primary, fallback))
+ with pytest.raises(ContentFiltered):
+ await fbm.stream(_messages())
+ assert fallback.provider.call_count == 0 # type: ignore[attr-defined]
+
+
+async def test_content_filtered_hops_when_opted_in() -> None:
+ from cubepi.errors import ContentFiltered
+
+ err = ContentFiltered("blocked", provider="primary", model="m")
+ primary = _raising(err)
+ fallback = _faux("fallback", "ok")
+ fbm = FallbackBoundModel(
+ chain=(primary, fallback),
+ trigger_errors=frozenset({ContentFiltered}),
+ )
+ stream = await fbm.stream(_messages())
+ result = await stream.result()
+ assert result.provider_id == "fallback"
+
+
+async def test_reset_active_and_index_helpers() -> None:
+ from cubepi.providers.fallback import (
+ begin_fallback_run,
+ end_fallback_run,
+ get_active_index,
+ reset_active,
+ set_active_index,
+ )
+
+ assert get_active_index() == 0
+ token = begin_fallback_run()
+ try:
+ set_active_index(2)
+ assert get_active_index() == 2
+ reset_active()
+ assert get_active_index() == 0
+ fbm = FallbackBoundModel(chain=(_faux("p", "hi"),))
+ fbm.reset_active()
+ assert get_active_index() == 0
+ finally:
+ end_fallback_run(token)
+
+
+def test_negative_retries_rejected() -> None:
+ with pytest.raises(ValueError, match="max_retries_per_model"):
+ FallbackBoundModel(chain=(_faux("p", "hi"),), max_retries_per_model=-1)
+
+
+async def test_on_retry_callback_exception_is_swallowed() -> None:
+ err = ProviderUnavailable("blip", provider="primary", model="m")
+ primary_p = _CountingRaiseProvider(err, fail_times=1, provider_id="primary")
+ primary = BoundModel(provider=primary_p, spec=Model(id="m", provider_id="primary"))
+
+ def _bad(failed, error, attempt, wait_s): # noqa: ANN001
+ raise RuntimeError("retry hook broken")
+
+ fbm = FallbackBoundModel(
+ chain=(primary,), on_retry=_bad, retry_backoff=0.0, max_retries_per_model=2
+ )
+ stream = await fbm.stream(_messages())
+ result = await stream.result()
+ assert result.content
+
+
+async def test_rate_limited_honors_retry_after_cap() -> None:
+ err = RateLimited("429", provider="primary", model="m", retry_after=30.0)
+ primary_p = _CountingRaiseProvider(err, fail_times=1, provider_id="primary")
+ primary = BoundModel(provider=primary_p, spec=Model(id="m", provider_id="primary"))
+ waits: list[float] = []
+
+ def _on_retry(failed, error, attempt, wait_s): # noqa: ANN001
+ waits.append(wait_s)
+
+ fbm = FallbackBoundModel(
+ chain=(primary,),
+ on_retry=_on_retry,
+ retry_backoff=0.0,
+ max_retry_after=0.0,
+ max_retries_per_model=1,
+ )
+ stream = await fbm.stream(_messages())
+ await stream.result()
+ assert waits == [0.0]
+
+
+def test_sticky_disabled_always_starts_at_zero() -> None:
+ fbm = FallbackBoundModel(chain=(_faux("p", "hi"),), sticky_within_run=False)
+ assert fbm._start_index() == 0
+
+
+async def test_async_on_retry_is_awaited() -> None:
+ seen: list[int] = []
+ err = ProviderUnavailable("blip", provider="primary", model="m")
+ primary_p = _CountingRaiseProvider(err, fail_times=1, provider_id="primary")
+ primary = BoundModel(provider=primary_p, spec=Model(id="m", provider_id="primary"))
+
+ async def _cb(failed, error, attempt, wait_s): # noqa: ANN001
+ seen.append(attempt)
+
+ fbm = FallbackBoundModel(
+ chain=(primary,), on_retry=_cb, retry_backoff=0.0, max_retries_per_model=2
+ )
+ await (await fbm.stream(_messages())).result()
+ assert seen == [1]
+
+
+def test_context_too_small_without_need_or_window() -> None:
+ from cubepi.providers.fallback import _context_too_small
+
+ bound = BoundModel(
+ provider=_RaisingProvider(ProviderUnavailable("x")),
+ spec=Model(id="m", provider_id="p", context_window=0),
+ )
+ assert (
+ _context_too_small(ContextLengthExceeded("long", tokens_in=10), bound) is False
+ )
+ bound2 = BoundModel(
+ provider=bound.provider,
+ spec=Model(id="m", provider_id="p", context_window=8_000),
+ )
+ assert (
+ _context_too_small(ContextLengthExceeded("long", tokens_in=None), bound2)
+ is False
+ )
+
+
+def test_start_index_clamps_out_of_range() -> None:
+ from cubepi.providers.fallback import (
+ begin_fallback_run,
+ end_fallback_run,
+ set_active_index,
+ )
+
+ fbm = FallbackBoundModel(chain=(_faux("p", "hi"),))
+ token = begin_fallback_run()
+ try:
+ set_active_index(99)
+ assert fbm._start_index() == 0
+ finally:
+ end_fallback_run(token)
+
+
+def test_stick_noop_when_disabled() -> None:
+ from cubepi.providers.fallback import begin_fallback_run, end_fallback_run
+
+ fbm = FallbackBoundModel(chain=(_faux("p", "hi"),), sticky_within_run=False)
+ token = begin_fallback_run()
+ try:
+ fbm._stick(1)
+ assert fbm._start_index() == 0
+ finally:
+ end_fallback_run(token)
+
+
+async def test_retry_sleeps_when_wait_positive() -> None:
+ err = RateLimited("429", provider="primary", model="m", retry_after=0.01)
+ primary_p = _CountingRaiseProvider(err, fail_times=1, provider_id="primary")
+ primary = BoundModel(provider=primary_p, spec=Model(id="m", provider_id="primary"))
+ fbm = FallbackBoundModel(
+ chain=(primary,),
+ retry_backoff=0.0,
+ max_retry_after=0.01,
+ max_retries_per_model=1,
+ )
+ await (await fbm.stream(_messages())).result()
+ assert primary_p.calls == 2
diff --git a/tests/test_errors.py b/tests/test_errors.py
index 2a0c893..26ea414 100644
--- a/tests/test_errors.py
+++ b/tests/test_errors.py
@@ -394,3 +394,105 @@ class TestErrorCodeExtraction:
with pytest.raises(ProviderBadRequest) as ei:
classify_and_raise(exc, model=_model())
assert not isinstance(ei.value, ModelNotFound)
+
+ def test_nested_error_object_and_attr_error(self) -> None:
+ from cubepi.errors import extract_error_code
+
+ nested = _FakeExc("x", status_code=400)
+ nested.error = {"error": {"code": "model_not_available"}}
+ assert extract_error_code(nested) == "model_not_available"
+
+ class _Obj:
+ code = None
+ type = "content_filter"
+ param = None
+
+ attr = _FakeExc("filtered", status_code=400)
+ attr.error = _Obj()
+ assert extract_error_code(attr) == "content_filter"
+
+ def test_type_fallback_and_param_model(self) -> None:
+ from cubepi.errors import extract_error_code
+
+ typ = _FakeExc("x", status_code=400)
+ typ.error = {"type": "invalid_model"}
+ assert extract_error_code(typ) == "invalid_model"
+
+ param = _FakeExc("x", status_code=400)
+ param.error = {"type": "invalid_request_error", "param": "model"}
+ assert extract_error_code(param) == "invalid_request_error"
+
+ other = _FakeExc("x", status_code=400)
+ other.error = {"type": "overloaded_error"}
+ assert extract_error_code(other) == "overloaded_error"
+
+ def test_looks_like_model_not_found_gates(self) -> None:
+ from cubepi.errors import _looks_like_model_not_found
+
+ assert _looks_like_model_not_found(status=500, code="model_not_found", msg="x")
+ assert _looks_like_model_not_found(
+ status=400, code=None, msg="x", param="model"
+ )
+ assert _looks_like_model_not_found(
+ status=404, code="not_found_error", msg="unknown model id"
+ )
+ assert _looks_like_model_not_found(
+ status=400, code=None, msg="invalid model xyz"
+ )
+
+ def test_content_filtered_by_code(self) -> None:
+ from cubepi.errors import _looks_like_content_filtered
+
+ assert _looks_like_content_filtered(code="content_filter", msg="nope")
+
+ def test_classify_string_error_branches(self) -> None:
+ from cubepi.errors import classify_string_error
+
+ assert isinstance(
+ classify_string_error("maximum context length exceeded"),
+ ContextLengthExceeded,
+ )
+ assert isinstance(
+ classify_string_error("slow down", status_code=429), RateLimited
+ )
+ assert isinstance(
+ classify_string_error("nope", status_code=401), ProviderAuthFailed
+ )
+ assert isinstance(
+ classify_string_error("blocked by content_policy"), ContentFiltered
+ )
+ assert isinstance(
+ classify_string_error("unknown model foo", status_code=404), ModelNotFound
+ )
+ assert isinstance(
+ classify_string_error("boom", status_code=503), ProviderUnavailable
+ )
+
+ def test_error_from_stream_fields_context_length(self) -> None:
+ from cubepi.errors import error_from_stream_fields
+
+ err = error_from_stream_fields(
+ error_message="too long",
+ error_type="ContextLengthExceeded",
+ tokens_in=99,
+ context_window=10,
+ )
+ assert isinstance(err, ContextLengthExceeded)
+ assert err.tokens_in == 99
+
+ def test_annotate_error_event_typed_and_raw(self) -> None:
+ from cubepi.errors import annotate_error_event
+
+ rl = RateLimited("wait", retry_after=1.5, provider="p", model="m")
+ fields = annotate_error_event(rl)
+ assert fields["error_type"] == "RateLimited"
+ assert fields["retry_after"] == 1.5
+
+ cle = ContextLengthExceeded("long", tokens_in=10, context_window=8)
+ fields = annotate_error_event(cle)
+ assert fields["tokens_in"] == 10
+
+ raw = RuntimeError("nope")
+ fields = annotate_error_event(raw, fallback_message="x")
+ assert fields["error_message"] == "x"
+ assert fields["error_type"] is None