fix: keep body content out of the DecodeError message

The message is now 'failed to decode response into <model>: <type>' with
the error count appended when the original exception has error_count().
A non-class model such as X | None is shown by repr, which stops the
AttributeError on Python 3.11 to 3.13. exc.original is unchanged.

Author: lesnik512

docs/errors.md

@@ -149,19 +149,20 @@ Fields:
 - `model: type`: the type passed as `response_model=`.
 - `original: BaseException`: the decoder's own exception, such as `pydantic.ValidationError`, `msgspec.ValidationError` or `msgspec.DecodeError`. It is also `exc.__cause__`.
 
+The message names the model and the type of `original`, and adds the error count when `original` has an `error_count()` method, as `pydantic.ValidationError` does:
+
+    failed to decode response into User: ValidationError (2 errors)
+
+A model that is not a class, such as `User | None` or `list[User]`, appears as its `repr`. The message never quotes the body. `str(exc.original)` can: a pydantic `ValidationError` echoes the input values it rejected, so check what it holds before you log it.
+
 ```python
 from httpware import AsyncClient, DecodeError
 
 
 try:
     user = await client.get("/users/1", response_model=User)
 except DecodeError as exc:
-    _LOGGER.error(
-        "decode failed for %s into %s: %s",
-        exc.response.request.url,
-        exc.model.__name__,
-        exc.original,
-    )
+    _LOGGER.error("%s", exc)
     raise
 ```
 

src/httpware/errors.py

@@ -202,14 +202,26 @@ def __init__(self, *, retry_after: float | None) -> None:
             super().__init__(f"circuit open (retry_after={retry_after:.3f}s)")
 
 
+def _decode_error_summary(model: type, original: BaseException) -> str:
+    model_name = model.__name__ if isinstance(model, type) else repr(model)
+    summary = f"failed to decode response into {model_name}: {type(original).__qualname__}"
+    error_count = getattr(original, "error_count", None)
+    if not callable(error_count):
+        return summary
+    count = error_count()
+    return f"{summary} ({count} error{'' if count == 1 else 's'})"
+
+
 class DecodeError(ClientError):
     """Raised when the active ResponseDecoder failed to decode response.content.
 
     The HTTP call itself succeeded — status was 2xx/3xx and the transport
     delivered the body intact — but the body could not be parsed into the
     requested response_model. Always chained from the underlying library
     exception via ``raise ... from exc``; that exception is also exposed as
-    ``self.original`` for structured handling.
+    ``self.original`` for structured handling. The message names the model
+    and the original exception's type, plus its error count when it has an
+    ``error_count()`` method (pydantic), and never includes body content.
     """
 
     response: httpx2.Response
@@ -226,7 +238,7 @@ def __init__(
         self.response = response
         self.model = model
         self.original = original
-        super().__init__(f"failed to decode response into {model.__name__}: {original}")
+        super().__init__(_decode_error_summary(model, original))
 
 
 def _missing_decoder_summary(model: type, registered_names: tuple[str, ...]) -> str:

tests/test_errors.py

@@ -298,14 +298,40 @@ def test_decode_error_stores_fields() -> None:
     assert exc.original is inner
 
 
-def test_decode_error_summary_includes_model_and_original() -> None:
-    response = _make_response(200)
-    inner = ValueError("bad payload")
-    exc = DecodeError(response=response, model=_DecodeErrorModel, original=inner)
-    summary = str(exc)
-    assert "_DecodeErrorModel" in summary
-    assert "bad payload" in summary
-    assert summary.startswith("failed to decode response into ")
+def _validation_error(payload: bytes) -> pydantic.ValidationError:
+    with pytest.raises(pydantic.ValidationError) as caught:
+        _DecodeErrorModel.model_validate_json(payload)
+    return caught.value
+
+
+def test_decode_error_summary_names_model_and_exception_type_only() -> None:
+    exc = DecodeError(response=_make_response(200), model=_DecodeErrorModel, original=ValueError("body: topsecret"))
+    assert str(exc) == "failed to decode response into _DecodeErrorModel: ValueError"
+
+
+def test_decode_error_summary_counts_validation_errors_without_body_content() -> None:
+    original = _validation_error(b'{"id": "topsecret", "extra": 1}')
+    exc = DecodeError(response=_make_response(200), model=_DecodeErrorModel, original=original)
+    assert str(exc) == "failed to decode response into _DecodeErrorModel: ValidationError (1 error)"
+    assert exc.original is original
+
+
+class _TwoFieldModel(pydantic.BaseModel):
+    id: int
+    name: str
+
+
+def test_decode_error_summary_pluralises_error_count() -> None:
+    with pytest.raises(pydantic.ValidationError) as caught:
+        _TwoFieldModel.model_validate_json(b'{"id": "topsecret", "name": 3}')
+    exc = DecodeError(response=_make_response(200), model=_TwoFieldModel, original=caught.value)
+    assert str(exc) == "failed to decode response into _TwoFieldModel: ValidationError (2 errors)"
+
+
+@pytest.mark.parametrize("model", [_DecodeErrorModel | None, list[_DecodeErrorModel]], ids=["optional", "generic"])
+def test_decode_error_summary_uses_repr_for_non_class_models(model: type) -> None:
+    exc = DecodeError(response=_make_response(200), model=model, original=ValueError("x"))
+    assert str(exc) == f"failed to decode response into {model!r}: ValueError"
 
 
 def test_decode_error_rejects_positional_args() -> None: