sendly 4.3.0 → 4.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3aee146f9046fd6558c2ec3af67cf715a780538d5f054a212d1fd27c36c52a59
-  data.tar.gz: f88147e73d75d0a731e2c8fd65634ac79ce5a162908e03d7c778122bb841914f
+  metadata.gz: 511e36e32d4475552b4000a026856bde62c06bd7f43a52b59646c347d7ff4b0c
+  data.tar.gz: 92531f77aa366320d2887a3b9a0ac9793c6562d507f3863577352830097f4d32
 SHA512:
-  metadata.gz: bd2892234c3a4b5dbd721fe37a0b4ecc8693ea20440fcfa04d724ce9d6ad94fd6f42319aefa9148d3a05e801ac0f2db225096c1b23e7897e54625b406ef1115e
-  data.tar.gz: 89476582a5b3026c6a07d54fb563425df47328d1ba5f00f5da9e17731dfe3e229ceb96b699efa219f9c9fcaa1907e7bc3e4174b5c52b6b3ce6f004553daead90
+  metadata.gz: 000020f0a21c87fb3f4b33ca84fad93e36a73abaa936ca602b22c3065e7fbc3d09b2c0fe62b02f2080dbab1f2b4d37d8ad60648d08e0a0d022a71bbcd64b1ee6
+  data.tar.gz: fbc1718f201afe7895d433d989bf41e7c0938fac6c029dca8380b2d88620ef56d65851a258b9d3e39ad683652023e8468ef534c8a459ce930fcf35cc6d07ddba

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 # sendly (Ruby)
 
+## 4.5.0
+
+### Patch Changes
+
+- **`Sendly::ValidationError#status_code` is the response's real status.** It was always 400, so a 422 (such as `whatsapp_window_closed` or `sms_fallback_not_supported`) reported 400. Code that compared `status_code` with 400 to spot a validation error should check the class (or `code`) instead. `ValidationError.new` takes an optional `status_code:`, 400 by default.
+- Docs give 503, the status the API sends, instead of 502 for the WhatsApp and voice errors raised when WhatsApp or the carrier couldn't be reached: `whatsapp_send_failed` when the message never reached WhatsApp (not sent, and safe to send again with the same idempotency key), the WhatsApp signup, profile, conversational-components and calling errors, `voice_attach_failed` and `carrier_refused`. The API answers every 502 as a 503 with a `Sendly-Upstream-Status: 502` header. Nothing changes at runtime.
+
+## 4.4.0
+
+### Minor Changes
+
+- **WhatsApp to SMS fallback.** `messages.send(channel: "whatsapp", fallback_to_sms: true)` sends `fallbackToSms`; it was dropped before. When WhatsApp can't deliver the message (the 24-hour window is closed, WhatsApp refuses it, or reports it undeliverable later), it goes as an SMS from the same number, billed as an SMS. The new `Sendly::WhatsAppSmsFallback` (`channel`, `status`, `reason`, `message_id`, `credits_used`, `error`, `content_dropped`, with `pending?` and `sent?`, and `STATUSES` and `REASONS`) says what happened: it is `WhatsAppMessage#fallback`, and `WhatsAppMessage#fell_back?` is true when the SMS went. When the SMS went in place of the WhatsApp message, `status` is `"failed"` and `fallback.status` is `"sent"`. `Message` gains `fallback` (on a WhatsApp message from `messages.get` or `messages.list`) and `fallback_of` (on the SMS, the id of the WhatsApp message it replaced), and `to_h` includes them when present. The number must already be able to send SMS to the recipient (US and Canada), or the API answers 403 `sms_fallback_unavailable`; marketing and authentication templates, and media without a caption, get 422 `sms_fallback_not_supported`.
+
+### Patch Changes
+
+- **Errors carry the API's error code.** `e.code` is the code the API sent in `error`, such as `"whatsapp_window_closed"`, `"sms_fallback_unavailable"` or `"invalid_api_key"`, on every error class, so refusals with the same status can be told apart. Before, only an unrecognised status read a code, and from a `code` field the API doesn't send, so `e.code` was the class's own code (`"VALIDATION_ERROR"`, `"API_ERROR"` and so on). That code is still used when the body names none (an `error` that is a sentence, or no `error` at all); a body's `code` field is read when `error` isn't a code. Code that compared `e.code` with a class code for an API error should rescue the class instead, or compare with the API's code.
+
 ## 4.3.0
 
 ### Minor Changes

data/Gemfile.lock

@@ -1,14 +1,14 @@
 PATH
   remote: .
   specs:
