.gitignore

@@ -1,5 +1,5 @@
 # claude
-.claude/
+CLAUDE.md
 
 # python
 __pycache__/

README.md

@@ -13,17 +13,15 @@ send to the core — inheriting rotation, proxy, retry, and result for free.
 ## Install
 
 ```
-aiowebhooks @ git+ssh://git@git.rethinkstudios.io/rethink-public/aiowebhooks.git@v0.1.4
+aiowebhooks @ git+ssh://git@git.rethinkstudios.io/rethink-public/aiowebhooks.git@v0.1.2
 # discord embeds / identity helpers need the extra:
-aiowebhooks[discord] @ git+ssh://git@git.rethinkstudios.io/rethink-public/aiowebhooks.git@v0.1.4
+aiowebhooks[discord] @ git+ssh://git@git.rethinkstudios.io/rethink-public/aiowebhooks.git@v0.1.2
 ```
 
 The base pulls `aiohttp` and `commons` (for the retry/backoff engine). Only
 `aiowebhooks[discord]` adds `discord.py` (>=2.3, mainline — not discord.py-self), and
 only for `DiscordWebhook`.
 
-Drop the `@v0.1.4` suffix from the line above to install the latest unpinned.
-
 ## Core sender
 
 ```python
@@ -72,10 +70,8 @@ result.proxy     # canonical proxy string used (host:port:user:pass / host:port)
 
 Status retries run through `commons.aretry` (exponential backoff + cap):
 
-- **429** — always retried, capped by `max_retries`. When a wait is parseable (body
+- **429** — honors the `retry_after` from the body first (Discord sends seconds), then
-  `retry_after` first — Discord sends seconds — then the `Retry-After` header) it sleeps
+  the `Retry-After` header, sleeping that exact value; capped by `max_retries`.
-  that value before retrying; a 429 with no parseable wait (edge/Cloudflare/generic
-  webhook) still retries under aretry's backoff rather than failing one-shot.
 - **5xx** — retried with exponential backoff, capped by `max_retries`.
 - **4xx** (other than 429) — fails immediately (no retry), returned as `ok=False`.
 
@@ -141,19 +137,6 @@ Without the extra installed, importing `aiowebhooks` still works; constructing o
 
 ## Changelog
 
-### v0.1.4
-
-- **Never-raises net widened:** an unexpected exception that escapes a send attempt (a
-  closed injected session → `RuntimeError`, a malformed proxy URL → `ValueError`) now
-  converts to a falsy `WebhookResult(ok=False, ...)` instead of propagating out of
-  `send()`, restoring the documented contract for those edge triggers.
-
-### v0.1.3
-
-- **429 always retries:** every `429` is now retryable under aretry's backoff + cap, not
-  only those with a parseable `retry_after`. A 429 with no body `retry_after` and no
-  `Retry-After` header (edge/Cloudflare/generic webhook) previously failed one-shot.
-
 ### v0.1.2
 
 - Removed a dead `clock` constructor param (it was stored but never used). Pinned
@@ -172,4 +155,4 @@ Without the extra installed, importing `aiowebhooks` still works; constructing o
 
 ## Versioning
 
-Releases are tagged `vX.Y.Z`. The install line above pins a release; drop the `@vX.Y.Z` suffix to install the latest unpinned. Pin deliberately for reproducible installs.
+Tagged `vX.Y.Z`. Pin the tag.

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "aiowebhooks"
-version = "0.1.4"
+version = "0.1.2"
 description = "async webhook sender (aiohttp) with round-robin urls, retry, and proxy rotation; optional discord.py embeds"
 requires-python = ">=3.10"
 dependencies = [

src/aiowebhooks/__init__.py

@@ -21,4 +21,4 @@ from .sender import Webhook
 
 __all__ = ["Webhook", "WebhookResult", "WebhookError", "NoUrlsError"]
 
-__version__ = "0.1.4"
+__version__ = "0.1.2"

src/aiowebhooks/sender.py

@@ -145,16 +145,6 @@ class Webhook:
             )
         except _Retryable as exhausted:
             return exhausted.result
-        except Exception as error:
-            # never-raises safety net: an unexpected error that escapes the attempt (a
-            # closed injected session -> RuntimeError, a malformed proxy url -> ValueError,
-            # anything not aiohttp.ClientError/TimeoutError) must come back as a failed
-            # result, not propagate out of send()
-            log.warning("webhook send failed unexpectedly on %s: %s", url, error, exc_info=True)
-            return WebhookResult(
-                ok=False, status=None, url=url, attempts=counter[0] or 1,
-                error=f"{type(error).__name__}: {error}",
-            )
 
     async def _attempt(
         self, session: aiohttp.ClientSession, url: str, payload: Dict, counter: List[int]
@@ -211,19 +201,10 @@ class Webhook:
                         error=f"http {status}", response=body, proxy=last_proxy,
                     )
 
-                    if status == 429:
+                    wait = self._retry_after(status, resp.headers, body)
-                        # every 429 is retryable; honor an explicit retry_after by
+                    if wait is not None:
-                        # sleeping it, but a 429 with no parseable wait (edge/Cloudflare/
+                        log.warning("webhook 429 on %s; honoring retry_after %.3fs", url, wait)
-                        # generic webhook) still retries under aretry's backoff + cap.
+                        await asyncio.sleep(wait)
-                        # note: aretry ALSO sleeps its backoff between retries, so an
-                        # honored retry_after is additive (retry_after + backoff) — this
-                        # only ever over-waits, never under-waits the server's hint
-                        wait = self._retry_after(status, resp.headers, body)
-                        if wait is not None:
-                            log.warning("webhook 429 on %s; honoring retry_after %.3fs", url, wait)
-                            await asyncio.sleep(wait)
-                        else:
-                            log.warning("webhook 429 on %s; no retry_after, backing off", url)
                         raise _Retryable(result)
                     if status >= 500:
                         raise _Retryable(result)