Skip to content

Free, Open Source, Self-Hosted WhatsApp API Gateway

docs(sdk): stop calling 503 the only retryable status

Yudhi Armyndharis6d0fc27f72a6
diff --git a/docs/18-sdk-design.md b/docs/18-sdk-design.md
index 19509ce20..d4e3cca73 100644
--- a/docs/18-sdk-design.md
+++ b/docs/18-sdk-design.md
@@ -18,7 +18,7 @@ OpenWA ships five official, hand-written client libraries for the REST API. They
- **One client, fluent resources.** A single client object (`OpenWAClient` / `OpenWA\Client`) exposes every resource as a property — `client.messages.sendText(...)`, `client.sessions.start(...)`. All five SDKs expose the **same** resource surface; only the language idioms differ (camelCase methods + objects in JS/PHP/Java, snake_case methods + dicts in Python, exported fields + structs in Go).
- **It is a request/response client, not an event SDK.** There is no WebSocket, EventEmitter, or `client.on(...)`. To receive inbound messages and acks, register a webhook (the `webhooks` resource) and host your own receiver, or connect to the real-time Socket.IO API directly (see [API Specification §6.5](./06-api-specification.md)).
-- **Typed errors.** Non-2xx responses raise/throw a typed error mapped from the HTTP status (`401/403/404/409/429/501`), plus a timeout error — all `instanceof`/`catch`-checkable. See each language's Error Handling subsection.
+- **Typed errors.** Non-2xx responses raise/throw a typed error mapped from the HTTP status (`401/403/404/409/429/501/503`), plus a timeout error — all `instanceof`/`catch`-checkable. See each language's Error Handling subsection.
- **Injectable transport.** The HTTP layer is replaceable (`fetch` in JS, an `httpx` transport in Python, a Guzzle client in PHP) — the extension point for retry/observability middleware and for testing without the network.
- **Safe by default.** Redirects are never followed (so the API key is never re-sent to a redirect target), the auth/JSON headers always take precedence over caller-supplied defaults, path segments are percent-encoded, a base-URL path prefix (e.g. behind a reverse proxy at `/v1`) is preserved, and there is a default 30s per-request timeout. **No automatic retries by default** — in JS, Python, PHP, and Java wrap calls in your own backoff if you need them (especially for `429`); the Go SDK additionally ships an opt-in `WithRetry(RetryPolicy)` that never replays a `POST` after a network error and limits `POST` retries to `429`/`503`.
@@ -355,17 +355,17 @@ Media bodies share the `SendMediaRequest` shape: `{ chatId, url? | base64?, mime
On a non-2xx response the SDK throws a typed `OpenWAApiError` subclass carrying `.status` (HTTP status), `.body` (parsed JSON error envelope, or raw text), and `.errorKind` (the NestJS `error` field, `undefined` when the gateway omits it — which is the norm for a validation rejection in production, where `disableErrorMessages` is on). All error classes extend `OpenWAError` and are exported, so they are `instanceof`-checkable. A timeout throws `OpenWATimeoutError`, which extends `OpenWAError` directly (not `OpenWAApiError`).
-| Error class | HTTP status | Meaning |
-| ------------------------------- | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `OpenWAAuthError` | 401 | Missing or invalid API key. |
-| `OpenWAForbiddenError` | 403 | The key's role is insufficient (e.g. an OPERATOR-only route). |
-| `OpenWANotFoundError` | 404 | Resource not found. |
-| `OpenWAConflictError` | 409 | Conflict — typically the engine is not ready. |
-| `OpenWARateLimitError` | 429 | Rate limited. |
-| `OpenWANotImplementedError` | 501 | The active engine does not support this operation. |
-| `OpenWAServiceUnavailableError` | 503 | The engine did not confirm in time. The only retryable error here — 501 is permanent. In a routed deployment a forwarded request answers 503 only when the owner node was never reached; a forward that fails after the request was sent answers 502 or 504, which the owner may already have acted on. |
-| `OpenWAApiError` | any other | Generic non-2xx (the base API error, e.g. `400`; also surfaced for unfollowed 3xx redirects). |
-| `OpenWATimeoutError` | — | The request exceeded the configured timeout. |
+| Error class | HTTP status | Meaning |
+| ------------------------------- | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `OpenWAAuthError` | 401 | Missing or invalid API key. |
+| `OpenWAForbiddenError` | 403 | The key's role is insufficient (e.g. an OPERATOR-only route). |
+| `OpenWANotFoundError` | 404 | Resource not found. |
+| `OpenWAConflictError` | 409 | Conflict — typically the engine is not ready. |
+| `OpenWARateLimitError` | 429 | Rate limited. |
+| `OpenWANotImplementedError` | 501 | The active engine does not support this operation. |
+| `OpenWAServiceUnavailableError` | 503 | The engine did not confirm in time. Transient, like 429 (honor `Retry-After`), though a catalog 503 can persist because WhatsApp may never answer that query; 501 is permanent. In a routed deployment a forwarded request answers 503 only when the owner node was never reached; a forward that fails after the request was sent answers 502 or 504, which the owner may already have acted on. |
+| `OpenWAApiError` | any other | Generic non-2xx (the base API error, e.g. `400`; also surfaced for unfollowed 3xx redirects). |
+| `OpenWATimeoutError` | — | The request exceeded the configured timeout. |
```typescript
import {
@@ -726,17 +726,17 @@ Resources are accessed as properties on the client (e.g. `client.messages`). All
Every error inherits from `OpenWAError`. A non-2xx response raises an `OpenWAApiError` (or a more specific subclass picked by status); a timeout raises `OpenWATimeoutError`. The API-error classes carry `.status` (HTTP code), `.body` (parsed JSON or raw text), and `.error_kind` (the NestJS `error` field).
-| Exception | Trigger |
-| ------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `OpenWAAuthError` | HTTP `401` — missing or invalid API key |
-| `OpenWAForbiddenError` | HTTP `403` — insufficient role |
-| `OpenWANotFoundError` | HTTP `404` — resource not found |
-| `OpenWAConflictError` | HTTP `409` — typically engine-not-ready |
-| `OpenWARateLimitError` | HTTP `429` — too many requests |
-| `OpenWANotImplementedError` | HTTP `501` — active engine doesn't support the operation |
-| `OpenWAServiceUnavailableError` | HTTP `503` — engine did not confirm in time; retryable. In a routed deployment a forwarded request answers 503 only when the owner node was never reached; a forward that fails after the request was sent answers 502 or 504, which the owner may already have acted on |
-| `OpenWAApiError` | any other non-2xx status (incl. unfollowed `3xx`) |
-| `OpenWATimeoutError` | request exceeded `timeout` (has a `.timeout` attribute) |
+| Exception | Trigger |
+| ------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `OpenWAAuthError` | HTTP `401` — missing or invalid API key |
+| `OpenWAForbiddenError` | HTTP `403` — insufficient role |
+| `OpenWANotFoundError` | HTTP `404` — resource not found |
+| `OpenWAConflictError` | HTTP `409` — typically engine-not-ready |
+| `OpenWARateLimitError` | HTTP `429` — too many requests |
+| `OpenWANotImplementedError` | HTTP `501` — active engine doesn't support the operation |
+| `OpenWAServiceUnavailableError` | HTTP `503` — engine did not confirm in time; transient, like 429 (honor `Retry-After`), though a catalog 503 can persist because WhatsApp may never answer that query. In a routed deployment a forwarded request answers 503 only when the owner node was never reached; a forward that fails after the request was sent answers 502 or 504, which the owner may already have acted on |
+| `OpenWAApiError` | any other non-2xx status (incl. unfollowed `3xx`) |
+| `OpenWATimeoutError` | request exceeded `timeout` (has a `.timeout` attribute) |
```python
from openwa import (
@@ -1075,18 +1075,18 @@ All payloads are associative arrays; all listed methods are synchronous and retu
All exceptions live in `OpenWA\Exceptions` and descend from `OpenWAException` (which extends PHP's `\Exception`). Any non-2xx response is raised as an `OpenWAApiException`; the static `classify()` factory picks the most specific subclass by status code. An `OpenWAApiException` carries the HTTP status (`getStatus(): int`), the parsed error body (`getBody(): mixed`), and the NestJS `error` kind when present (`getErrorKind(): ?string`).
-| Exception | Extends | Trigger |
-| ----------------------------------- | -------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `OpenWAException` | `\Exception` | Base for all SDK errors (also thrown for missing `baseUrl`/`apiKey`). |
-| `OpenWAApiException` | `OpenWAException` | Any non-2xx (including unfollowed 3xx and other 4xx/5xx). |
-| `OpenWAAuthException` | `OpenWAApiException` | `401` — missing/invalid API key. |
-| `OpenWAForbiddenException` | `OpenWAApiException` | `403` — insufficient role (e.g. operator-only endpoint). |
-| `OpenWANotFoundException` | `OpenWAApiException` | `404` — resource not found. |
-| `OpenWAConflictException` | `OpenWAApiException` | `409` — conflict (e.g. engine not ready). |
-| `OpenWARateLimitException` | `OpenWAApiException` | `429` — rate limited. |
-| `OpenWANotImplementedException` | `OpenWAApiException` | `501` — active engine does not support the operation. |
-| `OpenWAServiceUnavailableException` | `OpenWAApiException` | `503` — engine did not confirm in time; the only retryable one. In a routed deployment a forwarded request answers 503 only when the owner node was never reached; a forward that fails after the request was sent answers 502 or 504, which the owner may already have acted on. |
-| `OpenWATimeoutException` | `OpenWAException` | Request exceeded the timeout (`getTimeout(): float`). Not an API error — has no status/body. |
+| Exception | Extends | Trigger |
+| ----------------------------------- | -------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `OpenWAException` | `\Exception` | Base for all SDK errors (also thrown for missing `baseUrl`/`apiKey`). |
+| `OpenWAApiException` | `OpenWAException` | Any non-2xx (including unfollowed 3xx and other 4xx/5xx). |
+| `OpenWAAuthException` | `OpenWAApiException` | `401` — missing/invalid API key. |
+| `OpenWAForbiddenException` | `OpenWAApiException` | `403` — insufficient role (e.g. operator-only endpoint). |
+| `OpenWANotFoundException` | `OpenWAApiException` | `404` — resource not found. |
+| `OpenWAConflictException` | `OpenWAApiException` | `409` — conflict (e.g. engine not ready). |
+| `OpenWARateLimitException` | `OpenWAApiException` | `429` — rate limited. |
+| `OpenWANotImplementedException` | `OpenWAApiException` | `501` — active engine does not support the operation. |
+| `OpenWAServiceUnavailableException` | `OpenWAApiException` | `503` — engine did not confirm in time; transient, like 429 (honor `Retry-After`), though a catalog 503 can persist because WhatsApp may never answer that query. In a routed deployment a forwarded request answers 503 only when the owner node was never reached; a forward that fails after the request was sent answers 502 or 504, which the owner may already have acted on. |
+| `OpenWATimeoutException` | `OpenWAException` | Request exceeded the timeout (`getTimeout(): float`). Not an API error — has no status/body. |
```php
<?php
diff --git a/sdk/go/README.md b/sdk/go/README.md
index e5935b30e..a7ef276c0 100644
--- a/sdk/go/README.md
+++ b/sdk/go/README.md
@@ -102,7 +102,9 @@ case err != nil:
Sentinels: `ErrUnauthorized` (401), `ErrForbidden` (403), `ErrNotFound` (404),
`ErrConflict` (409), `ErrRateLimited` (429), `ErrNotImplemented` (501),
-`ErrServiceUnavailable` (503 — the only retryable one). A timeout
+`ErrServiceUnavailable` (503). 429 (honor `Retry-After`) and 503 are the
+transient statuses, but a catalog 503 can persist because WhatsApp may never
+answer that query, so bound any retry. A timeout
surfaces as `*openwa.TimeoutError`. In a routed deployment only 503 proves
the request was never carried out: a forward that fails after the request
reached the owner node answers 502 or 504.
diff --git a/sdk/go/errors.go b/sdk/go/errors.go
index 701a1f69e..a9e1f9b8c 100644
--- a/sdk/go/errors.go
+++ b/sdk/go/errors.go
@@ -35,13 +35,15 @@ var (
ErrNotImplemented = errors.New("openwa: not implemented")
// ErrServiceUnavailable is returned for a 503 — a transport failure rather
// than a refusal: WhatsApp never replied, the socket was down, or the
- // request budget ran out. Unlike every other sentinel here it is
- // RETRYABLE. The non-idempotent sends are deliberately left unbounded by
- // the gateway so a slow WhatsApp reply never answers one, and in a
- // multi-node deployment a forwarded request answers 503 only when the
- // owner node was never reached. A forward that fails after the request
- // was sent answers 502 or 504 instead: the owner may already have carried
- // it out, so do not repeat a non-idempotent send on those unchecked.
+ // request budget ran out. It is retryable, as is ErrRateLimited (honor
+ // its Retry-After), but a catalog 503 can persist because WhatsApp may
+ // never answer that query, so bound any retry. The non-idempotent sends
+ // are deliberately left unbounded by the gateway so a slow WhatsApp reply
+ // never answers one, and in a multi-node deployment a forwarded request
+ // answers 503 only when the owner node was never reached. A forward that
+ // fails after the request was sent answers 502 or 504 instead: the owner
+ // may already have carried it out, so do not repeat a non-idempotent send
+ // on those unchecked.
ErrServiceUnavailable = errors.New("openwa: service unavailable")
)
diff --git a/sdk/java/README.md b/sdk/java/README.md
index 8f91001e8..528a7654a 100644
--- a/sdk/java/README.md
+++ b/sdk/java/README.md
@@ -96,19 +96,19 @@ try {
}
```
-| Class | HTTP | Meaning |
-| ------------------------------- | ---- | ------------------------------------------------------- |
-| `OpenWAAuthError` | 401 | Missing or invalid API key |
-| `OpenWAForbiddenError` | 403 | API key role insufficient |
-| `OpenWANotFoundError` | 404 | Resource not found |
-| `OpenWAConflictError` | 409 | Engine not ready |
-| `OpenWARateLimitError` | 429 | Rate limited |
-| `OpenWANotImplementedError` | 501 | Active engine does not support the call |
-| `OpenWAServiceUnavailableError` | 503 | Engine did not confirm in time — the only retryable one |
-| `OpenWAApiError` | — | Any other non-2xx (carries `.status()`) |
-| `OpenWATimeoutError` | — | Request exceeded the configured timeout |
-
-All extend `OpenWAError` (a `RuntimeException`). In a routed deployment only 503 proves the request was never carried out: a forward that fails after the request reached the owner node answers 502 or 504.
+| Class | HTTP | Meaning |
+| ------------------------------- | ---- | --------------------------------------- |
+| `OpenWAAuthError` | 401 | Missing or invalid API key |
+| `OpenWAForbiddenError` | 403 | API key role insufficient |
+| `OpenWANotFoundError` | 404 | Resource not found |
+| `OpenWAConflictError` | 409 | Engine not ready |
+| `OpenWARateLimitError` | 429 | Rate limited |
+| `OpenWANotImplementedError` | 501 | Active engine does not support the call |
+| `OpenWAServiceUnavailableError` | 503 | Engine did not confirm in time |
+| `OpenWAApiError` | — | Any other non-2xx (carries `.status()`) |
+| `OpenWATimeoutError` | — | Request exceeded the configured timeout |
+
+All extend `OpenWAError` (a `RuntimeException`). 429 (honor `Retry-After`) and 503 are the transient statuses, but a catalog 503 can persist because WhatsApp may never answer that query, so bound any retry. In a routed deployment only 503 proves the request was never carried out: a forward that fails after the request reached the owner node answers 502 or 504.
## Reliability & security
diff --git a/sdk/java/src/main/java/com/rmyndharis/openwa/errors/OpenWAServiceUnavailableError.java b/sdk/java/src/main/java/com/rmyndharis/openwa/errors/OpenWAServiceUnavailableError.java
index bee77b52f..fc90c17b8 100644
--- a/sdk/java/src/main/java/com/rmyndharis/openwa/errors/OpenWAServiceUnavailableError.java
+++ b/sdk/java/src/main/java/com/rmyndharis/openwa/errors/OpenWAServiceUnavailableError.java
@@ -4,12 +4,13 @@ package com.rmyndharis.openwa.errors;
* 503 Service Unavailable — a transport failure, not a refusal.
*
* <p>The gateway answers this when the engine did not confirm the operation in time: WhatsApp never
- * replied, the socket was down, or the request budget ran out. <b>Retryable</b>, unlike every other
- * typed error here. The non-idempotent sends are deliberately left unbounded by the gateway so a slow
- * WhatsApp reply never answers one, and in a multi-node deployment a forwarded request answers 503
- * only when the owner node was never reached. A forward that fails after the request was sent
- * answers 502 or 504 instead (a plain {@link OpenWAApiError}): the owner may already have carried it
- * out, so do not repeat a non-idempotent send on those unchecked.
+ * replied, the socket was down, or the request budget ran out. <b>Retryable</b>, as is a 429 (honor
+ * its {@code Retry-After}), but a catalog 503 can persist because WhatsApp may never answer that
+ * query, so bound any retry. The non-idempotent sends are deliberately left unbounded by the gateway
+ * so a slow WhatsApp reply never answers one, and in a multi-node deployment a forwarded request
+ * answers 503 only when the owner node was never reached. A forward that fails after the request was
+ * sent answers 502 or 504 instead (a plain {@link OpenWAApiError}): the owner may already have
+ * carried it out, so do not repeat a non-idempotent send on those unchecked.
*/
public class OpenWAServiceUnavailableError extends OpenWAApiError {
public OpenWAServiceUnavailableError(String message, int status, Object body, String errorKind) {
diff --git a/sdk/javascript/README.md b/sdk/javascript/README.md
index 8743a162b..221d096cb 100644
--- a/sdk/javascript/README.md
+++ b/sdk/javascript/README.md
@@ -45,10 +45,12 @@ CommonJS consumers use `require('@rmyndharis/openwa')` identically.
Non-2xx responses throw a typed `OpenWAApiError` subclass
(`OpenWAAuthError`, `OpenWAForbiddenError`, `OpenWANotFoundError`,
`OpenWAConflictError`, `OpenWARateLimitError`, `OpenWANotImplementedError`,
-`OpenWAServiceUnavailableError` — 503, the only retryable one),
+`OpenWAServiceUnavailableError` for 503),
each carrying `.status` and the parsed `.body`. Timeouts throw
`OpenWATimeoutError`. The SDK does **not** retry — wrap calls with your own
-backoff if needed. In a routed deployment only 503 proves the request was
+backoff if needed. 429 (honor `Retry-After`) and 503 are the transient
+statuses, but a catalog 503 can persist because WhatsApp may never answer
+that query, so bound any retry. In a routed deployment only 503 proves the request was
never carried out: a forward that fails after the request reached the owner
node answers 502 or 504.
diff --git a/sdk/javascript/src/errors.ts b/sdk/javascript/src/errors.ts
index 296b41f49..4ecd6c675 100644
--- a/sdk/javascript/src/errors.ts
+++ b/sdk/javascript/src/errors.ts
@@ -84,7 +84,8 @@ export class OpenWANotImplementedError extends OpenWAApiError {}
/**
* 503 Service Unavailable — a transport failure, not a refusal. The gateway answers this when the
* engine did not confirm the operation in time: WhatsApp never replied, the socket was down, or the
- * request budget ran out. **Retryable**, unlike every other typed error here.
+ * request budget ran out. **Retryable**, as is a 429 (honor its `Retry-After`), but a catalog 503 can
+ * persist because WhatsApp may never answer that query, so bound any retry.
*
* Not every 503 is safe to repeat blindly: the non-idempotent sends (group create, channel create,
* media send) are deliberately left unbounded by the gateway so a slow WhatsApp reply never answers
diff --git a/sdk/php/README.md b/sdk/php/README.md
index d63f9dc43..88c54a0db 100644
--- a/sdk/php/README.md
+++ b/sdk/php/README.md
@@ -56,9 +56,11 @@ $client = new Client([
A non-2xx response throws a typed `OpenWA\Exceptions\OpenWAApiException` subclass —
`OpenWAAuthException` (401), `OpenWAForbiddenException` (403), `OpenWANotFoundException` (404),
`OpenWAConflictException` (409), `OpenWARateLimitException` (429),
-`OpenWANotImplementedException` (501), `OpenWAServiceUnavailableException` (503 — the only
-retryable one) — each exposing `getStatus()` and the parsed `getBody()`.
-A timeout throws `OpenWATimeoutException`. In a routed deployment only 503 proves the request
+`OpenWANotImplementedException` (501), `OpenWAServiceUnavailableException` (503) — each
+exposing `getStatus()` and the parsed `getBody()`.
+A timeout throws `OpenWATimeoutException`. 429 (honor `Retry-After`) and 503 are the transient
+statuses, but a catalog 503 can persist because WhatsApp may never answer that query, so bound
+any retry. In a routed deployment only 503 proves the request
was never carried out: a forward that fails after the request reached the owner node answers
502 or 504.
diff --git a/sdk/php/src/Exceptions/OpenWAServiceUnavailableException.php b/sdk/php/src/Exceptions/OpenWAServiceUnavailableException.php
index 4c30f3b21..e2da8ef2a 100644
--- a/sdk/php/src/Exceptions/OpenWAServiceUnavailableException.php
+++ b/sdk/php/src/Exceptions/OpenWAServiceUnavailableException.php
@@ -8,8 +8,9 @@ namespace OpenWA\Exceptions;
* 503 Service Unavailable — a transport failure, not a refusal.
*
* The gateway answers this when the engine did not confirm the operation in time: WhatsApp never
- * replied, the socket was down, or the request budget ran out. Retryable, unlike every other typed
- * exception here. The non-idempotent sends are deliberately left unbounded by the gateway so a slow
+ * replied, the socket was down, or the request budget ran out. Retryable, as is a 429 (honor its
+ * Retry-After), but a catalog 503 can persist because WhatsApp may never answer that query, so bound
+ * any retry. The non-idempotent sends are deliberately left unbounded by the gateway so a slow
* WhatsApp reply never answers one, and in a multi-node deployment a forwarded request answers 503
* only when the owner node was never reached. A forward that fails after the request was sent
* answers 502 or 504 instead (a plain OpenWAApiException): the owner may already have carried it
diff --git a/sdk/python/README.md b/sdk/python/README.md
index b1f2c8cda..93fd522e5 100644
--- a/sdk/python/README.md
+++ b/sdk/python/README.md
@@ -71,8 +71,10 @@ for hit in res["hits"]:
A non-2xx response raises a typed `OpenWAApiError` subclass — `OpenWAAuthError` (401),
`OpenWAForbiddenError` (403), `OpenWANotFoundError` (404), `OpenWAConflictError` (409),
`OpenWARateLimitError` (429), `OpenWANotImplementedError` (501),
-`OpenWAServiceUnavailableError` (503 — the only retryable one) — each carrying `.status`
-and the parsed `.body`. A timeout raises `OpenWATimeoutError`. In a routed deployment only
+`OpenWAServiceUnavailableError` (503) — each carrying `.status`
+and the parsed `.body`. A timeout raises `OpenWATimeoutError`. 429 (honor `Retry-After`) and
+503 are the transient statuses, but a catalog 503 can persist because WhatsApp may never answer
+that query, so bound any retry. In a routed deployment only
503 proves the request was never carried out: a forward that fails after the request reached
the owner node answers 502 or 504.
diff --git a/sdk/python/openwa/errors.py b/sdk/python/openwa/errors.py
index 383922fc6..165387ffd 100644
--- a/sdk/python/openwa/errors.py
+++ b/sdk/python/openwa/errors.py
@@ -82,8 +82,9 @@ class OpenWAServiceUnavailableError(OpenWAApiError):
"""503 Service Unavailable -- a transport failure, not a refusal.
The gateway answers this when the engine did not confirm the operation in time: WhatsApp never
- replied, the socket was down, or the request budget ran out. Retryable, unlike every other typed
- error here. The non-idempotent sends are deliberately left unbounded by the gateway so a slow
+ replied, the socket was down, or the request budget ran out. Retryable, as is a 429 (honor its
+ Retry-After), but a catalog 503 can persist because WhatsApp may never answer that query, so bound
+ any retry. The non-idempotent sends are deliberately left unbounded by the gateway so a slow
WhatsApp reply never answers one, and in a multi-node deployment a forwarded request answers 503
only when the owner node was never reached. A forward that fails after the request was sent
answers 502 or 504 instead (a plain OpenWAApiError): the owner may already have carried it out, so