@getanyapi/sdk 0.22.0 → 0.23.0

package/README.md

@@ -79,6 +79,12 @@ billing. This handwritten discovery client safety-scans the response, projects k
 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.
 
+Every catalog and search result carries the gateway-authored `method`, `path`, and execution
+mode. Lanes carry their public source identity and complete health sample counts when health is
+available. Eligible APIs may carry `tryMaxItems`; ranked search carries the gateway's failover
+facts. `describe` also returns `latency`, either the complete trailing-window p50/p95/p99
+distribution or `null` when no sample is available.
+
 ## Pagination
 
 Paginated SKUs expose an iterator that yields items across pages and follows the cursor for
@@ -162,13 +168,13 @@ No other `409` retries: `idempotency_conflict` (the same key with different inpu
 Automatic network retry of a billed `run()` requires structured runtime evidence that the
 request body was not sent:
 
-| Runtime | Automatic billed-run network retry | Evidence available to the SDK |
-| ------- | ---------------------------------- | ----------------------------- |
-| Node 18+ with built-in undici `fetch` | Yes | DNS and connect codes, connect-phase timeouts, or an undici socket reporting zero bytes written |
-| Bun 1.3.11 | Yes | `ConnectionRefused`, which Bun 1.3.11 emits only while establishing the origin or proxy connection |
-| Cloudflare Workers | No | `retryable: true` means transient, not undelivered; it can appear after the origin received the full body |
-| Deno | No | Fetch exposes only prose without a structured connection code |
-| Browsers | No | Fetch generally exposes an opaque `TypeError` |
+| Runtime                               | Automatic billed-run network retry | Evidence available to the SDK                                                                             |
+| ------------------------------------- | ---------------------------------- | --------------------------------------------------------------------------------------------------------- |
+| Node 18+ with built-in undici `fetch` | Yes                                | DNS and connect codes, connect-phase timeouts, or an undici socket reporting zero bytes written           |
+| Bun 1.3.11                            | Yes                                | `ConnectionRefused`, which Bun 1.3.11 emits only while establishing the origin or proxy connection        |
+| Cloudflare Workers                    | No                                 | `retryable: true` means transient, not undelivered; it can appear after the origin received the full body |
+| Deno                                  | No                                 | Fetch exposes only prose without a structured connection code                                             |
+| Browsers                              | No                                 | Fetch generally exposes an opaque `TypeError`                                                             |
 
 On a runtime without strict non-delivery evidence, the SDK makes no automatic network retry for a
 billed `run()`. HTTP 429 retry is unchanged. Handle other retries explicitly only when your

package/dist/index.cjs

@@ -232,23 +232,92 @@ function pageIdempotencyKey(key, pageNumber) {
 
 // src/core/account.ts
 var DEFAULT_BASE_URL = "https://api.getanyapi.com";
+function mapProfile(raw) {
+  const profile = {
+    id: raw.id,
+    status: raw.status,
+    createdAt: raw.createdAt,
+    onboardingComplete: raw.onboardingComplete
+  };
+  if (raw.email !== void 0 && raw.email !== null) {
+    profile.email = raw.email;
+  }
+  return profile;
+}
+async function agentSignup(options = {}) {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  if (typeof fetchImpl !== "function") {
+    throw new AnyAPIError(
+      "no fetch implementation available: pass options.fetch or run on a runtime with global fetch",
+      0
+    );
+  }
+  const base = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+  const body = {};
+  if (options.sponsorEmail !== void 0) {
+    body["sponsorEmail"] = options.sponsorEmail;
+  }
+  if (options.label !== void 0) {
+    body["label"] = options.label;
+  }
+  let response;
+  try {
+    response = await fetchImpl(`${base}/agent/signup`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+  } catch (err) {
+    throw new ConnectionError(
+      err instanceof Error ? err.message : "connection failed",
+      0
+    );
+  }
+  const requestId = requestIdOf(response.headers);
+  const text = await response.text().catch(() => "");
+  if (response.status !== 200) {
+    let message = `request failed with status ${response.status}`;
+    let code;
+    try {
+      const parsed2 = JSON.parse(text);
+      if (typeof parsed2.error === "string" && parsed2.error !== "") {
+        message = parsed2.error;
+      }
+      if (typeof parsed2.code === "string" && parsed2.code !== "") {
+        code = parsed2.code;
+      }
+    } catch {
+    }
+    throw errorFromStatus(response.status, message, requestId, code);
+  }
+  const parsed = JSON.parse(text);
+  return {
+    secret: parsed.secret,
+    capUsd: parsed.capUsd,
+    claimToken: parsed.claimToken,
+    claimUrl: parsed.claimUrl
+  };
+}
+
+// src/core/discovery-validation.ts
 function malformed(path) {
   throw new AnyAPIError(`malformed discovery response: ${path}`, 0);
 }
-function rejectUnsafeDiscoveryFields(value, path) {
+function rejectUnsafeFields(value, path) {
   if (Array.isArray(value)) {
     value.forEach(
-      (item, index) => rejectUnsafeDiscoveryFields(item, `${path}[${index}]`)
+      (item, index) => rejectUnsafeFields(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}`);
-    if (key === "provider" && item !== "AnyAPI") {
-      malformed(`${path}.${key}`);
-    }
-    rejectUnsafeDiscoveryFields(item, `${path}.${key}`);
+    if (key === "provider" && item !== "AnyAPI") malformed(`${path}.${key}`);
+    rejectUnsafeFields(item, `${path}.${key}`);
   }
 }
 function record(value, path) {
@@ -259,8 +328,7 @@ function record(value, path) {
 }
 function stringField(raw, key, path) {
   const value = raw[key];
-  if (typeof value !== "string") return malformed(`${path}.${key}`);
-  return value;
+  return typeof value === "string" ? value : malformed(`${path}.${key}`);
 }
 function numberField(raw, key, path) {
   const value = raw[key];
@@ -271,7 +339,16 @@ function numberField(raw, key, path) {
 }
 function integerField(raw, key, path) {
   const value = numberField(raw, key, path);
-  if (!Number.isInteger(value)) return malformed(`${path}.${key}`);
+  return Number.isInteger(value) ? value : malformed(`${path}.${key}`);
+}
+function methodField(raw, key, path) {
+  return stringField(raw, key, path) === "POST" ? "POST" : malformed(`${path}.${key}`);
+}
+function pathField(raw, key, path) {
+  const value = stringField(raw, key, path);
+  if (value.length < 2 || !value.startsWith("/") || value.startsWith("//")) {
+    return malformed(`${path}.${key}`);
+  }
   return value;
 }
 function boundedNumberField(raw, key, path, minimumExclusive, maximumInclusive) {
@@ -287,22 +364,17 @@ function parseOffer(value, path) {
   const unit = stringField(raw, "unit", path);
   const maxUsd = numberField(raw, "maxUsd", path);
   if (model === "flat") {
-    if (unit !== "request") {
-      return malformed(path);
-    }
-    return { model, unit, maxUsd };
-  }
-  if (model === "linear") {
-    if (unit.length === 0) return malformed(`${path}.unit`);
-    return {
-      model,
-      unit,
-      baseUsd: numberField(raw, "baseUsd", path),
-      perUnitUsd: numberField(raw, "perUnitUsd", path),
-      maxUsd
-    };
+    return unit === "request" ? { model, unit, maxUsd } : malformed(path);
   }
-  return malformed(`${path}.model`);
+  if (model !== "linear") return malformed(`${path}.model`);
+  if (unit.length === 0) return malformed(`${path}.unit`);
+  return {
+    model,
+    unit,
+    baseUsd: numberField(raw, "baseUsd", path),
+    perUnitUsd: numberField(raw, "perUnitUsd", path),
+    maxUsd
+  };
 }
 function parsePricing(value, path) {
   const raw = record(value, path);
@@ -311,31 +383,64 @@ function parsePricing(value, path) {
     failoverMaxUsd: numberField(raw, "failoverMaxUsd", path)
   };
 }
+function parseExecution(value, path) {
+  const raw = record(value, path);
+  const mode = stringField(raw, "mode", path);
+  return mode === "sync" || mode === "durable" ? { mode } : malformed(`${path}.mode`);
+}
+function parseSource(value, path) {
+  const raw = record(value, path);
+  const kind = stringField(raw, "kind", path);
+  if (kind !== "anonymous" && kind !== "brand")
+    return malformed(`${path}.kind`);
+  return {
+    id: stringField(raw, "id", path),
+    name: stringField(raw, "name", path),
+    kind,
+    artworkKey: stringField(raw, "artworkKey", path)
+  };
+}
 function parseHealth(value, path) {
   const raw = record(value, path);
   return {
     window: stringField(raw, "window", path),
     uptimePct: boundedNumberField(raw, "uptimePct", path, void 0, 100),
     latencyP50Ms: integerField(raw, "latencyP50Ms", path),
-    requests: integerField(raw, "requests", path)
+    uptimeSample: integerField(raw, "uptimeSample", path),
+    latencySample: integerField(raw, "latencySample", path),
+    requests: integerField(raw, "requests", path),
+    servedRequests: integerField(raw, "servedRequests", path)
   };
 }
 function parseLane(value, path) {
   const raw = record(value, path);
   const lane = {
-    pricing: parseOffer(raw["pricing"], `${path}.pricing`)
+    pricing: parseOffer(raw["pricing"], `${path}.pricing`),
+    source: parseSource(raw["source"], `${path}.source`)
   };
-  if (raw["health"] !== void 0) {
+  if (raw["health"] !== void 0)
     lane.health = parseHealth(raw["health"], `${path}.health`);
-  }
   return lane;
 }
-function parseProvider(raw, path) {
-  if (raw["provider"] !== "AnyAPI") return malformed(`${path}.provider`);
-  return "AnyAPI";
+function parseLatency(value, path) {
+  const raw = record(value, path);
+  const basis = stringField(raw, "basis", path);
+  if (basis !== "service_time_excludes_caller_requested_delay") {
+    return malformed(`${path}.basis`);
+  }
+  const sample = integerField(raw, "sample", path);
+  if (sample < 1) return malformed(`${path}.sample`);
+  return {
+    window: stringField(raw, "window", path),
+    p50Ms: integerField(raw, "p50Ms", path),
+    p95Ms: integerField(raw, "p95Ms", path),
+    p99Ms: integerField(raw, "p99Ms", path),
+    sample,
+    basis
+  };
 }
-function parseSchema(value, path) {
-  return record(value, path);
+function parseProvider(raw, path) {
+  return raw["provider"] === "AnyAPI" ? "AnyAPI" : malformed(`${path}.provider`);
 }
 function parseHighlight(value, path) {
   const raw = record(value, path);
@@ -346,31 +451,22 @@ function parseHighlight(value, path) {
   if (raw["why"] !== void 0) field.why = stringField(raw, "why", path);
   return field;
 }
-function mapProfile(raw) {
-  const profile = {
-    id: raw.id,
-    status: raw.status,
-    createdAt: raw.createdAt,
-    onboardingComplete: raw.onboardingComplete
-  };
-  if (raw.email !== void 0 && raw.email !== null) {
-    profile.email = raw.email;
-  }
-  return profile;
-}
+
+// src/core/discovery.ts
 function mapCatalogEntry(raw) {
-  rejectUnsafeDiscoveryFields(raw, "api");
+  rejectUnsafeFields(raw, "api");
   const value = record(raw, "api");
   const lanesRaw = value["lanes"];
-  if (!Array.isArray(lanesRaw)) {
-    return malformed("api.lanes");
-  }
+  if (!Array.isArray(lanesRaw)) return malformed("api.lanes");
   const entry = {
     id: stringField(value, "id", "api"),
     slug: stringField(value, "slug", "api"),
     category: stringField(value, "category", "api"),
     name: stringField(value, "name", "api"),
     description: stringField(value, "description", "api"),
+    method: methodField(value, "method", "api"),
+    path: pathField(value, "path", "api"),
+    execution: parseExecution(value["execution"], "api.execution"),
     provider: parseProvider(value, "api"),
     pricing: parsePricing(value["pricing"], "api.pricing"),
     lanes: lanesRaw.map(
@@ -379,37 +475,42 @@ function mapCatalogEntry(raw) {
     heavy: value["heavy"] === void 0 ? false : value["heavy"] === true,
     tryEligible: value["tryEligible"] === true
   };
-  if (value["heavy"] !== void 0 && typeof value["heavy"] !== "boolean") {
-    return malformed("api.heavy");
+  if (value["heavy"] !== void 0 && typeof value["heavy"] !== "boolean")
+    malformed("api.heavy");
+  if (typeof value["tryEligible"] !== "boolean") malformed("api.tryEligible");
+  if (value["tryMaxItems"] !== void 0) {
+    const tryMaxItems = integerField(value, "tryMaxItems", "api");
+    if (tryMaxItems < 1) malformed("api.tryMaxItems");
+    entry.tryMaxItems = tryMaxItems;
   }
-  if (typeof value["tryEligible"] !== "boolean")
-    return malformed("api.tryEligible");
   if (value["failover"] !== void 0) {
-    if (typeof value["failover"] !== "boolean")
-      return malformed("api.failover");
+    if (typeof value["failover"] !== "boolean") malformed("api.failover");
     entry.failover = value["failover"];
   }
   if (value["excludesCallerDelay"] !== void 0) {
     if (typeof value["excludesCallerDelay"] !== "boolean")
-      return malformed("api.excludesCallerDelay");
+      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 (value["inputSchema"] !== void 0)
+    entry.inputSchema = record(value["inputSchema"], "api.inputSchema");
+  if (value["outputSchema"] !== void 0)
+    entry.outputSchema = record(value["outputSchema"], "api.outputSchema");
+  if (value["latency"] !== void 0) {
+    entry.latency = value["latency"] === null ? null : parseLatency(value["latency"], "api.latency");
   }
   return entry;
 }
 function mapCatalogDetail(raw) {
   const entry = mapCatalogEntry(raw);
+  const value = record(raw, "api");
   if (entry.inputSchema === void 0) return malformed("api.inputSchema");
   if (entry.outputSchema === void 0) return malformed("api.outputSchema");
+  if (!("latency" in value)) return malformed("api.latency");
   return entry;
 }
 function mapCatalogList(raw) {
-  rejectUnsafeDiscoveryFields(raw, "catalog");
+  rejectUnsafeFields(raw, "catalog");
   const envelope = record(raw, "catalog");
   if (!Array.isArray(envelope["apis"])) return malformed("catalog.apis");
   return envelope["apis"].map(mapCatalogEntry);
@@ -422,13 +523,27 @@ function mapSearchResult(value, path) {
     name: stringField(raw, "name", path),
     description: stringField(raw, "description", path),
     category: stringField(raw, "category", path),
+    method: methodField(raw, "method", path),
+    path: pathField(raw, "path", path),
+    execution: parseExecution(raw["execution"], `${path}.execution`),
     provider: parseProvider(raw, path),
     pricing: parsePricing(raw["pricing"], `${path}.pricing`),
+    failover: typeof raw["failover"] === "boolean" ? raw["failover"] : malformed(`${path}.failover`),
     relevance: boundedNumberField(raw, "relevance", path, 0, 1)
   };
+  if (raw["tryMaxItems"] !== void 0) {
+    const tryMaxItems = integerField(raw, "tryMaxItems", path);
+    if (tryMaxItems < 1) malformed(`${path}.tryMaxItems`);
+    result.tryMaxItems = tryMaxItems;
+  }
+  if (raw["excludesCallerDelay"] !== void 0) {
+    if (typeof raw["excludesCallerDelay"] !== "boolean")
+      malformed(`${path}.excludesCallerDelay`);
+    result.excludesCallerDelay = raw["excludesCallerDelay"];
+  }
   if (raw["highlightFields"] !== void 0) {
     if (!Array.isArray(raw["highlightFields"]))
-      return malformed(`${path}.highlightFields`);
+      malformed(`${path}.highlightFields`);
     result.highlightFields = raw["highlightFields"].map(
       (field, index) => parseHighlight(field, `${path}.highlightFields[${index}]`)
     );
@@ -436,7 +551,7 @@ function mapSearchResult(value, path) {
   return result;
 }
 function mapCatalogSearch(raw) {
-  rejectUnsafeDiscoveryFields(raw, "search");
+  rejectUnsafeFields(raw, "search");
   const envelope = record(raw, "search");
   if (!Array.isArray(envelope["results"])) return malformed("search.results");
   const ranking = envelope["ranking"];
@@ -450,63 +565,6 @@ function mapCatalogSearch(raw) {
     ranking
   };
 }
-async function agentSignup(options = {}) {
-  const fetchImpl = options.fetch ?? globalThis.fetch;
-  if (typeof fetchImpl !== "function") {
-    throw new AnyAPIError(
-      "no fetch implementation available: pass options.fetch or run on a runtime with global fetch",
-      0
-    );
-  }
-  const base = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
-  const body = {};
-  if (options.sponsorEmail !== void 0) {
-    body["sponsorEmail"] = options.sponsorEmail;
-  }
-  if (options.label !== void 0) {
-    body["label"] = options.label;
-  }
-  let response;
-  try {
-    response = await fetchImpl(`${base}/agent/signup`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "application/json"
-      },
-      body: JSON.stringify(body)
-    });
-  } catch (err) {
-    throw new ConnectionError(
-      err instanceof Error ? err.message : "connection failed",
-      0
-    );
-  }
-  const requestId = requestIdOf(response.headers);
-  const text = await response.text().catch(() => "");
-  if (response.status !== 200) {
-    let message = `request failed with status ${response.status}`;
-    let code;
-    try {
-      const parsed2 = JSON.parse(text);
-      if (typeof parsed2.error === "string" && parsed2.error !== "") {
-        message = parsed2.error;
-      }
-      if (typeof parsed2.code === "string" && parsed2.code !== "") {
-        code = parsed2.code;
-      }
-    } catch {
-    }
-    throw errorFromStatus(response.status, message, requestId, code);
-  }
-  const parsed = JSON.parse(text);
-  return {
-    secret: parsed.secret,
-    capUsd: parsed.capUsd,
-    claimToken: parsed.claimToken,
-    claimUrl: parsed.claimUrl
-  };
-}
 
 // src/core/client.ts
 var DEFAULT_BASE_URL2 = "https://api.getanyapi.com";