signalwire-sdk 3.2.0.dev94__tar.gz → 3.2.0.dev96__tar.gz

{signalwire_sdk-3.2.0.dev94/signalwire/signalwire_sdk.egg-info → signalwire_sdk-3.2.0.dev96}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: signalwire-sdk
-Version: 3.2.0.dev94
+Version: 3.2.0.dev96
 Summary: SignalWire SDK
 Author-email: SignalWire Team <info@signalwire.com>
 License: MIT

{signalwire_sdk-3.2.0.dev94 → signalwire_sdk-3.2.0.dev96}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "signalwire-sdk"
-version = "3.2.0.dev94"
+version = "3.2.0.dev96"
 description = "SignalWire SDK"
 authors = [
     {name = "SignalWire Team", email = "info@signalwire.com"}

{signalwire_sdk-3.2.0.dev94 → signalwire_sdk-3.2.0.dev96}/signalwire/signalwire/__init__.py

@@ -14,8 +14,12 @@ A package for building AI agents using SignalWire's AI and SWML capabilities.
 
 from typing import TYPE_CHECKING, Any
 
-# Configure logging before any other imports to ensure early initialization
-from .core.logging_config import configure_logging
+# Library-safe logging: importing signalwire installs ONLY a NullHandler on the
+# `signalwire` namespace logger (done at logging_config module load). It does NOT
+# configure global logging — that would hijack the host application's logging (its
+# structlog config, its root/generic-named loggers). The app opts in to SDK log
+# OUTPUT by calling configure_logging() explicitly; the server/CLI entry points do.
+from .core.logging_config import configure_logging  # noqa: F401  (re-exported)
 
 if TYPE_CHECKING:
     from signalwire.rest.client import RestClient as _RestClient
@@ -48,9 +52,7 @@ if TYPE_CHECKING:
     from signalwire.utils.schema_utils import SchemaValidationError
     from signalwire.web import WebService
 
-configure_logging()
-
-__version__ = "3.2.0.dev94"
+__version__ = "3.2.0.dev96"
 
 # §6.2-python (owner decision: NO packaging split — one package, all deps required;
 # IMPORT-TIME behavior only): the agent/web symbols are lazy-imported via module

{signalwire_sdk-3.2.0.dev94 → signalwire_sdk-3.2.0.dev96}/signalwire/signalwire/agent_server.py

@@ -68,7 +68,7 @@ class AgentServer:
         self.app = FastAPI(
             title="SignalWire AI Agents",
             description="Hosted SignalWire AI Agents",
-            version="3.2.0.dev94",
+            version="3.2.0.dev96",
             redirect_slashes=False,
             docs_url=None,
             redoc_url=None,
@@ -372,7 +372,15 @@ class AgentServer:
 
         # Imported lazily here so tests can patch
         # signalwire.core.logging_config.get_execution_mode at call time.
-        from signalwire.core.logging_config import get_execution_mode
+        from signalwire.core.logging_config import (
+            configure_logging,
+            get_execution_mode,
+        )
+
+        # Opt-in to SDK logging OUTPUT at the run entry point (import is
+        # library-safe / silent; running is where the app wants logs). This also
+        # applies the CGI-off / auto detection that configure_logging performs.
+        configure_logging()
 
         # Detect execution mode
         mode = get_execution_mode()

{signalwire_sdk-3.2.0.dev94 → signalwire_sdk-3.2.0.dev96}/signalwire/signalwire/core/logging_config.py

@@ -43,6 +43,25 @@ def strip_control_chars(
 _logging_configured = False
 
 
+def _install_library_null_handler() -> None:
+    """Attach a NullHandler to the ``signalwire`` namespace logger (the standard
+    library pattern for a well-behaved library, per the stdlib logging HOWTO).
+
+    This is the ONLY logging side effect of importing the SDK. It makes the SDK's
+    own loggers silent-by-default (no "No handlers could be found" warning) WITHOUT
+    touching the root logger, the host application's structlog config, or any
+    host-owned logger — so ``import signalwire`` never hijacks the app's logging.
+    The app opts in to SDK log OUTPUT by calling ``configure_logging()`` explicitly
+    (the server/CLI entry points do this)."""
+    sw_logger = logging.getLogger("signalwire")
+    if not any(isinstance(h, logging.NullHandler) for h in sw_logger.handlers):
+        sw_logger.addHandler(logging.NullHandler())
+
+
+# Import-time side effect: ONLY the library NullHandler. NOT global configuration.
+_install_library_null_handler()
+
+
 def get_execution_mode() -> str:
     """
     Determine the execution mode based on environment variables
@@ -307,7 +326,9 @@ def get_logger(name: str) -> Any:
     Returns:
         A structlog BoundLogger that supports .bind(), .info(), .debug(), etc.
     """
-    # Ensure logging is configured
-    configure_logging()
-
+    # Library-safe: do NOT auto-configure global logging here. Every SDK module
+    # calls get_logger() at import, so auto-configuring would hijack the host
+    # app's logging the moment any SDK submodule is imported. The SDK's own
+    # logger carries a NullHandler (installed at module load) so it's silent by
+    # default; the app opts in to SDK output via configure_logging().
     return structlog.get_logger(name)

{signalwire_sdk-3.2.0.dev94 → signalwire_sdk-3.2.0.dev96}/signalwire/signalwire/core/mixins/web_mixin.py

@@ -204,6 +204,12 @@ class WebMixin(_HostTyped):  # type: ignore[misc]  # _HostTyped is object at run
         """
         import uvicorn
 
+        # Opt-in to SDK logging OUTPUT at the serve entry point (importing the SDK
+        # is library-safe / silent; running a server is where the app wants logs).
+        from signalwire.core.logging_config import configure_logging
+
+        configure_logging()
+
         if self._app is None:
             # Create a FastAPI app with explicit redirect_slashes=False
             app = FastAPI(

{signalwire_sdk-3.2.0.dev94 → signalwire_sdk-3.2.0.dev96}/signalwire/signalwire/core/swml_service.py

@@ -1200,6 +1200,12 @@ class SWMLService(ToolMixin):
         """
         import uvicorn
 
+        # Opt-in to SDK logging OUTPUT at the serve entry point (import is
+        # library-safe / silent; serving is where the app wants logs).
+        from signalwire.core.logging_config import configure_logging
+
+        configure_logging()
+
         # Store SSL configuration (override environment if explicitly provided)
         if ssl_enabled is not None:
             self.ssl_enabled = ssl_enabled

{signalwire_sdk-3.2.0.dev94 → signalwire_sdk-3.2.0.dev96}/signalwire/signalwire/relay/call.py

@@ -112,9 +112,15 @@ class Action:
                 )
 
     async def wait(self, timeout: float | None = None) -> RelayEvent:
-        """Wait for the action to complete. Returns the terminal event."""
+        """Wait for the action to complete. Returns the terminal event.
+
+        Raises ``asyncio.TimeoutError`` if ``timeout`` is exceeded. A timed-out
+        wait does NOT poison the action: ``self._done`` is shielded so the
+        ``wait_for`` cancellation stops the wait, not the underlying completion
+        future — the still-pending terminal event resolves the action normally
+        and a subsequent ``wait()`` returns it (mirrors ``Message.wait``)."""
         if timeout is not None:
-            return await asyncio.wait_for(self._done, timeout=timeout)
+            return await asyncio.wait_for(asyncio.shield(self._done), timeout=timeout)
         return await self._done
 
     @property
@@ -377,9 +383,14 @@ class Call:
         The outer JSON-RPC method is ``"calling.<method>"`` (e.g.
         ``"calling.answer"``) with ``node_id`` and ``call_id`` in params.
 
-        All server errors are logged gracefully and return an empty dict
-        rather than raising exceptions.  This is an SDK — stack traces
-        from server-side errors should never bubble up to the developer.
+        A2 contract (the documented behavior — only "call gone" is swallowed):
+        a **404** or **410** server error means the call no longer exists, so the
+        verb is a no-op and returns ``{}`` (the caller's action can't proceed but
+        that isn't an error worth raising). **Every other non-2xx server error
+        RAISES** — the previous code swallowed ALL errors carrying a ``code``,
+        which hid real failures (auth, bad params, server faults) the developer
+        must see. The docstring/contract always promised 404/410-only; the code
+        now matches it.
         """
         rpc_method = f"calling.{method}"
         params: dict[str, Any] = {
@@ -392,11 +403,13 @@ class Call:
             return await self._client.execute(rpc_method, params)
         except Exception as exc:
             code = getattr(exc, "code", None)
-            if code is not None:
+            if code in (404, 410):
+                # Call gone — swallow per the documented contract, return no-op.
                 logger.warning(
-                    f"Call {self.call_id} error during {method} (code={code}): {exc}"
+                    f"Call {self.call_id} gone during {method} (code={code}): {exc}"
                 )
                 return {}
+            # Any other server error (or a non-coded exception) propagates.
             raise
 
     # ------------------------------------------------------------------

{signalwire_sdk-3.2.0.dev94 → signalwire_sdk-3.2.0.dev96}/signalwire/signalwire/relay/client.py

@@ -24,6 +24,7 @@ import asyncio
 import json
 import os
 import re
+import ssl as ssl_module
 import uuid
 from typing import Any, TYPE_CHECKING
 from collections.abc import Callable, Coroutine
@@ -60,6 +61,7 @@ from .constants import (
     METHOD_SIGNALWIRE_RECEIVE,
     METHOD_SIGNALWIRE_UNRECEIVE,
     RECONNECT_BACKOFF_FACTOR,
+    RECONNECT_MAX_AUTH_ATTEMPTS,
     RECONNECT_MAX_DELAY,
     RECONNECT_MIN_DELAY,
 )
@@ -100,6 +102,48 @@ except ValueError:
 _active_clients: set[int] = set()
 
 
+# Credential-bearing JSON keys whose VALUES must never appear in debug logs
+# (SECRET-SCRUB, A6/enterprise): the raw RELAY frames carry the connect
+# authentication (project/token/jwt_token) and the server's encrypted
+# ``authorization_state`` re-auth blob. Logging a raw frame verbatim leaks these.
+_SCRUB_KEYS = ("token", "project", "jwt_token", "authorization_state")
+_SCRUB_RE = re.compile(
+    r'("(?:' + "|".join(_SCRUB_KEYS) + r')"\s*:\s*)"(?:\\.|[^"\\])*"'
+)
+
+
+def _scrub_frame(raw: object) -> str:
+    """Return a log-safe repr of a raw RELAY frame with credential VALUES masked.
+
+    Masks the string values of ``token``/``project``/``jwt_token``/
+    ``authorization_state`` keys wherever they appear in the (JSON) frame, so a
+    ``SIGNALWIRE_LOG_LEVEL=debug`` session never emits live credentials or the
+    re-auth blob. Non-string / structural content is preserved so the frame stays
+    diagnostic."""
+    text = (
+        raw.decode("utf-8", "replace")
+        if isinstance(raw, (bytes, bytearray))
+        else str(raw)
+    )
+    return _SCRUB_RE.sub(r'\1"***"', text)
+
+
+def _build_relay_ssl_context() -> ssl_module.SSLContext | None:
+    """Return a TLS context trusting SIGNALWIRE_RELAY_CA_FILE, or None.
+
+    A5 fleet CA-var contract: when SIGNALWIRE_RELAY_CA_FILE names a CA bundle,
+    build a default client TLS context that loads it as the trust root for the
+    RELAY WebSocket connection. Unset → None (websockets uses the system trust
+    store). Kept module-level so the connect path stays readable and the behavior
+    is unit-testable without a live socket."""
+    ca_file = os.environ.get("SIGNALWIRE_RELAY_CA_FILE")
+    if not ca_file:
+        return None
+    ctx = ssl_module.create_default_context()
+    ctx.load_verify_locations(cafile=ca_file)
+    return ctx
+
+
 class RelayClient:
     """Manages a WebSocket connection to SignalWire RELAY.
 
@@ -134,12 +178,24 @@ class RelayClient:
             # JWT auth — project/token not required (project_id is inside the token)
             if not self.project:
                 self.project = ""
-        elif not self.project or not self.token:
-            raise ValueError(
-                "project and token are required (or provide jwt_token). "
-                "Pass them directly or set SIGNALWIRE_PROJECT_ID / "
-                "SIGNALWIRE_API_TOKEN / SIGNALWIRE_JWT_TOKEN env vars."
-            )
+        else:
+            # A6 credential contract: fail fast pre-connect with a PER-VARIABLE
+            # actionable error — name exactly which credential is missing and the
+            # env var that supplies it, so the caller fixes the right one (a
+            # combined "project and token" message misleads when only one is
+            # absent). JWT is the alternative for both.
+            if not self.project:
+                raise ValueError(
+                    "project is required. Pass project=... or set the "
+                    "SIGNALWIRE_PROJECT_ID env var (or use jwt_token / "
+                    "SIGNALWIRE_JWT_TOKEN for JWT auth)."
+                )
+            if not self.token:
+                raise ValueError(
+                    "token is required. Pass token=... or set the "
+                    "SIGNALWIRE_API_TOKEN env var (or use jwt_token / "
+                    "SIGNALWIRE_JWT_TOKEN for JWT auth)."
+                )
 
         # Validate host to prevent SSRF / header injection
         if any(c in self.host for c in ("@", "/", "?", "\r", "\n", " ")):
@@ -205,6 +261,12 @@ class RelayClient:
         self._execute_queue: list[
             tuple[dict[str, Any], asyncio.Future[dict[str, Any]]]
         ] = []
+        # A6 bounded-reconnect state: whether authentication has ever succeeded
+        # (a drop after this is a TRANSIENT loss → reconnect indefinitely), and
+        # the count of consecutive auth rejections before any success (a
+        # PERMANENT credential failure → bounded, then raise).
+        self._authenticated_ever: bool = False
+        self._auth_reject_attempts: int = 0
 
     def __del__(self) -> None:
         _active_clients.discard(id(self))
@@ -228,6 +290,30 @@ class RelayClient:
         task.add_done_callback(self._bg_tasks.discard)
         return task
 
+    def _scrub_log(self, text: str) -> str:
+        """Log-safe repr with live credential VALUES masked wherever they appear.
+
+        Composes over :func:`_scrub_frame` (the key-shape mask, ``"token":"..."``)
+        and then masks any *verbatim* occurrence of THIS connection's live
+        credential values (project / token / jwt_token / authorization_state).
+        The key-shape pass alone misses a credential value the server reflects
+        into a NON-credential field (e.g. an auth-response ``identity`` derived
+        from the project, or the raw ``identity=`` diagnostic) — so a
+        ``SIGNALWIRE_LOG_LEVEL=debug`` session must never emit the raw value even
+        there. Defense-in-depth: value-masking is stronger than, and additive to,
+        the key-shape scrub.
+        """
+        out = _scrub_frame(text)
+        for value in (
+            self.project,
+            self.token,
+            self.jwt_token,
+            self._authorization_state,
+        ):
+            if value:
+                out = out.replace(value, "***")
+        return out
+
     @property
     def relay_protocol(self) -> str:
         """Server-assigned protocol string from the connect response."""
@@ -268,8 +354,20 @@ class RelayClient:
         uri = f"wss://{self.host}"
         logger.info(f"Connecting to {uri}")
 
+        # A5 (fleet CA-var contract, hard-cut no aliases): a custom CA bundle for
+        # the RELAY WebSocket transport is supplied via SIGNALWIRE_RELAY_CA_FILE.
+        # When set, build a TLS context that trusts it; unset → websockets' default
+        # (system trust store). This is the RELAY half of the fleet-standard pair
+        # (SIGNALWIRE_REST_CA_FILE is the REST half).
+        ssl_context = _build_relay_ssl_context()
+
         self._ws = await websockets.connect(
-            uri, ping_interval=None, max_size=10 * 1024 * 1024
+            uri,
+            ping_interval=None,
+            max_size=10 * 1024 * 1024,
+            # ssl_context is None when SIGNALWIRE_RELAY_CA_FILE is unset, which
+            # tells websockets to use its default (system trust store) for wss://.
+            ssl=ssl_context,
         )
         self._connected = True
         self._reconnect_delay = RECONNECT_MIN_DELAY
@@ -318,6 +416,12 @@ class RelayClient:
 
         result = await self._send_request(METHOD_SIGNALWIRE_CONNECT, params)
 
+        # Authentication succeeded: from here on a connection drop is a
+        # transient loss (reconnect indefinitely), not a credential failure.
+        # Reset the permanent-auth-failure counter (A6 bounded reconnect).
+        self._authenticated_ever = True
+        self._auth_reject_attempts = 0
+
         # Capture server-assigned protocol and identity
         self._relay_protocol = result.get("protocol", self._relay_protocol)
         self._identity = result.get("identity", self._identity)
@@ -327,7 +431,10 @@ class RelayClient:
         # session. Internal-only — not part of the public surface.
         self._session_id = result.get("sessionid", self._session_id)
         logger.debug(
-            f"Auth response: protocol={self._relay_protocol} identity={self._identity}"
+            self._scrub_log(
+                f"Auth response: protocol={self._relay_protocol} "
+                f"identity={self._identity}"
+            )
         )
 
     async def disconnect(self) -> None:
@@ -587,6 +694,30 @@ class RelayClient:
                     await self._recv_task
             except asyncio.CancelledError:
                 break
+            except RelayError as exc:
+                # A6 bounded reconnect: a RelayError out of connect() before we
+                # ever authenticated is a PERMANENT credential rejection (the
+                # server refused the connect creds), NOT a transient blip.
+                # Bound the retries and then RAISE the server's message — never
+                # loop forever on bad creds, never silent exit-0. A transport
+                # error (ConnectionRefused/OSError, server not up yet) is caught
+                # by the broad handler below and keeps reconnecting.
+                if not self._authenticated_ever:
+                    self._auth_reject_attempts += 1
+                    if self._auth_reject_attempts >= RECONNECT_MAX_AUTH_ATTEMPTS:
+                        logger.error(
+                            "RELAY authentication rejected "
+                            f"{self._auth_reject_attempts} time(s); giving up: {exc}"
+                        )
+                        await self.disconnect()
+                        raise
+                    logger.warning(
+                        "RELAY authentication rejected "
+                        f"({self._auth_reject_attempts}/{RECONNECT_MAX_AUTH_ATTEMPTS}); "
+                        f"retrying: {exc}"
+                    )
+                else:
+                    logger.exception("Connection error")
             except Exception:
                 logger.exception("Connection error")
 
@@ -721,10 +852,17 @@ class RelayClient:
                 try:
                     msg = json.loads(raw)
                 except json.JSONDecodeError:
-                    logger.warning(f"Invalid JSON received: {raw!r}")
+                    logger.warning(
+                        f"Invalid JSON received: {self._scrub_log(str(raw))!r}"
+                    )
                     continue
 
-                logger.debug(f"<< {raw!r}")
+                # SECRET-SCRUB: mask credential/authorization_state values so a
+                # debug-level log never leaks live creds or the re-auth blob —
+                # including a value the server reflects into a non-credential
+                # field (e.g. identity derived from the project). _scrub_log
+                # composes the key-shape mask with verbatim value-masking.
+                logger.debug(f"<< {self._scrub_log(str(raw))}")
                 await self._handle_message(msg)
         except websockets.exceptions.ConnectionClosed:
             logger.info("WebSocket connection closed")

{signalwire_sdk-3.2.0.dev94 → signalwire_sdk-3.2.0.dev96}/signalwire/signalwire/relay/constants.py

@@ -115,6 +115,14 @@ ROOM_STATE_LEAVE = "leave"
 RECONNECT_MIN_DELAY = 1.0
 RECONNECT_MAX_DELAY = 30.0
 RECONNECT_BACKOFF_FACTOR = 2.0
+# A6 credential-failure contract (bounded reconnect): a transient connection
+# loss reconnects indefinitely (a server blip must self-heal), but a PERMANENT
+# authentication rejection (the server refuses the credentials — a 401-class
+# error frame to signalwire.connect, before we have ever authenticated) must
+# NOT loop forever. After this many consecutive auth rejections with no
+# intervening successful auth, _run_forever re-raises the server's message and
+# stops — never an infinite reconnect on bad creds, never a silent exit-0.
+RECONNECT_MAX_AUTH_ATTEMPTS = 3
 
 # Default host
 DEFAULT_RELAY_HOST = "relay.signalwire.com"

{signalwire_sdk-3.2.0.dev94 → signalwire_sdk-3.2.0.dev96}/signalwire/signalwire/rest/_base.py

@@ -9,6 +9,7 @@ See LICENSE file in the project root for full license information.
 HTTP client infrastructure and base resource classes for the REST client.
 """
 
+import os
 import time
 from importlib.metadata import PackageNotFoundError, version
 from typing import Any, Generic, TypeVar, cast
@@ -153,6 +154,15 @@ class HttpClient:
         self._request_options = request_options
         self._session = requests.Session()
         self._session.auth = (project, token)
+        # A5 (fleet CA-var contract, hard-cut no aliases): a custom CA bundle for
+        # the REST transport is supplied via SIGNALWIRE_REST_CA_FILE. When set, it
+        # becomes the session's verify bundle (requests uses it for TLS
+        # verification of the platform cert). Unset → requests' default trust
+        # store. This is the REST half of the fleet-standard pair
+        # (SIGNALWIRE_RELAY_CA_FILE is the RELAY half).
+        _rest_ca_file = os.environ.get("SIGNALWIRE_REST_CA_FILE")
+        if _rest_ca_file:
+            self._session.verify = _rest_ca_file
         self._session.headers.update(
             {
                 "Content-Type": "application/json",
@@ -332,10 +342,21 @@ class ReadResource(BaseResource, Generic[TList, TItem]):
     defined once here.
     """
 
-    def list(self, **params: Any) -> TList:
-        return cast(TList, self._http.get(self._base_path, params=params or None))
+    def list(
+        self, *, request_options: RequestOptions | None = None, **params: Any
+    ) -> TList:
+        return cast(
+            TList,
+            self._http.get(
+                self._base_path,
+                params=params or None,
+                request_options=request_options,
+            ),
+        )
 
-    def paginate(self, **params: Any) -> PaginatedIterator:
+    def paginate(
+        self, *, request_options: RequestOptions | None = None, **params: Any
+    ) -> PaginatedIterator:
         """Iterate every item across all pages of this resource's list endpoint.
 
         ``list()`` returns a single raw page (the server's first response). For
@@ -347,14 +368,24 @@ class ReadResource(BaseResource, Generic[TList, TItem]):
 
         Wires the resource layer to the tested ``PaginatedIterator`` (which walks
         ``resp["data"]`` and follows ``resp["links"]["next"]``), so callers no
-        longer hand-construct the path + token loop.
+        longer hand-construct the path + token loop. ``request_options`` (a per-call
+        timeout / retry / header override) is applied to EVERY page fetch.
         """
         return PaginatedIterator(
-            self._http, self._base_path, params=params or None, data_key="data"
+            self._http,
+            self._base_path,
+            params=params or None,
+            data_key="data",
+            request_options=request_options,
         )
 
-    def get(self, resource_id: str) -> TItem:
-        return cast(TItem, self._http.get(self._path(resource_id)))
+    def get(
+        self, resource_id: str, *, request_options: RequestOptions | None = None
+    ) -> TItem:
+        return cast(
+            TItem,
+            self._http.get(self._path(resource_id), request_options=request_options),
+        )
 
 
 class CrudResource(ReadResource[TList, TItem], Generic[TList, TItem, TCreate, TUpdate]):
@@ -369,7 +400,9 @@ class CrudResource(ReadResource[TList, TItem], Generic[TList, TItem, TCreate, TU
 
     _update_method = "PATCH"
 
-    def create(self, **kwargs: Any) -> TItem:
+    def create(
+        self, *, request_options: RequestOptions | None = None, **kwargs: Any
+    ) -> TItem:
         # Honest fallback: the body accepts arbitrary wire fields and at runtime
         # is a plain dict. Concrete resources override this with a generated
         # CLOSED typed signature (explicit spec fields + an ``extras`` door); the
@@ -377,26 +410,58 @@ class CrudResource(ReadResource[TList, TItem], Generic[TList, TItem, TCreate, TU
         # TCreate shape to the signature oracle, NOT this base method body. (A
         # bare ``**kwargs: TCreate`` here is wrong — it would type each kwarg
         # VALUE as a whole TCreate — and is what the generated overrides replace.)
-        return cast(TItem, self._http.post(self._base_path, body=kwargs))
+        return cast(
+            TItem,
+            self._http.post(
+                self._base_path, body=kwargs, request_options=request_options
+            ),
+        )
 
-    def update(self, resource_id: str, /, **kwargs: Any) -> TItem:
+    def update(
+        self,
+        resource_id: str,
+        /,
+        *,
+        request_options: RequestOptions | None = None,
+        **kwargs: Any,
+    ) -> TItem:
         # resource_id is positional-only so a subclass may rename it without an LSP
         # override conflict. Same contract as ``create``: honest ``**kwargs: Any``
         # fallback; the concrete generated override carries the closed typed shape, the
         # binding carries TUpdate for the oracle.
         method = getattr(self._http, self._update_method.lower())
-        return cast(TItem, method(self._path(resource_id), body=kwargs))
+        return cast(
+            TItem,
+            method(
+                self._path(resource_id),
+                body=kwargs,
+                request_options=request_options,
+            ),
+        )
 
-    def delete(self, resource_id: str) -> TItem:
-        return cast(TItem, self._http.delete(self._path(resource_id)))
+    def delete(
+        self, resource_id: str, *, request_options: RequestOptions | None = None
+    ) -> TItem:
+        return cast(
+            TItem,
+            self._http.delete(self._path(resource_id), request_options=request_options),
+        )
 
 
 class CrudWithAddresses(CrudResource[TList, TItem, TCreate, TUpdate]):
     """CRUD resource that also supports listing addresses."""
 
-    def list_addresses(self, resource_id: str, **params: Any) -> Any:
+    def list_addresses(
+        self,
+        resource_id: str,
+        *,
+        request_options: RequestOptions | None = None,
+        **params: Any,
+    ) -> Any:
         return self._http.get(
-            self._path(resource_id, "addresses"), params=params or None
+            self._path(resource_id, "addresses"),
+            params=params or None,
+            request_options=request_options,
         )
 
 

{signalwire_sdk-3.2.0.dev94 → signalwire_sdk-3.2.0.dev96}/signalwire/signalwire/rest/_pagination.py

@@ -11,6 +11,8 @@ Pagination support for list endpoints that return paged results.
 
 from typing import TYPE_CHECKING, Any
 
+from signalwire.rest._request_options import RequestOptions
+
 if TYPE_CHECKING:
     # Type-only import: _base imports this module (ReadResource.paginate), so a
     # runtime `from ._base import HttpClient` would be a circular import. HttpClient
@@ -32,11 +34,15 @@ class PaginatedIterator:
         path: str,
         params: dict[str, Any] | None = None,
         data_key: str = "data",
+        request_options: RequestOptions | None = None,
     ) -> None:
         self._http = http
         self._path = path
         self._params: dict[str, Any] = dict(params or {})
         self._data_key = data_key
+        # Per-call request options (timeout / retry / headers) applied to every
+        # page fetch this iterator performs.
+        self._request_options = request_options
         self._current_page: Any = None
         self._items: list[Any] = []
         self._index = 0
@@ -61,7 +67,11 @@ class PaginatedIterator:
         return item
 
     def _fetch_next(self) -> None:
-        resp = self._http.get(self._path, params=self._params or None)
+        resp = self._http.get(
+            self._path,
+            params=self._params or None,
+            request_options=self._request_options,
+        )
         data = resp.get(self._data_key, [])
         self._items.extend(data)