-    sendly (4.3.0)
+    sendly (4.5.0)
       faraday (~> 2.0)
       faraday-retry (~> 2.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    addressable (2.9.0)
+    addressable (2.8.8)
       public_suffix (>= 2.0.2, < 8.0)
     ast (2.4.3)
     bigdecimal (3.3.1)
@@ -36,7 +36,7 @@ GEM
       ast (~> 2.4.1)
       racc
     prism (1.6.0)
-    public_suffix (6.0.2)
+    public_suffix (7.0.0)
     racc (1.8.1)
     rainbow (3.1.1)
     rake (13.3.1)
@@ -74,7 +74,7 @@ GEM
       unicode-emoji (~> 4.1)
     unicode-emoji (4.1.0)
     uri (1.1.1)
-    webmock (3.26.4)
+    webmock (3.26.1)
       addressable (>= 2.8.0)
       crack (>= 0.3.2)
       hashdiff (>= 0.4.0, < 2.0.0)
@@ -92,4 +92,4 @@ DEPENDENCIES
   webmock (~> 3.0)
 
 BUNDLED WITH
-   2.5.23
+   2.6.9

data/README.md

@@ -1153,11 +1153,11 @@ puts status.disabled?
 
 Connect a number you own to WhatsApp, create Meta-reviewed message
 templates, and send via `client.messages.send(channel: "whatsapp", ...)`.
-Connecting is a one-time $19 setup (no monthly fee). The first number always
+Connecting is free (no monthly fee either). The first number always
 ends with a human step: the signup returns a connect URL a person must open in
 a browser and log in with Facebook to link their WhatsApp Business Account.
 More numbers can then be added to that account with a 6-digit code Meta sends
-to the number, with no Facebook step (same $19 fee, refunded if it fails).
+to the number, with no Facebook step (also free).
 
 Sends go through `messages.send(channel: "whatsapp")` and need `sms:send`,
 not `whatsapp:write`. Reads (`signup.get`, templates, the window, senders and
@@ -1191,16 +1191,14 @@ gives its slot back. Note: Meta
 has paused marketing template delivery to US (+1) numbers.
 
 ```ruby
-# 1. Connect a number ($19 one-time; a human must open the connect URL)
+# 1. Connect a number (free; a human must open the connect URL)
 signup = client.whatsapp.signup.create(phone_number: "+15125550123")
 puts "Have your user open: #{signup.connect_url}"
 
 # 2. Poll until active. After the Facebook step the signup is "registering"
 # while WhatsApp activates the number. Activation usually takes a few minutes
 # but can take hours. If it hasn't finished about 6 hours after the session
-# began, the session fails with registration_timeout and the fee is refunded.
-# If the connection fails, the $19 fee is refunded automatically; once a
-# number has connected, a later disconnect gets nothing back.
+# began, the session fails with registration_timeout.
 status = client.whatsapp.signup.get(signup.id)
 puts status.failure_reasons if status.failed?  # e.g. ["waba_mismatch"]
 
@@ -1257,7 +1255,7 @@ puts added.status  # "verifying"
 # code has been submitted it is the newest code since the signup started, so
 # after a resend it still shows the earlier code until the new one arrives.
 # Once WhatsApp has checked a code, only a code that arrived after the last
-# submission or resend is returned. A 502 whatsapp_verification_unavailable
+# submission or resend is returned. A 503 whatsapp_verification_unavailable
 # isn't counted, so the same unchecked code can come back, and submitting it
 # again is safe.
 code = client.whatsapp.signup.get(added.id).verification_code
@@ -1324,7 +1322,7 @@ WhatsApp errors map onto the usual classes:
   while WhatsApp connections are unavailable. Only signup returns it; no send
   does. Nothing is charged, the response carries a `Retry-After: 3600` header,
   and `e.response_body["retryAfter"]` (3600) says how many seconds to wait; the client
-  retries it like any 5xx before raising. After 5 failed, charged signups in
+  retries it like any 5xx before raising. After 5 failed signups in
   24 hours it raises `Sendly::RateLimitError` for 429
   `whatsapp_signup_limit_reached`, which is not retried: try again the next
   day.
@@ -1332,10 +1330,13 @@ WhatsApp errors map onto the usual classes:
   `whatsapp_window_closed`); send a template instead.
 - `whatsapp_send_failed` is a `Sendly::ValidationError` (422) when WhatsApp
   refused the message, which is final (cached under the idempotency key and
-  replayed for 24 hours), and a `Sendly::ServerError` (502) when the message
-  provably never reached the carrier, so it was not sent and is safe to send
-  again; the 502 is never cached and the client retries it first under the
-  same idempotency key. Neither is charged.
+  replayed for 24 hours), and a `Sendly::ServerError` (503) when the message
+  provably never reached WhatsApp, so it was not sent and is safe to resend
+  under the same idempotency key; the 503 is never cached and the client
+  retries it automatically, up to 3 times under the same key, before raising.
+  Neither is charged. With `fallback_to_sms: true`, a 422 means the SMS
+  couldn't go either, and `e.response_body["fallback"]` says why; see
+  [SMS fallback](#sms-fallback).
 - `whatsapp_send_unconfirmed` is a `Sendly::APIError` with `status_code` 409:
   the outcome is unknown. The message was marked failed and refunded but may
   still be delivered, so check before sending it again (it could arrive
@@ -1363,11 +1364,11 @@ WhatsApp errors map onto the usual classes:
   400 `display_name_required` and for 422 `whatsapp_verification_start_failed`
   (WhatsApp refused to verify the number; final), `Sendly::APIError` (409) for
   `whatsapp_signup_in_progress` and `whatsapp_already_enabled`, and
-  `Sendly::ServerError` for 502 `whatsapp_verification_start_failed` (WhatsApp
+  `Sendly::ServerError` for 503 `whatsapp_verification_start_failed` (WhatsApp
   couldn't start verifying the number; start again). Either failure fails the
-  session and refunds its fee. With `business_account_id:` the client never
-  retries a 5xx, a timeout or a dropped connection, because each retry would
-  start a new charged session. A
+  session. With `business_account_id:` the client never retries a 5xx, a
+  timeout or a dropped connection, because each retry would start a new
+  session. A
   Facebook signup for a number
   that is being added by code gets 409 `whatsapp_verification_in_progress`,
   with that session's id in `e.response_body["id"]`.
@@ -1375,9 +1376,9 @@ WhatsApp errors map onto the usual classes:
   `invalid_verification_code` (not 6 digits) and 422
   `whatsapp_verification_code_invalid` (a wrong code, with
   `e.response_body["attemptsRemaining"]`); `Sendly::APIError` (409) for
-  `whatsapp_verification_failed` (after 5 wrong codes the session fails and
-  the fee is refunded), `whatsapp_verification_busy` (try again) and
-  `signup_not_active`; and `Sendly::ServerError` for 502
+  `whatsapp_verification_failed` (after 5 wrong codes the session fails),
+  `whatsapp_verification_busy` (try again) and
+  `signup_not_active`; and `Sendly::ServerError` for 503
   `whatsapp_verification_unavailable` (the attempt isn't counted) and
   `whatsapp_activation_pending` (the code was accepted but connecting didn't
   finish; check back shortly with `signup.get`). The client never retries a
@@ -1387,13 +1388,13 @@ WhatsApp errors map onto the usual classes:
 - `signup.resend` raises `Sendly::RateLimitError` for 429
   `whatsapp_verification_resend_too_soon` at once, with the seconds to wait in
   `e.retry_after`, and `whatsapp_verification_resend_failed` as a
-  `Sendly::ValidationError` (422) or a `Sendly::ServerError` (502).
+  `Sendly::ValidationError` (422) or a `Sendly::ServerError` (503).
 - `senders.upload_profile_photo` raises `Sendly::ValidationError` for 400
   `whatsapp_profile_photo_invalid` (not a JPEG or PNG) and `file_required`,
   and `Sendly::APIError` with `status_code` 413 for
   `whatsapp_profile_photo_too_large`. The photo methods raise
-  `Sendly::ServerError` for 502 `whatsapp_profile_update_failed`, and the
-  conversational component methods for 502
+  `Sendly::ServerError` for 503 `whatsapp_profile_update_failed`, and the
+  conversational component methods for 503
   `whatsapp_conversational_components_fetch_failed` and
   `whatsapp_conversational_components_update_failed`; an invalid list is a
   `Sendly::ValidationError` (400 `invalid_request`) with a message naming the
@@ -1403,10 +1404,78 @@ WhatsApp errors map onto the usual classes:
   (switch voice on for the number first), `Sendly::ValidationError` for 422
   `whatsapp_calling_unavailable` (Meta only allows calling once the account may
   message at least 2,000 people a day and the display name is approved), and
-  `Sendly::ServerError` for 502 `whatsapp_calling_update_failed`.
+  `Sendly::ServerError` for 503 `whatsapp_calling_update_failed`.
 - A sender method for a number that isn't connected raises
   `Sendly::NotFoundError` (404 `whatsapp_sender_not_connected`).
 
+### SMS fallback
+
+Pass `fallback_to_sms: true` and a WhatsApp message that can't be delivered
+goes as an SMS from the same number instead.
+
+```ruby
+begin
+  message = client.messages.send(
+    channel: "whatsapp",
+    to: "+15555550100",
+    from: "+15125550123",
+    text: "Your table is ready!",
+    fallback_to_sms: true
+  )
+  puts message.fallback.status  # "pending", "sent", "failed", "unavailable" or "skipped"
+  puts message.fallback.reason  # "window_closed", "whatsapp_refused" or "whatsapp_failed"
+  if message.fell_back?         # the SMS went instead (message.status is "failed")
+    sms = client.messages.get(message.fallback.message_id)
+    puts sms.fallback_of        # the WhatsApp message's id
+  end
+rescue Sendly::Error => e
+  body = e.response_body || {}
+  case e.code
+  when "sms_fallback_unavailable"
+    # 403: this number can't send SMS to the recipient; nothing was sent
+  when "sms_fallback_not_supported"
+    puts body["reason"] # marketing_template, authentication_template or media_without_caption
+  else
+    raise unless body["fallback"]
+    # 422 whatsapp_window_closed or whatsapp_send_failed: the SMS couldn't go
+    # either. A closed window also carries the WhatsApp message's id.
+    fallback = Sendly::WhatsAppSmsFallback.new(body["fallback"])
+    puts "#{e.code} #{body["id"]} #{fallback.status}: #{fallback.error}"
+  end
+end
+```
+
+- It falls back when the 24-hour window is closed (the SMS goes at once:
+  free-form text and media go only within 24 hours of the customer's last
+  message, templates any time), when WhatsApp refuses the message, or when
+  WhatsApp reports it undeliverable later. Never after WhatsApp reports it
+  delivered or read, and at most once per message.
+- The number must already be able to send SMS to the recipient (a verified
+  toll-free number, or a local number on a 10DLC campaign, to a US or Canada
+  number), or the send is refused with 403 `sms_fallback_unavailable`
+  before anything is sent.
+- Marketing and authentication templates, and media without a caption, can't
+  fall back: 422 `sms_fallback_not_supported`. A utility template falls
+  back as its text header, body and footer with the variables filled in, and
+  its URL and phone buttons as `label: target`; quick replies are dropped and
+  listed in `fallback.content_dropped`.
+- Billing: the WhatsApp charge is refunded (a closed window is never charged)
+  and the SMS is billed as an SMS. A message that fell back at once comes
+  back with `status` `"failed"`, `credits_used` 0 and `fallback.status` `"sent"`; `fallback.credits_used` is
+  what the SMS cost.
+- No SMS goes on a 409 `whatsapp_send_unconfirmed` or a 503
+  `whatsapp_send_failed`. The status is `"unavailable"` when SMS rules stop it
+  (the contact opted out, a promotional-looking text in the recipient's quiet
+  hours, restricted content), with the reason in `fallback.error`, and
+  `"skipped"` for a WhatsApp error an SMS can't fix.
+- There is no time-based fallback: a message WhatsApp accepted but hasn't
+  delivered, for example to a phone that is off, stays `"pending"`, and no SMS
+  goes unless WhatsApp later reports a failure.
+- `messages.get` and `messages.list` return the same fallback on the WhatsApp message, so check a
+  pending one later. The SMS carries `fallback_of`, the WhatsApp message's id.
+
+Guide: [Send WhatsApp with an SMS Fallback](https://sendly.live/docs/whatsapp/send-with-fallback).
+
 ## RCS
 
 Send branded rich messages — text with suggested replies and actions, or
@@ -1750,8 +1819,8 @@ string), `invalid_voice_mode`, `agent_required`,
 the address could not be validated, and `e.response_body["suggested"]` holds
 a corrected address when one was found); `Sendly::APIError` with
 `status_code` 409 for `agent_disabled`, `agent_limit` (20 agents per
-workspace) and `agent_in_use`; and `Sendly::ServerError` for 502
-`voice_attach_failed` and `carrier_refused` and 503 `voice_unavailable`,
+workspace) and `agent_in_use`; and `Sendly::ServerError` for 503
+`voice_attach_failed`, `carrier_refused` and `voice_unavailable`,
 raised after the client has already retried the 5xx on its own. Not every
 `carrier_refused` is worth retrying: when the message says the number
 couldn't be found for emergency registration, retrying won't help, so
@@ -1770,12 +1839,12 @@ begin
 rescue Sendly::AuthenticationError => e
   puts "Invalid API key"
 rescue Sendly::RateLimitError => e
-  if e.response_body&.dig("error") == "too_many_failed_key_attempts"
+  if e.code == "too_many_failed_key_attempts"
     # Repeated wrong API keys from this address locked it out for up to
     # 5 minutes. Fix the key; do not retry until the lockout ends.
     puts "Locked out for #{e.retry_after}s: check the API key"
   else
-    puts "Rate limited (#{e.response_body&.dig('error')}), retry after #{e.retry_after} seconds"
+    puts "Rate limited (#{e.code}), retry after #{e.retry_after} seconds"
   end
 rescue Sendly::InsufficientCreditsError => e
   puts "Add more credits to your account"
@@ -1786,17 +1855,18 @@ rescue Sendly::NotFoundError => e
 rescue Sendly::NetworkError => e
   puts "Network error: #{e.message}"
 rescue Sendly::Error => e
-  puts "Error: #{e.message} (#{e.response_body&.dig('error') || e.code})"
+  puts "Error: #{e.message} (#{e.code})"
 end
 ```
 
 Every error is a `Sendly::Error`, which carries `message`, `code`,
 `status_code`, `details` and `response_body` — the parsed JSON body of the
 API's response, or `nil` for an error raised before the request went out.
-The API's own error code is `e.response_body["error"]`; `code` is the SDK's
-name for the class (`"VALIDATION_ERROR"`, `"RATE_LIMIT_EXCEEDED"` and so on),
-except on `APIError`, where it is the body's `"code"` when there is one. Some
-refusals put more in that body than a message: a 409 `agent_in_use` lists the
+`code` is the API's own error code, such as `"whatsapp_window_closed"` or
+`"sms_fallback_unavailable"` (the body's `"error"`), so refusals with the same
+status can be told apart. When the body names no code, `code` is the SDK's
+name for the class (`"VALIDATION_ERROR"`, `"RATE_LIMIT_EXCEEDED"` and so on).
+Some refusals put more in that body than a message: a 409 `agent_in_use` lists the
 numbers under `"numbers"`, a 422 `invalid_address` carries a corrected
 address under `"suggested"`.
 
@@ -1809,7 +1879,7 @@ endpoint.
 | Class | Raised for |
 |-------|-----------|
 | `Sendly::AuthenticationError` | 401, and a missing or malformed API key at construction |
-| `Sendly::ValidationError` | 400 and 422; `field_errors` holds the API's `errors` list. `status_code` reads 400 for both, so tell them apart by `response_body["error"]` |
+| `Sendly::ValidationError` | 400 and 422; `field_errors` holds the API's `errors` list. `status_code` reads 400 for both, so tell them apart by `code` |
 | `Sendly::InsufficientCreditsError` | 402 |
 | `Sendly::NotFoundError` | 404, including a feature that is not enabled for you |
 | `Sendly::RateLimitError` | 429; `retry_after` in seconds when the API sent one |
@@ -2066,7 +2136,6 @@ client.enterprise.workspaces.list_keys("ws_xxx")
 # Enterprise-level account, credits and billing
 client.enterprise.get_account
 client.enterprise.credits.get
-client.enterprise.credits.deposit(amount: 100_000, description: "Q4 top-up")
 client.enterprise.settings.get_auto_top_up
 client.enterprise.settings.update_auto_top_up(enabled: true, threshold: 1000, amount: 10_000)
 client.enterprise.billing.get_breakdown(period: "30d")

data/lib/sendly/calls_resource.rb

@@ -55,6 +55,7 @@ module Sendly
       ring_timeout callee_declined callee_busy caller_cancelled room_closed_unanswered
       agent_left_unanswered agent_caller_never_joined invalid_number destination_rejected
       max_duration credits_exhausted media_aborted peer_connection_lost room_closed agent_left
+      transferred voicemail voicemail_unavailable
       setup_failed agent_dispatch_failed agent_api_unreachable agent_already_ended
       ended
     ].freeze

data/lib/sendly/errors.rb

@@ -3,7 +3,10 @@
 module Sendly
   # Base error class for all Sendly errors
   class Error < StandardError
-    # @return [String, nil] Error code from the API
+    # @return [String, nil] The API's error code, such as
+    #   +"whatsapp_window_closed"+ or +"sms_fallback_unavailable"+, for an
+    #   error built from an API response that names one. Otherwise the
+    #   class's own code, such as +"VALIDATION_ERROR"+.
     attr_reader :code
 
     # @return [Hash, nil] Additional error details
@@ -40,8 +43,8 @@ module Sendly
 
   # Raised when the API key is invalid or missing
   class AuthenticationError < Error
-    def initialize(message = "Invalid or missing API key")
-      super(message, code: "AUTHENTICATION_ERROR", status_code: 401)
+    def initialize(message = "Invalid or missing API key", code: nil)
+      super(message, code: code || "AUTHENTICATION_ERROR", status_code: 401)
     end
   end
 
@@ -50,16 +53,16 @@ module Sendly
     # @return [Integer, nil] Seconds to wait before retrying
     attr_reader :retry_after
 
-    def initialize(message = "Rate limit exceeded", retry_after: nil)
+    def initialize(message = "Rate limit exceeded", retry_after: nil, code: nil)
       @retry_after = retry_after
-      super(message, code: "RATE_LIMIT_EXCEEDED", status_code: 429)
+      super(message, code: code || "RATE_LIMIT_EXCEEDED", status_code: 429)
     end
   end
 
   # Raised when the account has insufficient credits
   class InsufficientCreditsError < Error
-    def initialize(message = "Insufficient credits")
-      super(message, code: "INSUFFICIENT_CREDITS", status_code: 402)
+    def initialize(message = "Insufficient credits", code: nil)
+      super(message, code: code || "INSUFFICIENT_CREDITS", status_code: 402)
     end
   end
 
@@ -70,16 +73,16 @@ module Sendly
     #   e.g. +[{ "path" => "brand.ein", "message" => "Enter a 9-digit EIN" }]+
     attr_reader :field_errors
 
-    def initialize(message = "Validation failed", field_errors: nil, details: nil)
+    def initialize(message = "Validation failed", field_errors: nil, details: nil, code: nil, status_code: 400)
       @field_errors = field_errors
-      super(message, code: "VALIDATION_ERROR", details: details, status_code: 400)
+      super(message, code: code || "VALIDATION_ERROR", details: details, status_code: status_code)
     end
   end
 
   # Raised when the requested resource is not found
   class NotFoundError < Error
-    def initialize(message = "Resource not found")
-      super(message, code: "NOT_FOUND", status_code: 404)
+    def initialize(message = "Resource not found", code: nil)
+      super(message, code: code || "NOT_FOUND", status_code: 404)
     end
   end
 
@@ -107,38 +110,50 @@ module Sendly
 
   # Raised for server errors (5xx)
   class ServerError < Error
-    def initialize(message = "Server error occurred", status_code: 500)
-      super(message, code: "SERVER_ERROR", status_code: status_code)
+    def initialize(message = "Server error occurred", status_code: 500, code: nil)
+      super(message, code: code || "SERVER_ERROR", status_code: status_code)
     end
   end
 
   # Convert API response to appropriate error
   class ErrorFactory
+    API_ERROR_CODE = /\A[a-z][a-z0-9_]*\z/
+    private_constant :API_ERROR_CODE
+
     def self.from_response(status, body, retry_after_header: nil)
       message = body["message"] || body["error"] || "Unknown error"
-      code = body["code"]
+      code = api_error_code(body)
       details = body["details"]
 
       error = case status
               when 400, 422
-                ValidationError.new(message, details: details, field_errors: body["errors"])
+                ValidationError.new(message, details: details, field_errors: body["errors"], code: code, status_code: status)
               when 401
-                AuthenticationError.new(message)
+                AuthenticationError.new(message, code: code)
               when 402
-                InsufficientCreditsError.new(message)
+                InsufficientCreditsError.new(message, code: code)
               when 404
-                NotFoundError.new(message)
+                NotFoundError.new(message, code: code)
               when 429
                 retry_after = parse_retry_after(retry_after_header) || body["retry_after"] || body["retryAfter"]
-                RateLimitError.new(message, retry_after: retry_after)
+                RateLimitError.new(message, retry_after: retry_after, code: code)
               when 500..599
-                ServerError.new(message, status_code: status)
+                ServerError.new(message, status_code: status, code: code)
               else
                 APIError.new(message, status_code: status, code: code, details: details)
               end
       error.with_response_body(body)
     end
 
+    def self.api_error_code(body)
+      error = body["error"]
+      return error.strip if error.is_a?(String) && error.strip.match?(API_ERROR_CODE)
+
+      code = body["code"]
+      code.is_a?(String) && !code.strip.empty? ? code : nil
+    end
+    private_class_method :api_error_code
+
     def self.parse_retry_after(value)
       text = value.to_s.strip
       return text.to_i if text.match?(/\A\d+\z/)

data/lib/sendly/messages.rb

@@ -62,9 +62,17 @@ module Sendly
     #   { action: { text: ..., postbackData: ..., url: ... } }. Passed
     #   through verbatim, so use the camelCase keys shown. Suggestions have
     #   no SMS form and are dropped on a fallback.
-    # @param fallback_to_sms [Boolean] RCS only: deliver +text+ as plain SMS
+    # @param fallback_to_sms [Boolean] RCS: deliver +text+ as plain SMS
     #   when the recipient can't receive RCS (default true). Pass false to
-    #   fail with 422 +rcs_not_supported_for_recipient+ instead.
+    #   fail with 422 +rcs_not_supported_for_recipient+ instead. WhatsApp:
+    #   default false. With true, a message WhatsApp can't deliver (the
+    #   24-hour window is closed, WhatsApp refuses it, or reports it
+    #   undeliverable later) goes as an SMS from the same number, billed as
+    #   an SMS; +message.fallback+ ({Sendly::WhatsAppSmsFallback}) says what
+    #   happened. The number must already be able to send SMS to the
+    #   recipient (US and Canada), or the API answers 403
+    #   +sms_fallback_unavailable+; marketing and authentication templates,
+    #   and media without a caption, get 422 +sms_fallback_not_supported+.
     # @param idempotency_key [String] Idempotency key for this operation
     #   (1-255 printable ASCII characters). The SDK already generates a key
     #   per logical request automatically, so the server can dedupe the
@@ -78,7 +86,7 @@ module Sendly
     #   WhatsApp the 422 +whatsapp_send_failed+ when WhatsApp refused the
     #   message (final, not retried, not charged; cached under the
     #   idempotency key and replayed for 24 hours)
-    # @raise [Sendly::ServerError] On WhatsApp, the 502 +whatsapp_send_failed+:
+    # @raise [Sendly::ServerError] On WhatsApp, the 503 +whatsapp_send_failed+:
     #   the message provably never reached the carrier, so it was not sent
     #   and is safe to send again. It isn't charged and is never cached, so
     #   the client retries it like any 5xx first under the same idempotency
@@ -130,6 +138,17 @@ module Sendly
     #   puts message.whatsapp.kind   # "template"
     #   puts message.credits_used    # priced by country + category
     #
+    # @example WhatsApp with an SMS fallback
+    #   message = client.messages.send(
+    #     channel: "whatsapp",
+    #     to: "+15551234567",
+    #     from: "+15559876543",
+    #     text: "Your table is ready!",
+    #     fallback_to_sms: true
+    #   )
+    #   puts message.fallback&.status  # "sent" when it went as an SMS
+    #   puts message.fell_back?
+    #
     # @example RCS text with suggested replies and actions
     #   message = client.messages.send(
     #     channel: "rcs",
@@ -189,6 +208,7 @@ module Sendly
         body[:mediaUrls] = media_urls if has_media
         body[:template] = template if template
         body[:metadata] = metadata if metadata
+        body[:fallbackToSms] = fallback_to_sms unless fallback_to_sms.nil?
 
         response = client.post("/messages", body, idempotency_key: idempotency_key)
         return WhatsAppMessage.new(response)

data/lib/sendly/types.rb

@@ -69,6 +69,14 @@ module Sendly
     # @return [String] "sms", "mms", "rcs" or "whatsapp"; "sms" when the response does not say
     attr_reader :message_format
 
+    # @return [Sendly::WhatsAppSmsFallback, nil] On a WhatsApp message sent
+    #   with +fallback_to_sms+, what happened to its SMS fallback
+    attr_reader :fallback
+
+    # @return [String, nil] On an SMS fallback, the id of the WhatsApp
+    #   message it replaced
+    attr_reader :fallback_of
+
     # Message status constants (sending removed - doesn't exist in database)
     STATUSES = %w[queued sent delivered failed bounced retrying].freeze
 
@@ -98,6 +106,8 @@ module Sendly
       @ai_metadata = data["aiMetadata"]
       @media_urls = data["mediaUrls"] || data["media_urls"] || []
       @message_format = data["messageFormat"] || data["message_format"] || "sms"
+      @fallback = data["fallback"].is_a?(Hash) ? WhatsAppSmsFallback.new(data["fallback"]) : nil
+      @fallback_of = data["fallbackOf"] || data["fallback_of"]
     end
 
     # Check if message was delivered
@@ -143,7 +153,9 @@ module Sendly
         metadata: metadata,
         ai_metadata: ai_metadata,
         media_urls: media_urls,
-        message_format: message_format
+        message_format: message_format,
+        fallback: fallback&.to_h,
+        fallback_of: fallback_of
       }.compact
     end
 

data/lib/sendly/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Sendly
-  VERSION = "4.3.0"
+  VERSION = "4.5.0"
 end

data/lib/sendly/voice_resource.rb

@@ -402,7 +402,7 @@ module Sendly
     # @raise [Sendly::NotFoundError] HTTP 404 +number_not_found+ / +agent_not_found+
     # @raise [Sendly::APIError] HTTP 409 +agent_disabled+ (the agent is
     #   switched off), 403 +forbidden+ / +live_key_required+
-    # @raise [Sendly::ServerError] HTTP 502 +voice_attach_failed+ (voice could
+    # @raise [Sendly::ServerError] HTTP 503 +voice_attach_failed+ (voice could
     #   not be switched on; try again) or 503 +voice_unavailable+, after the
     #   client's automatic retries. Either can follow a mode alone on a number
     #   whose voice is off.
@@ -454,7 +454,7 @@ module Sendly
     #   422 +invalid_address+ when the address could not be validated, with a
     #   corrected address (or +nil+) in +e.response_body["suggested"]+
     # @raise [Sendly::NotFoundError] HTTP 404 +number_not_found+
-    # @raise [Sendly::ServerError] HTTP 502 +carrier_refused+ when the
+    # @raise [Sendly::ServerError] HTTP 503 +carrier_refused+ when the
     #   registration was refused, raised after the client has already retried
     #   the 5xx on its own. When the message says the number couldn't be
     #   found for emergency registration, retrying won't help: contact
@@ -691,7 +691,7 @@ module Sendly
   # +agent_disabled+ / +agent_limit+ / +agent_in_use+ (409) and +forbidden+
   # / +live_key_required+ / +insufficient_permissions+ (403); and
   # {Sendly::ServerError} (not an +APIError+) for +voice_attach_failed+ /
-  # +carrier_refused+ (502), +voice_unavailable+ (503) and
+  # +carrier_refused+ / +voice_unavailable+ (503) and
   # +voice_internal_error+ (500). Every API error keeps the parsed body on
   # {Sendly::Error#response_body}. The full list is {Call::ERROR_CODES}.
   #

data/lib/sendly/webhooks.rb

@@ -103,6 +103,11 @@ module Sendly
     EVENT_SHORT_CODE_REJECTED            = "short_code.rejected"
     EVENT_SHORT_CODE_FILED               = "short_code.filed"
     EVENT_SHORT_CODE_LIVE                = "short_code.live"
+    EVENT_SHORT_CODE_SUSPENDED           = "short_code.suspended"
+    EVENT_SHORT_CODE_REACTIVATED         = "short_code.reactivated"
+    EVENT_SHORT_CODE_CANCELLED           = "short_code.cancelled"
+    EVENT_SHORT_CODE_PAYMENT_SUCCEEDED   = "short_code.payment_succeeded"
+    EVENT_SHORT_CODE_PAYMENT_FAILED      = "short_code.payment_failed"
 
     # Source of a list-health event. Frozen enum — new values will be
     # added in minor SDK versions, never removed.

data/lib/sendly/whatsapp_resource.rb

@@ -63,8 +63,8 @@ module Sendly
   # The status of a WhatsApp signup. +status+ is +"initiated"+,
   # +"registering"+ (WhatsApp is activating the number; activation usually
   # takes a few minutes but can take hours, and a session that hasn't
-  # finished about 6 hours after it began fails with +registration_timeout+
-  # and the fee is refunded), +"verifying"+ (a number being added to an
+  # finished about 6 hours after it began fails with +registration_timeout+),
+  # +"verifying"+ (a number being added to an
   # already-connected account, waiting for its code), +"active"+ or
   # +"failed"+. The API does not send +"expired"+,
   # so {#expired?} is never true; it stays for compatibility.
@@ -72,7 +72,8 @@ module Sendly
   # +"active"+ (from the start for a number added by code); it is nil while
   # +"initiated"+ or +"registering"+ and after a failure.
   # +failure_reasons+ is set when the status is +"failed"+, with one code:
-  # +setup_fee_payment_failed+, +signup_abandoned+, +meta_exchange_failed+,
+  # +setup_fee_payment_failed+ (the connection couldn't be started),
+  # +signup_abandoned+, +meta_exchange_failed+,
   # +registration_failed+, +waba_already_connected+, +waba_mismatch+ (the
   # WhatsApp Business Account chosen in the Facebook step doesn't hold the
   # verified number), +registration_timeout+ (activation hadn't finished
@@ -80,7 +81,6 @@ module Sendly
   # +verification_start_failed+ (WhatsApp couldn't start verifying an added
   # number), +verification_failed+ (too many wrong codes) or
   # +verification_expired+ (a verifying session left untouched for an hour).
-  # If the connection fails, the $19 fee is refunded automatically.
   #
   # While the status is +"verifying"+, +verification_method+ (+"sms"+ or
   # +"voice"+) and +verification_attempts_remaining+ are set, and on
@@ -90,7 +90,7 @@ module Sendly
   # started, so after a resend it still shows the earlier code until the new
   # one arrives. Once WhatsApp has checked a code, only a code that arrived
   # after the last submission or resend is returned. A submission answered
-  # with 502 +whatsapp_verification_unavailable+ is not counted, so the same
+  # with 503 +whatsapp_verification_unavailable+ is not counted, so the same
   # unchecked code can come back, and submitting it again with
   # {WhatsAppSignupResource#verify} is safe. All three are nil in any other
   # status.
@@ -420,6 +420,51 @@ module Sendly
     end
   end
 
+  # The SMS fallback of a WhatsApp message sent with +fallback_to_sms: true+.
+  # +status+ is +"pending"+ until WhatsApp's outcome is known, +"sent"+ when
+  # the SMS went, +"failed"+ when the SMS was refused or credits ran out,
+  # +"unavailable"+ when the SMS could no longer be sent from this number,
+  # and +"skipped"+ when the WhatsApp failure isn't one an SMS fixes.
+  # +reason+ is what made the message fall back (+"window_closed"+,
+  # +"whatsapp_refused"+ or +"whatsapp_failed"+). +message_id+ is the SMS
+  # message's id once it exists, +credits_used+ what the SMS cost, +error+
+  # why the SMS didn't go, in plain English, and +content_dropped+ the
+  # template parts with no SMS form, such as +"quick_replies"+. Values the
+  # API adds later come through unchanged.
+  class WhatsAppSmsFallback
+    attr_reader :channel, :status, :reason, :message_id, :credits_used,
+                :error, :content_dropped
+
+    STATUSES = %w[pending sent failed unavailable skipped].freeze
+    REASONS = %w[window_closed whatsapp_refused whatsapp_failed].freeze
+
+    def initialize(data)
+      @channel = data["channel"] || "sms"
+      @status = data["status"]
+      @reason = data["reason"]
+      @message_id = data["messageId"] || data["message_id"]
+      @credits_used = data["creditsUsed"] || data["credits_used"]
+      @error = data["error"]
+      @content_dropped = data["contentDropped"] || data["content_dropped"]
+    end
+
+    def pending?
+      status == "pending"
+    end
+
+    def sent?
+      status == "sent"
+    end
+
+    def to_h
+      {
+        channel: channel, status: status, reason: reason,
+        message_id: message_id, credits_used: credits_used, error: error,
+        content_dropped: content_dropped
+      }.compact
+    end
+  end
+
   # A sent WhatsApp message. Unlike {Message}, +segments+ is always 1
   # (WhatsApp has no segment concept), +text+ is the caption for a media
   # send (pass it as +text+ with +media_urls+) and nil for template sends
@@ -431,10 +476,14 @@ module Sendly
   # utility price of 12 credits. Templates are priced by category and
   # destination country; countries without a listed price use 33
   # (marketing), 12 (utility) and 12 (authentication) credits. A failed
-  # send gives its slot back.
+  # send gives its slot back. +fallback+ is a {WhatsAppSmsFallback} when the
+  # send asked for +fallback_to_sms+: when WhatsApp couldn't take the
+  # message and it went as an SMS instead, +status+ is +"failed"+ and
+  # +fallback.status+ is +"sent"+ (check with {#fell_back?}).
   class WhatsAppMessage
     attr_reader :id, :channel, :message_format, :to, :from, :text, :status,
-                :segments, :credits_used, :whatsapp, :created_at, :metadata
+                :segments, :credits_used, :whatsapp, :created_at, :metadata,
+                :fallback
 
     def initialize(data)
       @id = data["id"]
@@ -449,6 +498,11 @@ module Sendly
       @whatsapp = data["whatsapp"] ? WhatsAppMessageDetails.new(data["whatsapp"]) : nil
       @created_at = data["createdAt"] || data["created_at"]
       @metadata = data["metadata"]
+      @fallback = data["fallback"].is_a?(Hash) ? WhatsAppSmsFallback.new(data["fallback"]) : nil
+    end
+
+    def fell_back?
+      fallback&.sent? || false
     end
 
     def delivered?
@@ -464,7 +518,7 @@ module Sendly
         id: id, channel: channel, message_format: message_format,
         to: to, from: from, text: text, status: status, segments: segments,
         credits_used: credits_used, whatsapp: whatsapp&.to_h,
-        created_at: created_at, metadata: metadata
+        created_at: created_at, metadata: metadata, fallback: fallback&.to_h
       }.compact
     end
   end
@@ -479,34 +533,31 @@ module Sendly
 
     # Start connecting a number to WhatsApp.
     #
-    # Charges a one-time $19 setup fee (no monthly fee) and returns a
+    # Connecting a number is free (no setup or monthly fee). Returns a
     # +connect_url+. Completing the connection requires a human: hand the
     # URL to your user — they open it in a browser and log in with Facebook
     # to link their WhatsApp Business Account. Then poll {#get} until the
     # status is +"active"+.
     #
     # Calling again for a number with an in-flight signup returns the
-    # existing signup (same +connect_url+) without charging again. Requires
+    # existing signup (same +connect_url+). Requires
     # a live API key with the +whatsapp:write+ scope (a test key gets 403
     # +whatsapp_requires_live_key+) and, in a team workspace, an owner or
     # admin (+settings:write+). After the Facebook step the signup stays
     # +"registering"+ while WhatsApp activates the number. Activation usually
     # takes a few minutes but can take hours. If it hasn't finished about 6
     # hours after the session began, the session fails with
-    # +registration_timeout+ and the fee is refunded. If the connection
-    # fails, the $19 fee is refunded automatically; once the number has
-    # connected there is no refund, and a later disconnect gets nothing
-    # back.
+    # +registration_timeout+.
     #
     # To add a number to a WhatsApp Business Account this workspace has
     # already connected, pass its +business_account_id+ (as shown on
     # {WhatsAppSender#business_account_id}). There is no Facebook step and no
-    # +connect_url+: the same $19 fee is charged, Meta sends the number a
+    # +connect_url+: it is free too, Meta sends the number a
     # 6-digit code by text or voice call, and the session is +"verifying"+
     # until you submit the code with {#verify}. Calling again for a number
-    # that is verifying returns the same session without charging again or
-    # sending a second code; a verifying session older than 3 hours is
-    # expired (and refunded) and a new one is started.
+    # that is verifying returns the same session without sending a second
+    # code; a verifying session older than 3 hours is expired and a new one
+    # is started.
     #
     # @param phone_number [String] The number to connect, in E.164 format.
     #   Must be an active number in your workspace.
@@ -521,20 +572,20 @@ module Sendly
     #   +business_account_id+.
     # @return [WhatsAppSignupSession]
     # @raise [Sendly::ServerError] +whatsapp_unavailable+ (503) while
-    #   WhatsApp connections are unavailable. Nothing is charged. Only
+    #   WhatsApp connections are unavailable. Only
     #   signup returns it, with +retryAfter+ 3600 in the body
     #   (+e.response_body["retryAfter"]+) and a +Retry-After: 3600+ header.
     #   The client retries it like any 5xx before raising.
     # @raise [Sendly::RateLimitError] +whatsapp_signup_limit_reached+ (429)
