@hackerrank/astra-cli 0.1.24 → 0.1.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hackerrank/astra-cli",
-  "version": "0.1.24",
+  "version": "0.1.25",
   "description": "Minimal zero-dependency AI coding agent for the HackerRank AI Gateway.",
   "type": "module",
   "bin": {

package/src/model.js

@@ -42,7 +42,7 @@ export class GatewayModel {
    * @param {number} [opts.maxRetries]
    * @param {(info:object)=>void} [opts.onRetry] called before each retry sleep
    */
-  constructor({ model, baseUrl, apiKey, modelKwargs = {}, maxRetries = 5, maxTokens = 8192, requestTimeoutMs = 0, onRetry } = {}) {
+  constructor({ model, baseUrl, apiKey, modelKwargs = {}, maxRetries = 8, maxTokens = 8192, requestTimeoutMs = 0, onRetry } = {}) {
     if (!model) throw new Error("GatewayModel: `model` is required");
     this.model = model;
     this.maxTokens = maxTokens;
@@ -124,14 +124,15 @@ export class GatewayModel {
           // Retry on transient server / rate-limit errors with exponential
           // backoff (honoring Retry-After when the server provides it).
           if ((res.status === 429 || res.status >= 500) && attempt < this.maxRetries) {
-            const wait = retryAfterMs(res.headers) ?? backoffMs(attempt);
+            const serverWait = retryAfterMs(res.headers, text);
+            const wait = serverWait != null ? Math.max(serverWait + 250, 1000) : backoffMs(attempt);
             this.nRetries++;
             this.onRetry({
               attempt: attempt + 1,
               maxRetries: this.maxRetries,
               status: res.status,
               waitMs: wait,
-              reason: `HTTP ${res.status}`,
+              reason: res.status === 429 ? "HTTP 429 (rate limited)" : `HTTP ${res.status}`,
             });
             await sleep(wait);
             continue;
@@ -282,14 +283,180 @@ function hintForStatus(status) {
   }
 }
 
-/** Parse a Retry-After header (seconds or HTTP-date) into milliseconds. */
-function retryAfterMs(headers) {
-  const v = headers?.get?.("retry-after");
-  if (!v) return null;
-  const secs = Number(v);
-  if (Number.isFinite(secs)) return Math.max(0, secs * 1000);
-  const when = Date.parse(v);
-  if (Number.isFinite(when)) return Math.max(0, when - Date.now());
+/**
+ * Parse a duration string, number, or date into milliseconds.
+ * Supports numbers (seconds or timestamps), units (ms, s, m, h, d),
+ * composite durations ("1m 30s"), and HTTP/ISO dates.
+ */
+export function parseDurationMs(val) {
+  if (typeof val === "number" && Number.isFinite(val) && val >= 0) {
+    if (val > 1e11) return Math.max(0, val - Date.now());
+    if (val > 1e9) return Math.max(0, val * 1000 - Date.now());
+    return Math.max(0, Math.round(val * 1000));
+  }
+  if (!val || typeof val !== "string") return null;
+  const s = val.trim();
+
+  const rawNum = Number(s);
+  if (Number.isFinite(rawNum) && rawNum >= 0) {
+    if (rawNum > 1e11) return Math.max(0, rawNum - Date.now());
+    if (rawNum > 1e9) return Math.max(0, rawNum * 1000 - Date.now());
+    return Math.max(0, Math.round(rawNum * 1000));
+  }
+
+  const when = Date.parse(s);
+  if (Number.isFinite(when) && when > Date.now()) {
+    return Math.max(0, when - Date.now());
+  }
+
+  const pattern = /([0-9]+(?:\.[0-9]+)?)\s*(milliseconds?|millis?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d)\b/gi;
+  let match;
+  let totalMs = 0;
+  let matched = false;
+  while ((match = pattern.exec(s)) !== null) {
+    matched = true;
+    const n = parseFloat(match[1]);
+    const unit = match[2].toLowerCase();
+    if (!Number.isFinite(n)) continue;
+    if (unit.startsWith("ms") || unit.startsWith("milli")) {
+      totalMs += n;
+    } else if (unit.startsWith("s")) {
+      totalMs += n * 1000;
+    } else if (unit.startsWith("m")) {
+      totalMs += n * 60 * 1000;
+    } else if (unit.startsWith("h")) {
+      totalMs += n * 3600 * 1000;
+    } else if (unit.startsWith("d")) {
+      totalMs += n * 86400 * 1000;
+    }
+  }
+  return matched ? Math.round(totalMs) : null;
+}
+
+/**
+ * Extract retry duration from unstructured error message text.
+ * Matches phrases like "retry after 12.5s", "try again in 5 seconds", "resets in 30s", "wait 10s".
+ */
+export function extractDurationFromText(text) {
+  if (!text || typeof text !== "string") return null;
+
+  const p1 = /(?:retry(?:ing)?|try\s+again|wait(?:ing)?|resets?|available|back\s*off)\s+(?:again\s+)?(?:after|in|for)\s+([0-9]+(?:\.[0-9]+)?\s*(?:milliseconds?|millis?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d)\b(?:\s+[0-9]+(?:\.[0-9]+)?\s*(?:milliseconds?|millis?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d)\b)*|[0-9]+(?:\.[0-9]+)?)/i;
+  const m1 = text.match(p1);
+  if (m1) {
+    const parsed = parseDurationMs(m1[1]);
+    if (parsed != null) return parsed;
+  }
+
+  const p2 = /(?:wait(?:ing)?)\s+([0-9]+(?:\.[0-9]+)?\s*(?:milliseconds?|millis?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d)\b)/i;
+  const m2 = text.match(p2);
+  if (m2) {
+    const parsed = parseDurationMs(m2[1]);
+    if (parsed != null) return parsed;
+  }
+
+  const p3 = /in\s+([0-9]+(?:\.[0-9]+)?\s*(?:milliseconds?|millis?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d)\b)\s*[,.]?\s*(?:please\s+)?(?:retry|try)/i;
+  const m3 = text.match(p3);
+  if (m3) {
+    const parsed = parseDurationMs(m3[1]);
+    if (parsed != null) return parsed;
+  }
+
+  return null;
+}
+
+/**
+ * Parse retry delay from response headers or error response body into milliseconds.
+ * Checks standard and provider-specific rate-limit headers as well as JSON fields
+ * and error messages returned by AI gateways (HackerRank, OpenAI, Anthropic, LiteLLM, Gemini, etc.).
+ */
+export function retryAfterMs(headers, bodyText) {
+  const msHeader = headers?.get?.("retry-after-ms");
+  if (msHeader) {
+    const ms = Number(msHeader);
+    if (Number.isFinite(ms) && ms >= 0) return Math.round(ms);
+  }
+
+  const headerKeys = [
+    "retry-after",
+    "x-retry-after",
+    "x-ratelimit-reset-requests",
+    "x-ratelimit-reset-tokens",
+    "x-ratelimit-reset",
+  ];
+  for (const k of headerKeys) {
+    const val = headers?.get?.(k);
+    if (val) {
+      const parsed = parseDurationMs(val);
+      if (parsed != null) return parsed;
+    }
+  }
+
+  if (bodyText) {
+    let json = null;
+    if (typeof bodyText === "object") {
+      json = bodyText;
+    } else if (typeof bodyText === "string") {
+      try {
+        json = JSON.parse(bodyText);
+      } catch {}
+    }
+
+    if (json && typeof json === "object") {
+      const msCandidates = [json.retry_after_ms, json.error?.retry_after_ms];
+      for (const c of msCandidates) {
+        if (Number.isFinite(Number(c)) && Number(c) >= 0) {
+          return Math.round(Number(c));
+        }
+      }
+
+      const durationCandidates = [
+        json.retry_after,
+        json.retryAfter,
+        json.retry_after_seconds,
+        json.retry_after_sec,
+        json.reset_in,
+        json.reset_after,
+        json.reset_at,
+        json.wait_seconds,
+        json.wait_time,
+        json.error?.retry_after,
+        json.error?.retryAfter,
+        json.error?.retry_after_seconds,
+        json.error?.retry_after_sec,
+        json.error?.reset_in,
+        json.error?.reset_after,
+        json.error?.reset_at,
+        json.error?.wait_seconds,
+        json.error?.wait_time,
+      ];
+      for (const c of durationCandidates) {
+        if (c != null) {
+          const parsed = parseDurationMs(c);
+          if (parsed != null) return parsed;
+        }
+      }
+
+      const msgCandidates = [
+        json.error?.message,
+        typeof json.error === "string" ? json.error : null,
+        json.message,
+        json.detail,
+        typeof json.details === "string" ? json.details : null,
+      ];
+      for (const msg of msgCandidates) {
+        if (msg) {
+          const extracted = extractDurationFromText(msg);
+          if (extracted != null) return extracted;
+        }
+      }
+    }
+
+    if (typeof bodyText === "string") {
+      const extracted = extractDurationFromText(bodyText);
+      if (extracted != null) return extracted;
+    }
+  }
+
   return null;
 }