unismsgateway 1.5.1 → 1.5.3

package/README.md

@@ -35,26 +35,30 @@ import { init, getSmsPlatform, reset, smsPlatform } from 'unismsgateway';
 ### `IgatewaySettings`
 
 
-| Field        | Type            | Description                            |
-| ------------ | --------------- | -------------------------------------- |
-| `platformId` | `'route' \| 'hubtel' \| 'nest'` | Which gateway to use. |
-| `param`      | `IgatewayParam` | Provider-specific options (see below). |
+| Field        | Type                          | Description                            |
+| ------------ | ----------------------------- | -------------------------------------- |
+| `platformId` | `'route' | 'hubtel' | 'nest'` | Which gateway to use.                  |
+| `param`      | `IgatewayParam`               | Provider-specific options (see below). |
 
 
 ### `IgatewayParam` (all fields optional except what your `platformId` requires)
 
 
-| Field          | Type      | Used by         | Description                                                            |
-| -------------- | --------- | --------------- | ---------------------------------------------------------------------- |
-| `username`     | `string`  | `route`         | Route Mobile account username. **Required** for `route`.               |
-| `password`     | `string`  | `route`         | Route Mobile account password. **Required** for `route`.               |
-| `host`         | `string`  | `route`, `nest` | API host. See per-gateway defaults below.                              |
-| `port`         | `number`  | `route`         | TCP port for Route Mobile. Default: `8080`.                            |
-| `protocol`     | `'http' \| 'https'` | `route`, `nest` | HTTPS or HTTP to the provider API.                         |
-| `clientId`     | `string`  | `hubtel`        | Hubtel client ID. **Required** for `hubtel`.                           |
-| `clientSecret` | `string`  | `hubtel`        | Hubtel client secret. **Required** for `hubtel`.                       |
-| `apiKey`       | `string`  | `nest`          | SMSOnlineGH API key (`Authorization: key …`). **Required** for `nest`. |
-| `debug`        | `boolean` | all             | If `true`, the active gateway logs each request/response to the console (prefix `[unismsgateway:…]`). Off by default. |
+| Field          | Type               | Used by         | Description                                                                                                                                                                                                 |
+| -------------- | ------------------ | --------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `username`     | `string`           | `route`         | Route Mobile account username. **Required** for `route`.                                                                                                                                                    |
+| `password`     | `string`           | `route`         | Route Mobile account password. **Required** for `route`.                                                                                                                                                    |
+| `host`         | `string`           | `route`, `nest` | API host. See per-gateway defaults below.                                                                                                                                                                   |
+| `port`         | `number`           | `route`         | TCP port for Route Mobile. Default: `8080`.                                                                                                                                                                 |
+| `protocol`     | `'http' | 'https'` | `route`, `nest` | HTTPS or HTTP to the provider API.                                                                                                                                                                          |
+| `clientId`     | `string`           | `hubtel`        | Hubtel client ID. **Required** for `hubtel`.                                                                                                                                                                |
+| `clientSecret` | `string`           | `hubtel`        | Hubtel client secret. **Required** for `hubtel`.                                                                                                                                                            |
+| `apiKey`       | `string`           | `nest`          | SMSOnlineGH API key (`Authorization: key …`). **Required** for `nest`.                                                                                                                                      |
+| `debug`        | `boolean`          | all             | If `true`, the active gateway logs each request/response to the console (prefix `[unismsgateway:…]`). Off by default.                                                                                       |
+| `keepAlive`    | `boolean`          | `nest`          | Enable HTTP keep-alive connection pooling. Reuses TCP/TLS sockets across calls, eliminating per-request handshake overhead. Stale-socket errors are recovered automatically via `retries`. Default: `true`. |
+| `timeout`      | `number`           | `nest`          | Request deadline in milliseconds. The request is aborted with an `ETIMEDOUT` error if the server does not respond within this window. Default: `10000`.                                                     |
+| `maxSockets`   | `number`           | `nest`          | Maximum concurrent sockets in the keep-alive pool. Default: `10`.                                                                                                                                           |
+| `retries`      | `number`           | `nest`          | Automatic retry attempts on transient socket errors (`ECONNRESET`, `ECONNABORTED`, `EPIPE`, `ETIMEDOUT`). Default: `1`.                                                                                     |
 
 
 Validation runs in `smsPlatform` when the instance is constructed: missing required fields for the chosen `platformId` throw `Error` with a clear message.
@@ -79,11 +83,11 @@ There are **two separate contexts**. Use the section that matches what you are d
 Nothing is read from the environment unless **you** wire it. Required fields are determined only by `platformId`:
 
 
-| `platformId` | Required in `param`        | Optional in `param` (defaults in this library)                                                |
-| ------------ | -------------------------- | --------------------------------------------------------------------------------------------- |
-| `nest`       | `apiKey`                   | `host` (default `api.smsonlinegh.com`), `protocol` (default `https`), `debug`                 |
-| `hubtel`     | `clientId`, `clientSecret` | `debug`                                                                                       |
-| `route`      | `username`, `password`     | `host` (default `rslr.connectbind.com`), `protocol` (default `http`), `port` (default `8080`), `debug` |
+| `platformId` | Required in `param`        | Optional in `param` (defaults in this library)                                                                                                                                                    |
+| ------------ | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `nest`       | `apiKey`                   | `host` (default `api.smsonlinegh.com`), `protocol` (default `https`), `debug`, `keepAlive` (default `true`), `timeout` (default `10000` ms), `maxSockets` (default `10`), `retries` (default `1`) |
+| `hubtel`     | `clientId`, `clientSecret` | `debug`                                                                                                                                                                                           |
+| `route`      | `username`, `password`     | `host` (default `rslr.connectbind.com`), `protocol` (default `http`), `port` (default `8080`), `debug`                                                                                            |
 
 
 **Suggested env names for your app** (optional; you can rename them). Credential keys (`NEST_`*, `HUBTEL_`*, `ROUTE_*`) match [live test](#live-integration-test-environment-variables) and `.env.example`. Platform selection differs: the test script requires `GATEWAY_PLATFORM` (or `TEST_ALL`); in your app you choose any name (the example below uses `SMS_PLATFORM_ID`):
@@ -300,20 +304,42 @@ const gateway = unisms.init({
 **Optional `param`:**
 
 
-| Field      | Default if omitted    |
-| ---------- | --------------------- |
-| `host`     | `api.smsonlinegh.com` |
-| `protocol` | `'https'`             |
+| Field        | Default if omitted    | Notes                                                                 |
+| ------------ | --------------------- | --------------------------------------------------------------------- |
+| `host`       | `api.smsonlinegh.com` |                                                                       |
+| `protocol`   | `'https'`             |                                                                       |
+| `keepAlive`  | `true`                | Set to `false` to open a fresh TCP/TLS connection per request.        |
+| `timeout`    | `10000`               | Milliseconds before the request is aborted with `ETIMEDOUT`.          |
+| `maxSockets` | `10`                  | Maximum sockets held open in the keep-alive pool.                     |
+| `retries`    | `1`                   | Retry count for transient errors (`ECONNRESET`, `ECONNABORTED`, etc). |
 
 
-Requests use `POST` to path `**/v5/<endpoint>`** (e.g. send: `message/sms/send`, balance: `account/balance`). Authorization header: `Authorization: key <apiKey>`. Each request opens a fresh connection (keep-alive pooling is disabled) to prevent stale-socket errors in long-running processes.
+Requests use `POST` to path `/v5/<endpoint>` (e.g. send: `message/sms/send`, balance: `account/balance`). Authorization header: `Authorization: key <apiKey>`.
+
+`NestSmsGateway` maintains a private keep-alive connection pool (`https.Agent`) so TCP and TLS handshakes are paid once and subsequent requests reuse warm sockets. If the server closes an idle socket between calls and the first write fails with `ECONNABORTED` or `ECONNRESET`, the library retries automatically on a fresh socket (controlled by `retries`). Set `keepAlive: false` to revert to a per-request connection if your network environment requires it.
+
+The `destroy()` method on `NestSmsGateway` releases all pooled sockets; call it during application shutdown so Node does not hold the event loop open. Access it via `getGateway()`:
+
+```javascript
+const gateway = unisms.init({
+  platformId: 'nest',
+  param: { apiKey: 'your-api-key' }
+});
+
+// On app shutdown:
+gateway.getGateway().destroy();
+```
+
+**Example with performance tuning:**
 
 ```javascript
 const gateway = unisms.init({
   platformId: 'nest',
   param: {
-    apiKey: 'your-api-key'
-    // optional: host, protocol
+    apiKey: 'your-api-key',
+    timeout: 5000,     // abort after 5 s
+    maxSockets: 20,    // higher pool ceiling for burst traffic
+    retries: 2         // extra resilience on flaky networks
   }
 });
 ```
@@ -337,18 +363,20 @@ console.log(balance.balance, balance.model);
 
 ### `QuickSendParams`
 
-| Field     | Type     | Required | Description                                                            |
-| --------- | -------- | -------- | ---------------------------------------------------------------------- |
-| `From`    | `string` | yes      | Sender ID or label.                                                    |
-| `To`      | `string \| number` | yes      | Recipient MSISDN or number.                                            |
-| `Content` | `string` | yes      | Message body.                                                          |
-| `Type`    | `number` | no       | Message type; **nest** maps this to request body `type` (default `0`). |
 
-**camelCase:** You may pass **`from`**, **`to`**, **`content`**, and **`type`** instead of the PascalCase names above. Many JavaScript projects use camelCase; if you pass only `content` and `Content` is missing, the SMSOnlineGH (`nest`) API receives no message body and may return handshake **1305** (`MV_ERR_MESSAGE` — missing or invalid message body). The library normalizes both conventions before calling the gateway.
+| Field     | Type              | Required | Description                                                            |
+| --------- | ----------------- | -------- | ---------------------------------------------------------------------- |
+| `From`    | `string`          | yes      | Sender ID or label.                                                    |
+| `To`      | `string | number` | yes      | Recipient MSISDN or number.                                            |
+| `Content` | `string`          | yes      | Message body.                                                          |
+| `Type`    | `number`          | no       | Message type; **nest** maps this to request body `type` (default `0`). |
+
+
+**camelCase:** You may pass `**from`**, `**to**`, `**content**`, and `**type**` instead of the PascalCase names above. Many JavaScript projects use camelCase; if you pass only `content` and `Content` is missing, the SMSOnlineGH (`nest`) API receives no message body and may return handshake **1305** (`MV_ERR_MESSAGE` — missing or invalid message body). The library normalizes both conventions before calling the gateway.
 
 ### `quickSend(params, callback?)`
 
-Returns `Promise<SendResult>`. Optional `callback` is invoked with the same result when the promise completes. The `params` argument accepts **`QuickSendParams`** (PascalCase) or **`QuickSendParamsCamel`** (`{ from, to, content, type? }`). See **`normalizeQuickSendParams`** in the public API if you need the same mapping outside `quickSend`.
+Returns `Promise<SendResult>`. Optional `callback` is invoked with the same result when the promise completes. The `params` argument accepts `**QuickSendParams`** (PascalCase) or `**QuickSendParamsCamel**` (`{ from, to, content, type? }`). See `**normalizeQuickSendParams**` in the public API if you need the same mapping outside `quickSend`.
 
 `**SendResult`:**
 
@@ -362,7 +390,7 @@ Returns `Promise<SendResult>`. Optional `callback` is invoked with the same resu
 }
 ```
 
-When `success` is `false`, always read **`error`** — it contains a human-readable reason (provider status codes, API handshake labels, network errors, and so on). For **`nest`**, if the API rejects the send but returns JSON, **`data`** is the **full parsed response body** (not only `response.data`), so you can inspect `handshake` and any provider fields. For HTTP errors, `data` may be the raw response body string. **`statusCode`** is set when the adapter knows the HTTP status (for example nest).
+When `success` is `false`, always read `**error**` — it contains a human-readable reason (provider status codes, API handshake labels, network errors, and so on). For `**nest**`, if the API rejects the send but returns JSON, `**data**` is the **full parsed response body** (not only `response.data`), so you can inspect `handshake` and any provider fields. For HTTP errors, `data` may be the raw response body string. `**statusCode`** is set when the adapter knows the HTTP status (for example nest).
 
 **Debugging:** Set `param.debug: true` when calling `init()` to print request URLs, bodies, and responses to the console. The live test script enables debug for the `nest` platform so you can trace `quickSend` and `getBalance` without changing application code.
 
@@ -438,35 +466,50 @@ Full variable reference (selection, per-gateway credentials, live send): [Live i
 ## API reference
 
 
-| Export                     | Description                                                          |
-| -------------------------- | -------------------------------------------------------------------- |
-| `init(settings)`           | Create and register the singleton `smsPlatform`, return it.          |
-| `getSmsPlatform()`         | Current `smsPlatform` or `null` after `reset()` and before `init()`. |
-| `reset()`                  | Clear the singleton.                                                 |
-| `smsPlatform`              | Class type for typing/advanced use.                                  |
-| `QuickSendParamsInput`     | Union: PascalCase `QuickSendParams` or camelCase `QuickSendParamsCamel`. |
-| `QuickSendParamsCamel`     | `{ from, to, content, type? }` for `quickSend`.                      |
+| Export                     | Description                                                                |
+| -------------------------- | -------------------------------------------------------------------------- |
+| `init(settings)`           | Create and register the singleton `smsPlatform`, return it.                |
+| `getSmsPlatform()`         | Current `smsPlatform` or `null` after `reset()` and before `init()`.       |
+| `reset()`                  | Clear the singleton.                                                       |
+| `smsPlatform`              | Class type for typing/advanced use.                                        |
+| `QuickSendParamsInput`     | Union: PascalCase `QuickSendParams` or camelCase `QuickSendParamsCamel`.   |
+| `QuickSendParamsCamel`     | `{ from, to, content, type? }` for `quickSend`.                            |
 | `normalizeQuickSendParams` | Maps input to canonical `QuickSendParams` (throws if body/sender missing). |
 
 
 `**smsPlatform` instance methods**
 
 
-| Method                         | Returns               | Description                                    |
-| ------------------------------ | --------------------- | ---------------------------------------------- |
-| `init()`                       | `ISmsGateway`         | Returns `this` (facade).                       |
+| Method                         | Returns               | Description                                                                      |
+| ------------------------------ | --------------------- | -------------------------------------------------------------------------------- |
+| `init()`                       | `ISmsGateway`         | Returns `this` (facade).                                                         |
 | `quickSend(params, callback?)` | `Promise<SendResult>` | Normalizes PascalCase or camelCase params, then delegates to the active gateway. |
-| `getGateway()`                 | `ISmsGateway`         | Underlying adapter (for nest: `getBalance()`). |
+| `getGateway()`                 | `ISmsGateway`         | Underlying adapter (for nest: `getBalance()`).                                   |
 
 
 ---
 
 ## Changelog
 
+### 1.6.0
+
+- **Performance (`nest`):** The `NestSmsGateway` now uses a persistent keep-alive connection pool (`https.Agent`) instead of opening a fresh TCP + TLS connection on every request. Subsequent sends to the same host reuse warm sockets, eliminating the per-call handshake overhead (~100–300 ms per request).
+- **Reliability (`nest`):** Stale-socket errors (`ECONNRESET`, `ECONNABORTED`, `EPIPE`, `ETIMEDOUT`) that can occur when a pooled socket is reused after the server has closed it are automatically retried on a fresh connection. The default retry count is `1`; configure via `param.retries`.
+- **Timeout support (`nest`):** Requests that stall mid-flight are now aborted after a configurable deadline (`param.timeout`, default `10 000 ms`) instead of hanging indefinitely.
+- **New `param` fields (`nest`):** `keepAlive` (default `true`), `timeout` (default `10000`), `maxSockets` (default `10`), `retries` (default `1`). All are optional and fully backwards-compatible; existing `init()` calls require no changes.
+- **Resource cleanup (`nest`):** `NestSmsGateway` exposes a `destroy()` method (accessible via `getGateway().destroy()`) that releases pooled sockets so Node does not hold the event loop open after the gateway is no longer needed.
+- **Internal (`nest`):** Response chunks are now accumulated as `Buffer[]` and concatenated once at the end, avoiding repeated string re-allocation per chunk. The POST body is serialised to a `Buffer` upfront so `Content-Length` reads `Buffer.length` (O(1)) rather than rescanning the string.
+
+### 1.5.2
+
+- **Build:** TypeScript `rootDir` is now `./src` with `include: ["src/**/*.ts"]` (scripts stay `ts-node`-only). Previously the compiler also picked up `scripts/test-live.ts`, inferred a project root above `src/`, and emitted library code under `dist/src/lib/…` while published entrypoints load `dist/lib/…` — leaving **stale or missing** `dist/lib/nest-gateway.js` (wrong `requestBody` shape). The published `dist/` layout now matches `package.json` `main` and always rebuilds gateway files from current sources.
+
 ### 1.5.1
+
 - **Fix (`nest` / all gateways):** `quickSend` now accepts **camelCase** (`from`, `to`, `content`, `type`) as well as PascalCase (`From`, `To`, `Content`, `Type`). Passing only camelCase previously left `Content` undefined, so the nest JSON body omitted `text` and the API returned handshake **1305** (missing or invalid message body). Validation errors throw clear messages when body or sender is empty after trim.
 
 ### 1.5.0
+
 - **Fix (`nest`):** `quickSend` now reliably works in long-running processes (servers, workers). Node's global HTTP agent reuses keep-alive sockets across calls; when the provider closes an idle socket server-side, the next `quickSend` that writes a request body received `write ECONNABORTED` while `getBalance` (no body) appeared to work fine. Fixed by setting `agent: false` on each request so every call opens a fresh connection rather than reusing a potentially stale one from the pool.
 
 ---

package/dist/lib/lib.d.ts

@@ -1,5 +1,5 @@
-import { smsPlatform, IgatewaySettings, IgatewayParam, PlatformId, QuickSendParams, SendResult, ISmsGateway } from './platform';
+import { smsPlatform, IgatewaySettings, IgatewayParam, PlatformId, QuickSendParams, QuickSendParamsInput, QuickSendParamsCamel, normalizeQuickSendParams, SendResult, ISmsGateway } from './platform';
 export declare function init(settings: IgatewaySettings): smsPlatform;
 export declare function getSmsPlatform(): smsPlatform | null;
 export declare function reset(): void;
-export { smsPlatform, IgatewaySettings, IgatewayParam, PlatformId, QuickSendParams, SendResult, ISmsGateway };
+export { smsPlatform, IgatewaySettings, IgatewayParam, PlatformId, QuickSendParams, QuickSendParamsInput, QuickSendParamsCamel, normalizeQuickSendParams, SendResult, ISmsGateway };

package/dist/lib/lib.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.smsPlatform = exports.reset = exports.getSmsPlatform = exports.init = void 0;
+exports.normalizeQuickSendParams = exports.smsPlatform = exports.reset = exports.getSmsPlatform = exports.init = void 0;
 const platform_1 = require("./platform");
 Object.defineProperty(exports, "smsPlatform", { enumerable: true, get: function () { return platform_1.smsPlatform; } });
+Object.defineProperty(exports, "normalizeQuickSendParams", { enumerable: true, get: function () { return platform_1.normalizeQuickSendParams; } });
 let smsPlatformInstance = null;
 function init(settings) {
     smsPlatformInstance = new platform_1.smsPlatform(settings);

package/dist/lib/nest-gateway.d.ts

@@ -1,8 +1,53 @@
 import { ISmsGateway, QuickSendParams, SendResult, NestSmsConfig } from './types';
 export declare class NestSmsGateway implements ISmsGateway {
-    private config;
+    private readonly _cfg;
+    private _agent;
     constructor(config: NestSmsConfig);
+    /**
+     * Creates a persistent keep-alive connection pool.
+     *
+     * Why keep-alive instead of `agent: false`:
+     *   Each HTTPS request with `agent: false` pays for a full TCP + TLS
+     *   handshake (~100–300 ms). With a pooled agent, subsequent requests to the
+     *   same host reuse an existing socket and skip the handshake entirely.
+     *
+     * Stale-socket problem (original reason for `agent: false`):
+     *   Servers sometimes close idle sockets, making the next reuse fail with
+     *   ECONNABORTED/ECONNRESET. This is handled transparently by the retry
+     *   logic in `makeRequest()` rather than paying the handshake penalty on
+     *   every single call.
+     */
+    private _createAgent;
+    /**
+     * Destroys all sockets held by the connection pool. Call this when the
+     * gateway instance will no longer be used (e.g. during app shutdown) to
+     * prevent Node from holding the event loop open.
+     */
+    destroy(): void;
     init(): ISmsGateway;
+    private log;
+    /**
+     * Performs a single HTTP/S POST to the gateway. Does not retry — see
+     * `makeRequest()` for retry orchestration.
+     *
+     * Key implementation details:
+     * - Post body is serialized once to a `Buffer` so `Content-Length` is read
+     *   directly from `Buffer.length` (O(1)) rather than re-scanning the string
+     *   with `Buffer.byteLength()`.
+     * - Response chunks are accumulated in a `Buffer[]` and concatenated once
+     *   at the end, avoiding repeated string re-allocation per chunk.
+     * - `req.setTimeout()` + `req.destroy()` ensure stalled connections are
+     *   aborted within the configured timeout window.
+     */
+    private _doRequest;
+    /**
+     * Wraps `_doRequest` with automatic retry for transient socket errors.
+     *
+     * When a keep-alive socket is reused and the server has already closed it
+     * on its end, the write fails with ECONNABORTED or ECONNRESET. A single
+     * retry on a fresh socket (which the agent provisions automatically after
+     * destroying the bad one) is sufficient to recover in virtually all cases.
+     */
     private makeRequest;
     quickSend(params: QuickSendParams, callback?: Function): Promise<SendResult>;
     getBalance(): Promise<{

package/dist/lib/nest-gateway.js

@@ -33,111 +33,251 @@ const https = __importStar(require("https"));
 const http = __importStar(require("http"));
 const DEFAULT_HOST = 'api.smsonlinegh.com';
 const DEFAULT_PROTOCOL = 'https';
+const DEFAULT_TIMEOUT = 10000;
+const DEFAULT_MAX_SOCKETS = 10;
+const DEFAULT_RETRIES = 1;
+/**
+ * Error codes that indicate a stale or broken socket rather than a genuine
+ * application-level failure. A single retry on a fresh socket resolves these.
+ */
+const RETRYABLE_CODES = new Set([
+    'ECONNRESET',
+    'ECONNABORTED',
+    'EPIPE',
+    'ENOTCONN',
+    'ETIMEDOUT'
+]);
 class NestSmsGateway {
     constructor(config) {
-        this.config = {
+        var _a, _b, _c;
+        this._cfg = {
             host: config.host || DEFAULT_HOST,
             protocol: config.protocol || DEFAULT_PROTOCOL,
-            apiKey: config.apiKey
+            apiKey: config.apiKey,
+            debug: config.debug || false,
+            timeout: (_a = config.timeout) !== null && _a !== void 0 ? _a : DEFAULT_TIMEOUT,
+            maxSockets: (_b = config.maxSockets) !== null && _b !== void 0 ? _b : DEFAULT_MAX_SOCKETS,
+            retries: (_c = config.retries) !== null && _c !== void 0 ? _c : DEFAULT_RETRIES,
+            keepAlive: config.keepAlive !== false
         };
+        this._agent = this._createAgent();
+    }
+    /**
+     * Creates a persistent keep-alive connection pool.
+     *
+     * Why keep-alive instead of `agent: false`:
+     *   Each HTTPS request with `agent: false` pays for a full TCP + TLS
+     *   handshake (~100–300 ms). With a pooled agent, subsequent requests to the
+     *   same host reuse an existing socket and skip the handshake entirely.
+     *
+     * Stale-socket problem (original reason for `agent: false`):
+     *   Servers sometimes close idle sockets, making the next reuse fail with
+     *   ECONNABORTED/ECONNRESET. This is handled transparently by the retry
+     *   logic in `makeRequest()` rather than paying the handshake penalty on
+     *   every single call.
+     */
+    _createAgent() {
+        const { protocol, maxSockets, keepAlive } = this._cfg;
+        const opts = {
+            keepAlive,
+            maxSockets,
+            maxFreeSockets: Math.ceil(maxSockets / 2)
+        };
+        return protocol === 'https' ? new https.Agent(opts) : new http.Agent(opts);
+    }
+    /**
+     * Destroys all sockets held by the connection pool. Call this when the
+     * gateway instance will no longer be used (e.g. during app shutdown) to
+     * prevent Node from holding the event loop open.
+     */
+    destroy() {
+        this._agent.destroy();
     }
     init() {
         return this;
     }
-    makeRequest(endpoint, data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
-                var _a;
-                const postData = data ? JSON.stringify(data) : '';
-                const protocol = this.config.protocol || DEFAULT_PROTOCOL;
-                const httpModule = protocol === 'https' ? https : http;
-                const defaultPort = protocol === 'https' ? 443 : 80;
-                const options = {
-                    hostname: this.config.host || DEFAULT_HOST,
-                    port: ((_a = this.config.host) === null || _a === void 0 ? void 0 : _a.includes(':'))
-                        ? parseInt(this.config.host.split(':')[1])
-                        : defaultPort,
-                    path: `/v5/${endpoint}`,
-                    method: 'POST',
-                    headers: {
-                        'Host': this.config.host || DEFAULT_HOST,
-                        'Content-Type': 'application/json',
-                        'Accept': 'application/json',
-                        'Authorization': `key ${this.config.apiKey}`,
-                        'Content-Length': Buffer.byteLength(postData)
-                    }
-                };
-                const req = httpModule.request(options, (res) => {
-                    let responseBody = '';
-                    res.on('data', (chunk) => {
-                        responseBody += chunk;
-                    });
-                    res.on('end', () => {
-                        try {
-                            if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
-                                const parsed = JSON.parse(responseBody);
-                                resolve(parsed);
-                            }
-                            else {
-                                reject(new Error(`HTTP ${res.statusCode}: ${responseBody}`));
-                            }
+    log(...args) {
+        if (this._cfg.debug) {
+            console.log('[unismsgateway:nest]', ...args);
+        }
+    }
+    /**
+     * Performs a single HTTP/S POST to the gateway. Does not retry — see
+     * `makeRequest()` for retry orchestration.
+     *
+     * Key implementation details:
+     * - Post body is serialized once to a `Buffer` so `Content-Length` is read
+     *   directly from `Buffer.length` (O(1)) rather than re-scanning the string
+     *   with `Buffer.byteLength()`.
+     * - Response chunks are accumulated in a `Buffer[]` and concatenated once
+     *   at the end, avoiding repeated string re-allocation per chunk.
+     * - `req.setTimeout()` + `req.destroy()` ensure stalled connections are
+     *   aborted within the configured timeout window.
+     */
+    _doRequest(endpoint, data) {
+        return new Promise((resolve, reject) => {
+            const postBuffer = data
+                ? Buffer.from(JSON.stringify(data), 'utf8')
+                : Buffer.alloc(0);
+            const { protocol, timeout } = this._cfg;
+            const httpModule = protocol === 'https' ? https : http;
+            const defaultPort = protocol === 'https' ? 443 : 80;
+            const host = this._cfg.host;
+            const hostname = host.includes(':') ? host.split(':')[0] : host;
+            const port = host.includes(':')
+                ? parseInt(host.split(':')[1], 10)
+                : defaultPort;
+            const options = {
+                hostname,
+                port,
+                path: `/v5/${endpoint}`,
+                method: 'POST',
+                agent: this._agent,
+                headers: {
+                    'Host': hostname,
+                    'Content-Type': 'application/json',
+                    'Accept': 'application/json',
+                    'Authorization': `key ${this._cfg.apiKey}`,
+                    'Content-Length': postBuffer.length
+                }
+            };
+            this.log(`POST /v5/${endpoint}`, data ? JSON.stringify(data) : '(no body)');
+            const req = httpModule.request(options, (res) => {
+                const chunks = [];
+                res.on('data', (chunk) => {
+                    chunks.push(chunk);
+                });
+                res.on('end', () => {
+                    var _a;
+                    const statusCode = (_a = res.statusCode) !== null && _a !== void 0 ? _a : 0;
+                    const responseBody = Buffer.concat(chunks).toString('utf8');
+                    this.log(`HTTP ${statusCode} response:`, responseBody);
+                    try {
+                        const parsed = JSON.parse(responseBody);
+                        if (statusCode >= 200 && statusCode < 300) {
+                            resolve({ statusCode, body: parsed });
                         }
-                        catch (error) {
-                            reject(new Error(`Failed to parse response: ${responseBody}`));
+                        else {
+                            const err = new Error(`HTTP ${statusCode}: ${responseBody}`);
+                            err.statusCode = statusCode;
+                            err.rawBody = responseBody;
+                            reject(err);
                         }
-                    });
-                });
-                req.on('error', (error) => {
-                    reject(error);
+                    }
+                    catch (_b) {
+                        const err = new Error(`Failed to parse gateway response (HTTP ${statusCode}): ${responseBody}`);
+                        err.statusCode = statusCode;
+                        err.rawBody = responseBody;
+                        reject(err);
+                    }
                 });
-                req.write(postData);
-                req.end();
             });
+            req.setTimeout(timeout, () => {
+                const err = new Error(`Request timed out after ${timeout}ms`);
+                err.code = 'ETIMEDOUT';
+                req.destroy(err);
+            });
+            req.on('error', (error) => {
+                this.log('Network error:', error.message);
+                reject(error);
+            });
+            if (postBuffer.length > 0) {
+                req.write(postBuffer);
+            }
+            req.end();
+        });
+    }
+    /**
+     * Wraps `_doRequest` with automatic retry for transient socket errors.
+     *
+     * When a keep-alive socket is reused and the server has already closed it
+     * on its end, the write fails with ECONNABORTED or ECONNRESET. A single
+     * retry on a fresh socket (which the agent provisions automatically after
+     * destroying the bad one) is sufficient to recover in virtually all cases.
+     */
+    makeRequest(endpoint, data, attempt = 0) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this._doRequest(endpoint, data);
+            }
+            catch (error) {
+                const code = error.code;
+                if (code && RETRYABLE_CODES.has(code) && attempt < this._cfg.retries) {
+                    this.log(`Retrying POST /v5/${endpoint} (attempt ${attempt + 1}/${this._cfg.retries}) after ${code}`);
+                    return this.makeRequest(endpoint, data, attempt + 1);
+                }
+                throw error;
+            }
         });
     }
     quickSend(params, callback) {
-        var _a, _b;
+        var _a, _b, _c, _d, _e;
         return __awaiter(this, void 0, void 0, function* () {
-            const endpoint = 'message/sms/send';
             const requestBody = {
-                from: params.From,
-                to: String(params.To),
-                content: params.Content,
-                type: params.Type || 0
+                text: params.Content,
+                type: (_a = params.Type) !== null && _a !== void 0 ? _a : 0,
+                sender: params.From,
+                destinations: [String(params.To)]
             };
+            this.log('quickSend params:', JSON.stringify(params));
+            let result;
             try {
-                const response = yield this.makeRequest(endpoint, requestBody);
-                const result = {
-                    success: ((_a = response.handshake) === null || _a === void 0 ? void 0 : _a.id) === 0,
-                    data: response.data,
-                    messageId: (_b = response.data) === null || _b === void 0 ? void 0 : _b.messageId
-                };
-                if (callback) {
-                    callback(result);
+                const { statusCode, body: response } = yield this.makeRequest('message/sms/send', requestBody);
+                const handshakeId = (_b = response.handshake) === null || _b === void 0 ? void 0 : _b.id;
+                const handshakeLabel = (_c = response.handshake) === null || _c === void 0 ? void 0 : _c.label;
+                const handshakeOk = Number(handshakeId) === 0;
+                const responseData = (_d = response.data) !== null && _d !== void 0 ? _d : null;
+                const batchId = responseData && typeof responseData === 'object'
+                    ? responseData.batch
+                    : undefined;
+                const firstDest = responseData && typeof responseData === 'object'
+                    ? (_e = responseData.destinations) === null || _e === void 0 ? void 0 : _e[0]
+                    : undefined;
+                let errorMsg;
+                if (!handshakeOk) {
+                    if (handshakeLabel) {
+                        errorMsg = `API Error [code ${handshakeId}]: ${handshakeLabel}`;
+                    }
+                    else if (handshakeId !== undefined && handshakeId !== null) {
+                        errorMsg = `API Error: handshake code=${handshakeId}`;
+                    }
+                    else {
+                        errorMsg = `Unexpected API response: ${JSON.stringify(response)}`;
+                    }
                 }
-                return result;
+                result = {
+                    success: handshakeOk,
+                    messageId: batchId || (firstDest === null || firstDest === void 0 ? void 0 : firstDest.id),
+                    data: handshakeOk ? responseData : response,
+                    error: errorMsg,
+                    statusCode
+                };
             }
             catch (error) {
+                const httpErr = error;
                 const errorMessage = error instanceof Error ? error.message : String(error);
-                const result = {
+                result = {
                     success: false,
-                    error: errorMessage
+                    error: errorMessage,
+                    statusCode: httpErr.statusCode,
+                    data: httpErr.rawBody !== undefined ? httpErr.rawBody : null
                 };
-                if (callback) {
-                    callback(result);
-                }
-                return result;
             }
+            this.log('quickSend result:', JSON.stringify(result));
+            if (callback) {
+                callback(result);
+            }
+            return result;
         });
     }
     getBalance() {
-        var _a, _b;
+        var _a, _b, _c, _d;
         return __awaiter(this, void 0, void 0, function* () {
-            const endpoint = 'account/balance';
-            const response = yield this.makeRequest(endpoint);
+            this.log('getBalance called');
+            const { body: response } = yield this.makeRequest('account/balance');
             return {
-                balance: ((_a = response.data) === null || _a === void 0 ? void 0 : _a.balance) || 0,
-                model: ((_b = response.data) === null || _b === void 0 ? void 0 : _b.model) || 'quantity'
+                balance: (_b = (_a = response.data) === null || _a === void 0 ? void 0 : _a.balance) !== null && _b !== void 0 ? _b : 0,
+                model: (_d = (_c = response.data) === null || _c === void 0 ? void 0 : _c.model) !== null && _d !== void 0 ? _d : 'quantity'
             };
         });
     }