-    #   after 5 failed, charged signups in 24 hours. Not retried; try again
-    #   the next day.
+    #   after 5 failed signups (or 20 cancelled) in 24 hours. Not retried;
+    #   try again the next day.
     # @raise [Sendly::NotFoundError] +whatsapp_business_account_not_found+
     #   (404) when +business_account_id+ isn't connected in this workspace
     #   with an active number.
     # @raise [Sendly::ValidationError] +display_name_required+ (400) when no
     #   display name is given and the account has none to reuse, and
     #   +whatsapp_verification_start_failed+ (422) when WhatsApp refused to
-    #   verify the number: final, the session failed and the fee is refunded.
+    #   verify the number: final, the session failed.
     # @raise [Sendly::APIError] 409 +whatsapp_signup_in_progress+ (a Facebook
     #   connection for the number is in flight; +e.response_body["id"]+ is
     #   that session), 409 +whatsapp_verification_in_progress+ (a Facebook
@@ -543,14 +594,14 @@ module Sendly
     #   still being added, so try again in a moment) or 409
     #   +whatsapp_already_enabled+.
     # @raise [Sendly::InsufficientCreditsError] 402 +payment_method_required+
-    #   or +payment_failed+ when the $19 fee can't be charged.
-    # @raise [Sendly::ServerError] +whatsapp_verification_start_failed+ (502)
-    #   when WhatsApp couldn't start verifying the number: the session failed
-    #   and its fee is refunded, so start again. With +business_account_id+,
-    #   a 5xx is raised at once and never retried by the client, because
-    #   each retry would start a new charged session (a timeout or dropped
-    #   connection is never retried either). Without it the client retries a
-    #   5xx before raising, as before.
+    #   or +payment_failed+: not returned while connecting a number is free.
+    # @raise [Sendly::ServerError] +whatsapp_verification_start_failed+ (503)
+    #   when WhatsApp couldn't start verifying the number: the session failed,
+    #   so start again. With +business_account_id+, a 5xx is raised at once
+    #   and never retried by the client, because each retry would start a
+    #   new session (a timeout or dropped connection is never retried
+    #   either). Without it the client retries a 5xx before raising, as
+    #   before.
     #
     # @example
     #   signup = client.whatsapp.signup.create(phone_number: "+15559876543")
@@ -595,14 +646,14 @@ module Sendly
     #   (422) for a wrong code, with the attempts left in
     #   +e.response_body["attemptsRemaining"]+
     # @raise [Sendly::APIError] 409 +whatsapp_verification_failed+ after 5
-    #   wrong codes (the session failed, the fee is refunded and
+    #   wrong codes (the session failed and
     #   +whatsapp_account.failed+ fires), 409 +whatsapp_verification_busy+
     #   while another code for the number is being checked (try again), or
     #   409 +signup_not_active+ when the signup isn't waiting for a code or is
     #   older than 3 hours
     # @raise [Sendly::NotFoundError] +signup_not_found+ (404)
-    # @raise [Sendly::ServerError] 502 +whatsapp_verification_unavailable+
-    #   (WhatsApp couldn't check the code; the attempt isn't counted) or 502
+    # @raise [Sendly::ServerError] 503 +whatsapp_verification_unavailable+
+    #   (WhatsApp couldn't check the code; the attempt isn't counted) or 503
     #   +whatsapp_activation_pending+ (the code was accepted but connecting
     #   the number didn't finish; check back shortly with {#get}). A 5xx, a
     #   timeout or a dropped connection is raised at once and never retried
@@ -641,7 +692,7 @@ module Sendly
     #   waiting for a code or is older than 3 hours
     # @raise [Sendly::NotFoundError] +signup_not_found+ (404)
     # @raise [Sendly::ServerError] +whatsapp_verification_resend_failed+
