conduyt-mcp 4.83.0 → 4.84.0

package/README.md

@@ -387,6 +387,8 @@ object too large for the bound is left out and named in `_omitted`. Every HTTP r
 Conduyt API 503: Contact merge in progress [Retry-After: 5s] {"code":"merge_in_progress"}
 ```
 
+The contact merge route (`POST /contacts/merge`, no tool today) answers a retryable 503 with `Retry-After` and the code `merge_contacts_busy` (a contact stayed busy for the whole lock budget) or `merge_budget_exhausted` (the request's time budget ran out), nothing changed. Any tool that reaches it surfaces the refusal in this grammar and never retries it (one API job per key); the caller retries after the stated seconds.
+
 ## Setup
 
 ```bash

package/dist/client.d.ts

@@ -37,6 +37,13 @@ export interface RequestOptions {
  * ALWAYS_WHOLE_KEYS; a nested object that does not fit is left out and named in `_omitted`. JSON is never cut mid-object.
  */
 export declare function renderErrorDetails(body: Record<string, unknown>): string;
+/**
+ * The ONE Retry-After parser. RFC 9110: delay-seconds (digits; a value too long for a number saturates at 2^31-1) or an
+ * HTTP-date in one of the three §5.6.7 forms, parsed explicitly and always as UTC (never the host timezone): IMF-fixdate,
+ * RFC 850 (two-digit year: more than 50 years ahead of `nowMs` means the previous century) and asctime. A date becomes the
+ * remaining seconds, floored at 0. Absent, blank or anything else (ISO timestamps, other zones, "-3") is null.
+ */
+export declare function parseRetryAfter(raw: string | null | undefined, nowMs?: number): number | null;
 export declare class ConduytClient {
     private baseUrl;
     private apiKey;

package/dist/client.js

@@ -104,6 +104,58 @@ export function renderErrorDetails(body) {
         out._omitted = omitted;
     return JSON.stringify(out);
 }
+const RA_MAX_SECONDS = 2_147_483_647; // delay-seconds is unbounded 1*DIGIT: a longer value saturates here instead of becoming null
+const RA_MONTHS = { Jan: 0, Feb: 1, Mar: 2, Apr: 3, May: 4, Jun: 5, Jul: 6, Aug: 7, Sep: 8, Oct: 9, Nov: 10, Dec: 11 };
+const RA_MON = "Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec";
+const RA_IMF = new RegExp(`^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), (\\d{2}) (${RA_MON}) (\\d{4}) (\\d{2}):(\\d{2}):(\\d{2}) GMT$`);
+const RA_850 = new RegExp(`^(?:Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), (\\d{2})-(${RA_MON})-(\\d{2}) (\\d{2}):(\\d{2}):(\\d{2}) GMT$`);
+const RA_ASC = new RegExp(`^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun) (${RA_MON}) ([ \\d]\\d) (\\d{2}):(\\d{2}):(\\d{2}) (\\d{4})$`);
+/** A UTC timestamp for the parts, or NaN when any part is out of range (31 Feb, 25:00, ...). */
+function raUtc(y, mo, d, h, mi, s) {
+    if (y < 1900 || h > 23 || mi > 59 || s > 60)
+        return NaN; // RFC 5322: years below 1900 are not dates
+    const t = Date.UTC(y, mo, d, h, mi, Math.min(s, 59));
+    const back = new Date(t);
+    return back.getUTCFullYear() === y && back.getUTCMonth() === mo && back.getUTCDate() === d ? t : NaN;
+}
+/**
+ * The ONE Retry-After parser. RFC 9110: delay-seconds (digits; a value too long for a number saturates at 2^31-1) or an
+ * HTTP-date in one of the three §5.6.7 forms, parsed explicitly and always as UTC (never the host timezone): IMF-fixdate,
+ * RFC 850 (two-digit year: more than 50 years ahead of `nowMs` means the previous century) and asctime. A date becomes the
+ * remaining seconds, floored at 0. Absent, blank or anything else (ISO timestamps, other zones, "-3") is null.
+ */
+export function parseRetryAfter(raw, nowMs = Date.now()) {
+    if (raw === null || raw === undefined)
+        return null;
+    const v = raw.trim();
+    if (v === "")
+        return null;
+    if (/^\d+(\.\d+)?$/.test(v)) {
+        const n = Number(v);
+        return Number.isNaN(n) ? null : Math.min(n, RA_MAX_SECONDS);
+    }
+    let t = NaN;
+    let m;
+    if ((m = RA_IMF.exec(v)))
+        t = raUtc(Number(m[3]), RA_MONTHS[m[2]], Number(m[1]), Number(m[4]), Number(m[5]), Number(m[6]));
+    else if ((m = RA_850.exec(v))) {
+        const century = Math.floor(new Date(nowMs).getUTCFullYear() / 100) * 100;
+        const mo = RA_MONTHS[m[2]], d = Number(m[1]), h = Number(m[4]), mi = Number(m[5]), sec = Number(m[6]);
+        t = raUtc(century + Number(m[3]), mo, d, h, mi, sec);
+        // RFC 9110: a timestamp more than 50 years in the future (the same instant 50 calendar years on, UTC) is the previous century
+        // (the day is clamped to the month's last day: 29 Feb + 50 years is 28 Feb, never 1 Mar)
+        const n = new Date(nowMs);
+        const ly = n.getUTCFullYear() + 50, lm = n.getUTCMonth();
+        const limit = Date.UTC(ly, lm, Math.min(n.getUTCDate(), new Date(Date.UTC(ly, lm + 1, 0)).getUTCDate()), n.getUTCHours(), n.getUTCMinutes(), n.getUTCSeconds(), n.getUTCMilliseconds());
+        if (!Number.isNaN(t) && t > limit)
+            t = raUtc(century - 100 + Number(m[3]), mo, d, h, mi, sec);
+    }
+    else if ((m = RA_ASC.exec(v)))
+        t = raUtc(Number(m[6]), RA_MONTHS[m[1]], Number(m[2].trim()), Number(m[3]), Number(m[4]), Number(m[5]));
+    if (Number.isNaN(t))
+        return null;
+    return Math.max(0, Math.ceil((t - nowMs) / 1000));
+}
 export class ConduytClient {
     baseUrl;
     apiKey;
@@ -240,9 +292,9 @@ export class ConduytClient {
      * until the rest of the text is valid JSON (a server message may itself contain a brace).
      */
     httpError(res, text) {
-        const retryAfterRaw = res.headers.get("retry-after");
-        const retryAfter = retryAfterRaw === null || retryAfterRaw.trim() === "" ? NaN : Number(retryAfterRaw);
-        const retryAfterOk = Number.isFinite(retryAfter) && retryAfter >= 0;
+        const retryAfterParsed = parseRetryAfter(res.headers.get("retry-after"));
+        const retryAfter = retryAfterParsed ?? NaN;
+        const retryAfterOk = retryAfterParsed !== null;
         const raTag = retryAfterOk ? ` [Retry-After: ${retryAfter}s]` : "";
         let msg = res.statusText;
         try {
@@ -275,8 +327,8 @@ export class ConduytClient {
         });
     }
     retryDelayMs(res, attemptIndex) {
-        const retryAfter = Number(res?.headers.get("retry-after"));
-        if (Number.isFinite(retryAfter) && retryAfter >= 0) {
+        const retryAfter = parseRetryAfter(res?.headers.get("retry-after") ?? null);
+        if (retryAfter !== null) {
             return Math.min(retryAfter * 1000, MAX_RETRY_AFTER_MS);
         }
         return Math.min(this.retryBaseMs * 2 ** attemptIndex, MAX_RETRY_AFTER_MS);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "conduyt-mcp",
-  "version": "4.83.0",
+  "version": "4.84.0",
   "mcpName": "com.conduyt/mcp",
   "description": "MCP server for Conduyt CRM — expose CRM operations as AI-accessible tools",
   "type": "module",