fix: strengthen TogetherException repr handling

- preserve mapping-like headers as structured JSON in __repr__
- validate the regression with a real CIMultiDictProxy repro

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: giulio-leone

src/together/error.py

@@ -1,13 +1,24 @@
 from __future__ import annotations
 
 import json
+from collections.abc import Mapping
 from typing import Any, Dict
 
 from requests import RequestException
 
 from together.types.error import TogetherErrorResponse
 
 
+def _json_safe_headers(headers: str | Dict[Any, Any] | None) -> str | Dict[Any, Any]:
+    if headers is None:
+        return {}
+    if isinstance(headers, str):
+        return headers
+    if isinstance(headers, Mapping):
+        return {str(key): value for key, value in headers.items()}
+    return str(headers)
+
+
 class TogetherException(Exception):
     def __init__(
         self,
@@ -43,7 +54,7 @@ def __repr__(self) -> str:
                 "response": self._message,
                 "status": self.http_status,
                 "request_id": self.request_id,
-                "headers": self.headers,
+                "headers": _json_safe_headers(self.headers),
             },
             default=str,
         )

tests/unit/test_error_repr.py

@@ -3,39 +3,18 @@
 from __future__ import annotations
 
 import json
-from collections import OrderedDict
-from typing import Any, Iterator
 from unittest.mock import MagicMock
 
-import pytest
+from multidict import CIMultiDict, CIMultiDictProxy
 
 from together.error import (
-    TogetherException,
+    APIError,
     AuthenticationError,
     ResponseError,
-    APIError,
+    TogetherException,
 )
 
 
-class FakeMultiDictProxy:
-    """Simulates aiohttp's CIMultiDictProxy — not JSON serializable."""
-
-    def __init__(self, data: dict[str, str]) -> None:
-        self._data = data
-
-    def __iter__(self) -> Iterator[str]:
-        return iter(self._data)
-
-    def __len__(self) -> int:
-        return len(self._data)
-
-    def __getitem__(self, key: str) -> str:
-        return self._data[key]
-
-    def __repr__(self) -> str:
-        return f"<FakeMultiDictProxy({self._data!r})>"
-
-
 class TestExceptionReprNonSerializable:
     """Verify __repr__ doesn't crash on non-JSON-serializable headers (issue #108)."""
 
@@ -52,21 +31,28 @@ def test_repr_with_dict_headers(self) -> None:
         assert "test error" in result
 
     def test_repr_with_multidict_proxy_headers(self) -> None:
-        """CIMultiDictProxy-like headers must not crash repr (issue #108)."""
-        fake_headers = FakeMultiDictProxy(
-            {"Content-Type": "application/json", "X-Request-Id": "abc"}
+        """Real CIMultiDictProxy headers must not crash repr (issue #108)."""
+        headers = CIMultiDictProxy(
+            CIMultiDict(
+                {"Content-Type": "application/json", "X-Request-Id": "abc"}
+            )
         )
         exc = TogetherException(
             message="server error",
-            headers=fake_headers,  # type: ignore[arg-type]
+            headers=headers,  # type: ignore[arg-type]
             http_status=500,
             request_id="req-456",
         )
-        # Before fix: TypeError: Object of type FakeMultiDictProxy
+        # Before fix: TypeError: Object of type CIMultiDictProxy
         #             is not JSON serializable
         result = repr(exc)
         assert "TogetherException" in result
         assert "server error" in result
+        parsed = json.loads(result[len("TogetherException(") + 1 : -2])
+        assert parsed["headers"] == {
+            "Content-Type": "application/json",
+            "X-Request-Id": "abc",
+        }
 
     def test_repr_with_none_headers(self) -> None:
         """None headers (default) should work."""
@@ -110,12 +96,12 @@ def test_repr_output_is_valid_after_fix(self) -> None:
 
     def test_subclass_repr_with_non_serializable_headers(self) -> None:
         """Subclasses should also benefit from the fix."""
-        fake_headers = FakeMultiDictProxy({"X-Rate-Limit": "100"})
+        headers = CIMultiDictProxy(CIMultiDict({"X-Rate-Limit": "100"}))
 
         for ExcClass in (AuthenticationError, ResponseError, APIError):
             exc = ExcClass(
                 message="subclass test",
-                headers=fake_headers,  # type: ignore[arg-type]
+                headers=headers,  # type: ignore[arg-type]
                 http_status=429,
             )
             result = repr(exc)