ionq
diff --git a/‎ionq_core/_exceptions.py‎
Lines changed: 0 additions & 3 deletions b/‎ionq_core/_exceptions.py‎
Lines changed: 0 additions & 3 deletions
diff --git a/‎ionq_core/_extensions.py‎
Lines changed: 26 additions & 98 deletions b/‎ionq_core/_extensions.py‎
Lines changed: 26 additions & 98 deletions
diff --git a/‎ionq_core/_gates.py‎
Lines changed: 0 additions & 2 deletions b/‎ionq_core/_gates.py‎
Lines changed: 0 additions & 2 deletions
@@ -1,7 +1,5 @@
 """Structured exceptions for the IonQ API client."""
 
-from __future__ import annotations
-
 
 class IonQError(Exception):
     """Base exception for all IonQ API errors."""
@@ -86,7 +84,6 @@ def raise_for_status(
     *,
     request_id: str | None = None,
 ) -> None:
-    """Raise the appropriate exception for an error status code."""
     if status_code < 400:
         return
     exc_cls = _STATUS_TO_EXCEPTION.get(status_code, ServerError if status_code >= 500 else APIError)
 
@@ -1,43 +1,18 @@
-"""Extension API for downstream SDKs building on ionq-core.
-
-Provides hooks that downstream libraries (qiskit-ionq, cirq-ionq, etc.)
-use to customize client behavior without forking or monkey-patching.
-
-Typical usage::
-
-    from ionq_core import IonQClient, ClientExtension
-
-    ext = ClientExtension(
-        user_agent_token="qiskit-ionq/1.1.0",
-        default_headers={"X-Qiskit-Version": "1.3.0"},
-    )
-    client = IonQClient(api_key="...", extension=ext)
-"""
-
-from __future__ import annotations
+"""Extension API for downstream SDKs building on ionq-core."""
 
 import logging
 from collections.abc import Callable
-from dataclasses import dataclass, field
 from typing import Protocol, runtime_checkable
 
+import attrs
 import httpx
 
 logger = logging.getLogger("ionq_core")
 
 
 @runtime_checkable
 class EventHook(Protocol):
-    """Protocol for observing requests and responses (sync).
-
-    Hooks are for observation only (logging, metrics, telemetry) - they
-    must not mutate the request or response.  For mutation, use a custom
-    httpx transport instead.
-
-    ``on_error`` is called when the underlying transport raises an
-    exception (after retries are exhausted).  Hooks that do not implement
-    ``on_error`` are silently skipped.
-    """
+    """Protocol for observing requests and responses (sync)."""
 
     def on_request(self, request: httpx.Request) -> None: ...
     def on_response(self, request: httpx.Request, response: httpx.Response) -> None: ...
@@ -51,27 +26,20 @@ async def on_request(self, request: httpx.Request) -> None: ...
     async def on_response(self, request: httpx.Request, response: httpx.Response) -> None: ...
 
 
-@dataclass(frozen=True, slots=True)
+@attrs.frozen
 class ClientExtension:
-    """Declarative configuration bundle for downstream SDK integration.
-
-    All fields are optional and additive - they layer on top of the
-    defaults that IonQClient already provides.
-
-    Explicit caller arguments to ``IonQClient()`` take precedence over
-    extension values, which in turn take precedence over factory defaults.
-    """
+    """Declarative configuration bundle for downstream SDK integration."""
 
     user_agent_token: str | None = None
-    default_headers: dict[str, str] = field(default_factory=dict)
+    default_headers: dict[str, str] = attrs.Factory(dict)
     event_hooks: tuple[EventHook, ...] = ()
     async_event_hooks: tuple[AsyncEventHook, ...] = ()
     retryable_status_codes: frozenset[int] | None = None
     max_retries: int | None = None
     timeout: httpx.Timeout | None = None
     transport_wrapper: Callable[[httpx.BaseTransport], httpx.BaseTransport] | None = None
     async_transport_wrapper: Callable[[httpx.AsyncBaseTransport], httpx.AsyncBaseTransport] | None = None
-    error_mapper: Callable[[Exception], Exception] | None = None  # return same object to skip mapping
+    error_mapper: Callable[[Exception], Exception] | None = None
     debug_hooks: bool = False
 
 
@@ -101,92 +69,52 @@ async def _afire_hooks(hooks: tuple, method: str, *args, debug: bool = False) ->
             logger.exception("%s raised; ignoring", method)
 
 
-class HookTransport(httpx.BaseTransport):
-    """Transport decorator that invokes EventHook instances.
-
-    Sits between the retry transport (inner) and the user wrapper (outer).
-    Hooks observe the final request/response after retries resolve.
-    ``on_error`` fires when the inner transport raises.
-    """
+class HookTransport(httpx.BaseTransport, httpx.AsyncBaseTransport):
+    """Transport decorator that invokes EventHook instances and optionally maps exceptions."""
 
-    def __init__(self, transport: httpx.BaseTransport, hooks: tuple[EventHook, ...], *, debug: bool = False) -> None:
+    def __init__(
+        self,
+        transport,
+        hooks: tuple = (),
+        *,
+        debug: bool = False,
+        error_mapper: Callable[[Exception], Exception] | None = None,
+    ) -> None:
         self._transport = transport
         self._hooks = hooks
         self._debug = debug
+        self._error_mapper = error_mapper
+
+    def _map_error(self, exc: Exception) -> None:
+        if self._error_mapper is not None:
+            mapped = self._error_mapper(exc)
+            if mapped is not exc:
+                raise mapped from exc
 
     def handle_request(self, request: httpx.Request) -> httpx.Response:
         _fire_hooks(self._hooks, "on_request", request, debug=self._debug)
         try:
             response = self._transport.handle_request(request)
         except Exception as exc:
             _fire_hooks(self._hooks, "on_error", request, exc, debug=self._debug)
+            self._map_error(exc)
             raise
         _fire_hooks(self._hooks, "on_response", request, response, debug=self._debug)
         return response
 
-    def close(self) -> None:
-        self._transport.close()
-
-
-class AsyncHookTransport(httpx.AsyncBaseTransport):
-    """Async counterpart of HookTransport."""
-
-    def __init__(
-        self, transport: httpx.AsyncBaseTransport, hooks: tuple[AsyncEventHook, ...], *, debug: bool = False
-    ) -> None:
-        self._transport = transport
-        self._hooks = hooks
-        self._debug = debug
-
     async def handle_async_request(self, request: httpx.Request) -> httpx.Response:
         await _afire_hooks(self._hooks, "on_request", request, debug=self._debug)
         try:
             response = await self._transport.handle_async_request(request)
         except Exception as exc:
             await _afire_hooks(self._hooks, "on_error", request, exc, debug=self._debug)
+            self._map_error(exc)
             raise
         await _afire_hooks(self._hooks, "on_response", request, response, debug=self._debug)
         return response
 
-    async def aclose(self) -> None:
-        await self._transport.aclose()
-
-
-class _ErrorMapperTransport(httpx.BaseTransport):
-    """Translates exceptions via an error_mapper callback for downstream SDKs."""
-
-    def __init__(self, transport: httpx.BaseTransport, mapper: Callable[[Exception], Exception]) -> None:
-        self._transport = transport
-        self._mapper = mapper
-
-    def handle_request(self, request: httpx.Request) -> httpx.Response:
-        try:
-            return self._transport.handle_request(request)
-        except Exception as exc:
-            mapped = self._mapper(exc)
-            if mapped is not exc:
-                raise mapped from exc
-            raise
-
     def close(self) -> None:
         self._transport.close()
 
-
-class _AsyncErrorMapperTransport(httpx.AsyncBaseTransport):
-    """Async counterpart of _ErrorMapperTransport."""
-
-    def __init__(self, transport: httpx.AsyncBaseTransport, mapper: Callable[[Exception], Exception]) -> None:
-        self._transport = transport
-        self._mapper = mapper
-
-    async def handle_async_request(self, request: httpx.Request) -> httpx.Response:
-        try:
-            return await self._transport.handle_async_request(request)
-        except Exception as exc:
-            mapped = self._mapper(exc)
-            if mapped is not exc:
-                raise mapped from exc
-            raise
-
     async def aclose(self) -> None:
         await self._transport.aclose()
@@ -5,8 +5,6 @@
 Matrices are returned as nested tuples of complex numbers.
 """
 
-from __future__ import annotations
-
 import cmath
 import math