-    #   (502) when WhatsApp couldn't be reached. The client retries a 5xx
+    #   (503) when WhatsApp couldn't be reached. The client retries a 5xx
     #   before raising.
     #
     # @example
@@ -793,7 +844,7 @@ module Sendly
     # @raise [Sendly::APIError] +whatsapp_profile_photo_too_large+ with
     #   +status_code+ 413 when the photo is over 5 MB
     # @raise [Sendly::NotFoundError] +whatsapp_sender_not_connected+ (404)
-    # @raise [Sendly::ServerError] +whatsapp_profile_update_failed+ (502)
+    # @raise [Sendly::ServerError] +whatsapp_profile_update_failed+ (503)
     #   when WhatsApp refused the image or couldn't be reached. A 5xx, a
     #   timeout or a dropped connection is raised at once and never retried
     #   by the client; check the image is
@@ -822,7 +873,7 @@ module Sendly
     # @return [WhatsAppSenderProfile] The profile, normally with
     #   +profile_photo_url+ nil
     # @raise [Sendly::NotFoundError] +whatsapp_sender_not_connected+ (404)
-    # @raise [Sendly::ServerError] +whatsapp_profile_update_failed+ (502).
+    # @raise [Sendly::ServerError] +whatsapp_profile_update_failed+ (503).
     #   The client retries a 5xx before raising.
     #
     # @example
