CubeLoop — a Pythonic, async-native agent harness core designed for high performance, readability, and production-grade persistence.
Python agent-frameworkagent-harnessagent-runtimeagentic-aiai-agentsai-frameworkanthropicharnessharness-engineeringharness-frameworklanggraphlanggraph-alternativellmmcpopenaipi-agentpi-agent-corepythonpython-agent
refactor(base): inline chain-skip warning; drop _log_chain_skip helper
xf gong86a7bbd6f961
diff --git a/cubepi/providers/base.py b/cubepi/providers/base.pyindex 276a376..589da86 100644--- a/cubepi/providers/base.py+++ b/cubepi/providers/base.py@@ -815,33 +815,6 @@ class BaseProvider:await _fire_chunk_listeners(self._chunk_listeners, event, model)-def _log_chain_skip(idx: int, provider_type: str) -> None:- """Warn that a chain leg's provider isn't a BaseProvider and was skipped.-- Tries loguru first (matches the rest of ``cubepi.providers``) and falls- back to stdlib logging so the warning is never silently lost when loguru- isn't installed.- """- try:- from loguru import logger # pragma: no cover — loguru is an optional dep-- logger.warning( # pragma: no cover- "cubepi.providers.base.chain_providers: chain[{}] provider {} is not "- "a BaseProvider; tracing/metrics will skip this leg",- idx,- provider_type,- )- except ImportError:- import logging-- logging.getLogger("cubepi.providers.base").warning(- "cubepi.providers.base.chain_providers: chain[%d] provider %s is not "- "a BaseProvider; tracing/metrics will skip this leg",- idx,- provider_type,- )--def chain_providers(model: object) -> list["BaseProvider"]:"""Return the unique BaseProvider instances backing a bound model.@@ -853,10 +826,11 @@ def chain_providers(model: object) -> list["BaseProvider"]:For ``FallbackBoundModel``-like inputs, iterates the chain and dedupesproviders by identity. Chain entries whose ``.provider`` isn't a- ``BaseProvider`` are logged at WARNING via :func:`_log_chain_skip` and+ ``BaseProvider`` are logged at WARNING via stdlib ``logging`` andskipped — tracing / metrics need the ``subscribe_request`` /``subscribe_chunk`` / ``subscribe_response`` interface that only- ``BaseProvider`` exposes.+ ``BaseProvider`` exposes. (cubepi does not depend on loguru; hosts that+ use it can intercept stdlib logging.)For plain bound models, returns ``[model.provider]`` if it is a``BaseProvider``. For ``None`` or any other input, returns ``[]``.@@ -866,6 +840,8 @@ def chain_providers(model: object) -> list["BaseProvider"]:fallback chain so post-failover provider events land in the trace /metric stream."""+ import logging+if model is None:return []chain = getattr(model, "chain", None)@@ -875,7 +851,12 @@ def chain_providers(model: object) -> list["BaseProvider"]:for idx, bm in enumerate(chain):p = getattr(bm, "provider", None)if not isinstance(p, BaseProvider):- _log_chain_skip(idx, type(p).__name__)+ logging.getLogger("cubepi.providers.base").warning(+ "cubepi.providers.base.chain_providers: chain[%d] provider "+ "%s is not a BaseProvider; tracing/metrics will skip this leg",+ idx,+ type(p).__name__,+ )continueif id(p) not in seen:seen.add(id(p))diff --git a/tests/providers/test_fallback.py b/tests/providers/test_fallback.pyindex 37d5c2c..6c44af4 100644--- a/tests/providers/test_fallback.py+++ b/tests/providers/test_fallback.py@@ -455,51 +455,14 @@ def test_chain_providers_warns_when_chain_leg_is_not_base_provider(caplog) -> Noduck_bound = BoundModel(provider=duck, spec=real.model("m").spec) # type: ignore[arg-type]fbm = FallbackBoundModel(chain=(real.model("m"), duck_bound))- # loguru bridges into stdlib logging if a propagation handler is set;- # to keep the test independent of optional loguru config, just assert- # the dropped leg is absent from the output and accept either backend.with caplog.at_level(logging.WARNING, logger="cubepi.providers.base"):out = chain_providers(fbm)assert out == [real], "duck-typed leg should be dropped"- # Warning is emitted either via loguru or stdlib logging. Don't pin- # the backend; just check at least one of them carries the message.- warned = any(+ assert any("chain[1]" in record.message and "_DuckProvider" in record.messagefor record in caplog.records- )- # If loguru is installed it may not propagate to caplog; in that case- # we accept the assertion-free path (we already verified the leg was- # dropped above). Treat this as best-effort signal.- if not warned:- try:- import loguru # noqa: F401-- # loguru is installed → message went to loguru, not caplog;- # the drop assertion above is sufficient evidence the warning- # branch executed.- except ImportError:- raise AssertionError(- "expected a WARNING-level log mentioning chain[1] / _DuckProvider"- )---def test_log_chain_skip_loguru_branch_invokable_directly() -> None:- """Cover the loguru happy-path inside _log_chain_skip.-- The standard chain_providers warn-path test uses caplog (stdlib- logging). When loguru is installed (the default test environment),- the loguru branch fires but caplog cannot capture loguru messages- without bridge configuration. Call _log_chain_skip directly so the- loguru `logger.warning(...)` lines execute and the code path is- recorded by coverage.- """- from cubepi.providers.base import _log_chain_skip-- # No assertion needed — just exercising the path. If loguru is- # absent (extreme edge case), the stdlib fallback runs instead and- # still covers the function body.- _log_chain_skip(0, "object")+ ), "expected a WARNING-level log mentioning chain[1] / _DuckProvider"def test_chain_providers_returns_empty_for_object_without_provider_or_chain() -> None: