@getanyapi/sdk 0.9.8 → 0.9.9

package/README.md

@@ -73,7 +73,11 @@ console.log(api.pricing.from, api.pricing.failoverMaxUsd, api.inputSchema);
 
 `catalog` is category-only browsing. Ranked queries always use `search`, which returns
 `results`, `total`, and `ranking`; `describe` includes schemas. Discovery prices are nested
-USD flat/linear offers, lanes are anonymous, and provider is always `"AnyAPI"`.
+USD flat/linear offers, lanes are anonymous, and provider is always `"AnyAPI"`. The gateway
+owns validation, routing, lane order, failover, pricing relationships, health semantics, and
+billing. This handwritten discovery client safety-scans the response, projects known fields,
+preserves schemas as opaque JSON, and ignores safe additions. It does not recompute gateway
+business rules. Generated per-SKU methods remain a separate OpenAPI-driven surface.
 
 ## Pagination
 
@@ -113,7 +117,8 @@ await client.google.search(
 );
 ```
 
-Per-call transport overrides: `timeoutMs`, `maxRetries`, and an `AbortSignal` via `signal`.
+Per-call transport overrides: `timeoutMs`, `maxRetries`, `maxInProgressWaitMs`, and an
+`AbortSignal` via `signal`.
 
 ## Errors and retries
 
@@ -129,12 +134,30 @@ Per-call transport overrides: `timeoutMs`, `maxRetries`, and an `AbortSignal` vi
 | `ConnectionError`          | 0    | Network or transport failure               |
 | `TimeoutError`             | 0    | Request exceeded its timeout (not retried) |
 
-All extend `AnyAPIError` (with `status` and `requestId`). Retries cover only 429 and network
-failures proven to happen before a request was sent, with jittered exponential backoff honoring
-`Retry-After`. Default `maxRetries` is 2 (up to 3 attempts); set it on the client or per request.
-Timeouts are never retried. Connection failures during or after a billed `POST /v1/run` are not
-retried because the call may already have been charged. When the send phase is unknown, the SDK
-does not retry. Configure with `new AnyAPI({ timeoutMs, maxRetries })`.
+All extend `AnyAPIError` (with `status` and `requestId`). Retries cover 429, one specific 409
+(below), and network failures proven to happen before a request was sent, with jittered
+exponential backoff honoring `Retry-After`. Default `maxRetries` is 2 (up to 3 attempts); set it
+on the client or per request. Timeouts are never retried. Connection failures during or after a
+billed `POST /v1/run` are not retried because the call may already have been charged. When the
+send phase is unknown, the SDK does not retry. Configure with
+`new AnyAPI({ timeoutMs, maxRetries })`.
+
+### Waiting out a run that is still in flight
+
+Settlement is detached from your connection, so a run keeps going after a connection drops. When
+you re-issue a call whose `Idempotency-Key` is still executing, the gateway answers `409` with
+`code: "idempotency_in_progress"` and `Retry-After: 30`. The SDK waits that full delay and
+retries, so you get the original run's replayed result (`replayed: true`, no second charge)
+instead of an error.
+
+The 8s ordinary-backoff ceiling does not apply here; a separate whole-call budget does.
+`maxInProgressWaitMs` (default `60000`) caps the TOTAL time one `run()` may block on these
+waits, across every retry. A wait that does not fit the remaining budget is refused and the
+`409` is thrown rather than truncated into an attempt that would fail anyway. Set
+`maxInProgressWaitMs: 0` to surface the `409` immediately and handle it yourself.
+
+No other `409` retries: `idempotency_conflict` (the same key with different input) and
+`idempotency_needs_review` are caller-side problems a retry cannot fix.
 
 Automatic network retry of a billed `run()` requires structured runtime evidence that the
 request body was not sent:

package/dist/index.cjs

@@ -218,17 +218,20 @@ var DEFAULT_BASE_URL = "https://api.getanyapi.com";
 function malformed(path) {
   throw new AnyAPIError(`malformed discovery response: ${path}`, 0);
 }
-function rejectInternalKeys(value, path) {
+function rejectUnsafeDiscoveryFields(value, path) {
   if (Array.isArray(value)) {
     value.forEach(
-      (item, index) => rejectInternalKeys(item, `${path}[${index}]`)
+      (item, index) => rejectUnsafeDiscoveryFields(item, `${path}[${index}]`)
     );
     return;
   }
   if (typeof value !== "object" || value === null) return;
   for (const [key, item] of Object.entries(value)) {
     if (key.toLowerCase().includes("credit")) malformed(`${path}.${key}`);
-    rejectInternalKeys(item, `${path}.${key}`);
+    if (key === "provider" && item !== "AnyAPI") {
+      malformed(`${path}.${key}`);
+    }
+    rejectUnsafeDiscoveryFields(item, `${path}.${key}`);
   }
 }
 function record(value, path) {
@@ -237,12 +240,6 @@ function record(value, path) {
   }
   return value;
 }
-function exactKeys(raw, allowed, path) {
-  const keys = new Set(allowed);
-  for (const key of Object.keys(raw)) {
-    if (!keys.has(key)) malformed(`${path}.${key}`);
-  }
-}
 function stringField(raw, key, path) {
   const value = raw[key];
   if (typeof value !== "string") return malformed(`${path}.${key}`);
@@ -273,14 +270,12 @@ function parseOffer(value, path) {
   const unit = stringField(raw, "unit", path);
   const maxUsd = numberField(raw, "maxUsd", path);
   if (model === "flat") {
-    exactKeys(raw, ["model", "unit", "maxUsd"], path);
-    if (unit !== "request" || "baseUsd" in raw || "perUnitUsd" in raw) {
+    if (unit !== "request") {
       return malformed(path);
     }
     return { model, unit, maxUsd };
   }
   if (model === "linear") {
-    exactKeys(raw, ["model", "unit", "baseUsd", "perUnitUsd", "maxUsd"], path);
     if (unit.length === 0) return malformed(`${path}.unit`);
     return {
       model,
@@ -294,7 +289,6 @@ function parseOffer(value, path) {
 }
 function parsePricing(value, path) {
   const raw = record(value, path);
-  exactKeys(raw, ["from", "failoverMaxUsd"], path);
   return {
     from: parseOffer(raw["from"], `${path}.from`),
     failoverMaxUsd: numberField(raw, "failoverMaxUsd", path)
@@ -302,10 +296,8 @@ function parsePricing(value, path) {
 }
 function parseHealth(value, path) {
   const raw = record(value, path);
-  exactKeys(raw, ["window", "uptimePct", "latencyP50Ms", "requests"], path);
-  if (raw["window"] !== "30d") return malformed(`${path}.window`);
   return {
-    window: "30d",
+    window: stringField(raw, "window", path),
     uptimePct: boundedNumberField(raw, "uptimePct", path, void 0, 100),
     latencyP50Ms: integerField(raw, "latencyP50Ms", path),
     requests: integerField(raw, "requests", path)
@@ -313,7 +305,6 @@ function parseHealth(value, path) {
 }
 function parseLane(value, path) {
   const raw = record(value, path);
-  exactKeys(raw, ["pricing", "health"], path);
   const lane = {
     pricing: parseOffer(raw["pricing"], `${path}.pricing`)
   };
@@ -331,7 +322,6 @@ function parseSchema(value, path) {
 }
 function parseHighlight(value, path) {
   const raw = record(value, path);
-  exactKeys(raw, ["path", "type", "why"], path);
   const field = {
     path: stringField(raw, "path", path),
     type: stringField(raw, "type", path)
@@ -352,28 +342,10 @@ function mapProfile(raw) {
   return profile;
 }
 function mapCatalogEntry(raw) {
-  rejectInternalKeys(raw, "api");
+  rejectUnsafeDiscoveryFields(raw, "api");
   const value = record(raw, "api");
-  exactKeys(
-    value,
-    [
-      "id",
-      "slug",
-      "category",
-      "name",
-      "description",
-      "provider",
-      "pricing",
-      "lanes",
-      "heavy",
-      "tryEligible",
-      "inputSchema",
-      "outputSchema"
-    ],
-    "api"
-  );
   const lanesRaw = value["lanes"];
-  if (!Array.isArray(lanesRaw) || lanesRaw.length === 0) {
+  if (!Array.isArray(lanesRaw)) {
     return malformed("api.lanes");
   }
   const entry = {
@@ -395,32 +367,24 @@ function mapCatalogEntry(raw) {
   }
   if (typeof value["tryEligible"] !== "boolean")
     return malformed("api.tryEligible");
+  if (value["failover"] !== void 0) {
+    if (typeof value["failover"] !== "boolean")
+      return malformed("api.failover");
+    entry.failover = value["failover"];
+  }
+  if (value["excludesCallerDelay"] !== void 0) {
+    if (typeof value["excludesCallerDelay"] !== "boolean")
+      return malformed("api.excludesCallerDelay");
+    entry.excludesCallerDelay = value["excludesCallerDelay"];
+  }
   if (value["inputSchema"] !== void 0) {
     entry.inputSchema = parseSchema(value["inputSchema"], "api.inputSchema");
   }
   if (value["outputSchema"] !== void 0) {
     entry.outputSchema = parseSchema(value["outputSchema"], "api.outputSchema");
   }
-  if (!offersEqual(entry.pricing.from, entry.lanes[0].pricing)) {
-    return malformed("api.pricing.from");
-  }
-  const failoverMaxUsd = Math.max(
-    ...entry.lanes.map((lane) => lane.pricing.maxUsd)
-  );
-  if (entry.pricing.failoverMaxUsd !== failoverMaxUsd) {
-    return malformed("api.pricing.failoverMaxUsd");
-  }
   return entry;
 }
-function offersEqual(left, right) {
-  if (left.model !== right.model || left.unit !== right.unit || left.maxUsd !== right.maxUsd) {
-    return false;
-  }
-  if (left.model === "flat" || right.model === "flat") {
-    return left.model === right.model;
-  }
-  return left.baseUsd === right.baseUsd && left.perUnitUsd === right.perUnitUsd;
-}
 function mapCatalogDetail(raw) {
   const entry = mapCatalogEntry(raw);
   if (entry.inputSchema === void 0) return malformed("api.inputSchema");
@@ -428,28 +392,13 @@ function mapCatalogDetail(raw) {
   return entry;
 }
 function mapCatalogList(raw) {
+  rejectUnsafeDiscoveryFields(raw, "catalog");
   const envelope = record(raw, "catalog");
-  exactKeys(envelope, ["apis"], "catalog");
   if (!Array.isArray(envelope["apis"])) return malformed("catalog.apis");
   return envelope["apis"].map(mapCatalogEntry);
 }
 function mapSearchResult(value, path) {
   const raw = record(value, path);
-  exactKeys(
-    raw,
-    [
-      "slug",
-      "platformId",
-      "name",
-      "description",
-      "category",
-      "provider",
-      "pricing",
-      "relevance",
-      "highlightFields"
-    ],
-    path
-  );
   const result = {
     slug: stringField(raw, "slug", path),
     platformId: stringField(raw, "platformId", path),
@@ -470,9 +419,8 @@ function mapSearchResult(value, path) {
   return result;
 }
 function mapCatalogSearch(raw) {
-  rejectInternalKeys(raw, "search");
+  rejectUnsafeDiscoveryFields(raw, "search");
   const envelope = record(raw, "search");
-  exactKeys(envelope, ["results", "total", "ranking"], "search");
   if (!Array.isArray(envelope["results"])) return malformed("search.results");
   const ranking = envelope["ranking"];
   if (ranking !== "semantic" && ranking !== "keyword")
@@ -549,6 +497,8 @@ var DEFAULT_TIMEOUT_MS = 6e4;
 var DEFAULT_MAX_RETRIES = 2;
 var RETRY_BASE_DELAY_MS = 500;
 var RETRY_MAX_DELAY_MS = 8e3;
+var DEFAULT_MAX_IN_PROGRESS_WAIT_MS = 6e4;
+var IDEMPOTENCY_IN_PROGRESS_CODE = "idempotency_in_progress";
 var PRE_SEND_NETWORK_ERROR_CODES = /* @__PURE__ */ new Set([
   "EADDRNOTAVAIL",
   "EAI_AGAIN",
@@ -592,7 +542,7 @@ function backoffDelay(attempt) {
   const factor = 0.5 + Math.random();
   return base * factor;
 }
-function parseRetryAfter(header) {
+function parseRetryAfterMs(header) {
   if (header === null) {
     return void 0;
   }
@@ -602,13 +552,11 @@ function parseRetryAfter(header) {
   }
   const seconds = Number(trimmed);
   if (Number.isFinite(seconds)) {
-    const ms = seconds * 1e3;
-    return Math.min(Math.max(ms, 0), RETRY_MAX_DELAY_MS);
+    return Math.max(seconds * 1e3, 0);
   }
   const dateMs = Date.parse(trimmed);
   if (Number.isFinite(dateMs)) {
-    const delta = dateMs - Date.now();
-    return Math.min(Math.max(delta, 0), RETRY_MAX_DELAY_MS);
+    return Math.max(dateMs - Date.now(), 0);
   }
   return void 0;
 }
@@ -713,6 +661,7 @@ var AnyAPI = class {
   maxRetries;
   timeoutMs;
   idempotency;
+  maxInProgressWaitMs;
   /**
    * The network seam the generated per-platform namespaces target. The base client IS a
    * ClientCore (it implements `run`), so the generated subclass hands `this._core` to each
@@ -735,6 +684,7 @@ var AnyAPI = class {
     this.fetchImpl = resolvedFetch;
     this.maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
     this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.maxInProgressWaitMs = options.maxInProgressWaitMs ?? DEFAULT_MAX_IN_PROGRESS_WAIT_MS;
     const idempotency = options.idempotency ?? "auto";
     if (idempotency !== "auto" && idempotency !== "off") {
       throw new TypeError('idempotency must be "auto" or "off"');
@@ -755,6 +705,7 @@ var AnyAPI = class {
         body,
         timeoutMs: options?.timeoutMs ?? this.timeoutMs,
         maxRetries: options?.maxRetries ?? this.maxRetries,
+        maxInProgressWaitMs: options?.maxInProgressWaitMs ?? this.maxInProgressWaitMs,
         ...options?.idempotencyKey !== void 0 ? { idempotencyKey: options.idempotencyKey } : {},
         ...options?.signal ? { signal: options.signal } : {}
       }
@@ -827,6 +778,11 @@ var AnyAPI = class {
       headers["Idempotency-Key"] = key;
     }
     let attempt = 0;
+    let inProgressWaitedMs = 0;
+    const inProgressBudgetMs = Math.max(
+      opts.maxInProgressWaitMs ?? DEFAULT_MAX_IN_PROGRESS_WAIT_MS,
+      0
+    );
     for (; ; ) {
       const { signal, timeoutSignal } = composeSignal(
         opts.timeoutMs,
@@ -875,13 +831,22 @@ var AnyAPI = class {
       }
       const body = await response.text().catch(() => "");
       const { message, code } = messageFromBody(body, response.status);
+      const retryAfterMs = parseRetryAfterMs(response.headers.get("retry-after"));
       if (response.status === 429 && attempt < opts.maxRetries) {
-        const retryAfter = parseRetryAfter(response.headers.get("retry-after"));
-        const delay = retryAfter ?? backoffDelay(attempt);
+        const delay = retryAfterMs !== void 0 ? Math.min(retryAfterMs, RETRY_MAX_DELAY_MS) : backoffDelay(attempt);
         await sleep(delay, opts.signal);
         attempt += 1;
         continue;
       }
+      if (billedPost && response.status === 409 && code === IDEMPOTENCY_IN_PROGRESS_CODE && attempt < opts.maxRetries) {
+        const delay = retryAfterMs ?? backoffDelay(attempt);
+        if (inProgressWaitedMs + delay <= inProgressBudgetMs) {
+          await sleep(delay, opts.signal);
+          inProgressWaitedMs += delay;
+          attempt += 1;
+          continue;
+        }
+      }
       throw errorFromStatus(response.status, message, requestId, code);
     }
   }