@@ -845,7 +896,7 @@ module Sendly
     # @return [WhatsAppConversationalComponents]
     # @raise [Sendly::NotFoundError] +whatsapp_sender_not_connected+ (404)
     # @raise [Sendly::ServerError]
-    #   +whatsapp_conversational_components_fetch_failed+ (502). The client
+    #   +whatsapp_conversational_components_fetch_failed+ (503). The client
     #   retries a 5xx before raising.
     #
     # @example
@@ -879,7 +930,7 @@ module Sendly
     #   +invalid_request+ (400) with a message naming the problem
     # @raise [Sendly::NotFoundError] +whatsapp_sender_not_connected+ (404)
     # @raise [Sendly::ServerError]
-    #   +whatsapp_conversational_components_update_failed+ (502). The client
+    #   +whatsapp_conversational_components_update_failed+ (503). The client
     #   retries a 5xx before raising.
     #
     # @example
@@ -920,7 +971,7 @@ module Sendly
     #   when Meta refused: calling needs the account at the 2,000
     #   recipients a day messaging limit and an approved display name
     # @raise [Sendly::NotFoundError] +whatsapp_sender_not_connected+ (404)
-    # @raise [Sendly::ServerError] +whatsapp_calling_update_failed+ (502).
+    # @raise [Sendly::ServerError] +whatsapp_calling_update_failed+ (503).
     #   The client retries a 5xx before raising.
     #
     # @example
@@ -1099,7 +1150,7 @@ module Sendly
   # create Meta-reviewed message templates, and send via
   # +client.messages.send(channel: "whatsapp", ...)+.
   #
-  # Connecting a number is a one-time $19 setup (no monthly fee). The first
+  # Connecting a number is free (no setup or monthly fee). The first
   # number always ends with a human step: {WhatsAppSignupResource#create}
   # returns a +connect_url+ that a person must open in a browser and log in
   # with Facebook to link their WhatsApp Business Account. More numbers can
@@ -1141,7 +1192,7 @@ module Sendly
   # every method on this resource gets 404 +not_found+.
   #
   # @example Connect a number, create a template, then send
-  #   # 1. Connect ($19 one-time; a human must open the connect URL)
+  #   # 1. Connect (free; a human must open the connect URL)
   #   signup = client.whatsapp.signup.create(phone_number: "+15559876543")
   #   puts "Have your user open: #{signup.connect_url}"
   #

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sendly
 version: !ruby/object:Gem::Version
-  version: 4.3.0
+  version: 4.5.0
 platform: ruby
 authors:
 - Sendly
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-02 00:00:00.000000000 Z
+date: 2026-10-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -159,7 +159,7 @@ metadata:
   source_code_uri: https://github.com/SendlyHQ/sendly-ruby
   changelog_uri: https://github.com/SendlyHQ/sendly-ruby/blob/main/CHANGELOG.md
   documentation_uri: https://sendly.live/docs
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -174,8 +174,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.5
-signing_key: 
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: Official Ruby SDK for the Sendly SMS API
 test_files: []