agent402-openclaw 0.5.1 → 0.5.3

package/README.md

@@ -37,8 +37,22 @@ prompts but is never made primary (OpenClaw would refuse every turn as a
 context overflow). The plugin starts a loopback proxy (`127.0.0.1:8412`) that
 pays Agent402 and forwards; OpenClaw only ever sees a local OpenAI-compatible URL.
 
-Tested in CI against a real `openclaw@latest` install: plugin install, setup,
-model listing, gateway boot and one agent turn (`test-real-install.js`).
+The plugin is also on ClawHub: `openclaw plugins install clawhub:agent402-openclaw`
+installs the same package and shows its ClawHub security audit first.
+
+OpenClaw 2026.10.1 and later reserve the verified-source badge for plugins in
+OpenClaw's own official inventory, so `openclaw plugins doctor` and `plugins
+inspect` list agent402 with "OpenClaw can't verify where this plugin came from
+... reason=provenance-invalid" whichever way it was installed (npm, ClawHub or a
+local archive). That notice is OpenClaw's verdict on every community plugin. The
+plugin loads, the gateway starts its proxy and turns are served as before: it
+registers a model provider and a service, and uses no feature OpenClaw keeps for
+trusted plugins.
+
+Tested in CI against real OpenClaw installs (the newest proven release and the
+one before it, plus a daily run against the newest published one): plugin
+install from a packed archive and from the npm registry, doctor, setup, model
+listing, gateway boot and one agent turn (`test-real-install.js`).
 
 No OpenClaw? `agent402-openclaw proxy` runs the proxy alone; point any OpenAI
 client at `http://127.0.0.1:8412/v1` with model `auto`.
@@ -115,7 +129,7 @@ MCP or HTTP, wallet-keyed memory, finished reports (dossiers, insider flow, 13F,
 domain audits, token risk, deep research) and monitors, plus routing that buys
 from external sellers and resells the result.
 
-Why pay here, with every claim linked to its proof: https://agent402.tools/why.
+Why pay here, with every claim linked to its proof: https://agent402.tools/#why.
 Usage is priced under a ceiling quoted before you pay, a failed call is not
 charged and the receipt proves it, a keyed retry on a credits key is not
 debited twice, and uptime and transactions are published from outside

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent402-openclaw",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "description": "OpenClaw model provider for Agent402: an auto-routed tier at a flat per-call price and explicit LLM models priced per request, paid in USDC over x402 or with a prepaid credits key through a local proxy. Zero dependencies; x402 wallet payment is an optional peer.",
   "type": "module",
   "main": "index.js",

package/proxy.js

@@ -47,9 +47,52 @@ export const DEFAULT_UPSTREAM = "https://agent402.tools";
 export const PKG_VERSION = JSON.parse(readFileSync(new URL("./package.json", import.meta.url), "utf8")).version;
 const MAX_BODY = 2 * 1024 * 1024;
 
+// The model catalog read (GET /v1/models) settles nothing, so a 503 the
+// server sheds under load is safe to repeat. It is retried only when it names
+// its own delay (a Retry-After header or a retryAfterSeconds body field), at
+// most DISCOVERY_ATTEMPTS tries in all, each wait capped at
+// DISCOVERY_MAX_WAIT_MS. A paid call never goes through here: a repeat of
+// one could settle twice.
+const DISCOVERY_ATTEMPTS = 3;
+const DISCOVERY_MAX_WAIT_MS = 5000;
+
+async function shedRetryWaitMs(r) {
+  if (!r || r.status !== 503) return null;
+  const header = r.headers && typeof r.headers.get === "function" ? r.headers.get("retry-after") : null;
+  let seconds = header != null && String(header).trim() !== "" ? Number(header) : NaN;
+  if (!Number.isFinite(seconds)) {
+    try {
+      const body = await (typeof r.clone === "function" ? r.clone() : r).json();
+      seconds = Number(body && body.retryAfterSeconds);
+    } catch { seconds = NaN; }
+  }
+  if (!Number.isFinite(seconds) || seconds < 0) return null;
+  return Math.min(seconds * 1000, DISCOVERY_MAX_WAIT_MS);
+}
+
+// Resolves with the 2xx response, or throws `${label}: HTTP <status>` (plus
+// "after N attempts" when it retried) with `.status` and `.attempts` set.
+// `init` may be a function, so each attempt gets its own timeout signal.
+async function discoveryFetch(fetchImpl, label, url, init) {
+  let r;
+  let attempts = 0;
+  for (;;) {
+    attempts++;
+    r = await fetchImpl(url, typeof init === "function" ? init() : init);
+    if (r.ok) return r;
+    if (attempts >= DISCOVERY_ATTEMPTS) break;
+    const wait = await shedRetryWaitMs(r);
+    if (wait == null) break;
+    await new Promise((resolve) => setTimeout(resolve, wait));
+  }
+  const err = new Error(`${label}: HTTP ${r.status}${attempts > 1 ? ` after ${attempts} attempts` : ""}`);
+  err.status = r.status;
+  err.attempts = attempts;
+  throw err;
+}
+
 export async function loadRoutes(upstream, fetchImpl = fetch, { pricing = "metered" } = {}) {
-  const r = await fetchImpl(`${upstream}/v1/models`, { headers: { accept: "application/json" }, signal: AbortSignal.timeout(15_000) });
-  if (!r.ok) throw new Error(`GET /v1/models -> HTTP ${r.status}`);
+  const r = await discoveryFetch(fetchImpl, "GET /v1/models", `${upstream}/v1/models`, () => ({ headers: { accept: "application/json" }, signal: AbortSignal.timeout(15_000) }));
   return routesFromCatalog(await r.json(), { pricing });
 }