agent402-openclaw 0.1.1 → 0.2.0

package/README.md

@@ -11,7 +11,7 @@ Guide: https://agent402.tools/guides/openclaw-model-provider
 
 ```bash
 openclaw plugins install agent402-openclaw
-agent402-openclaw setup --credits-key a402_...   # buy a pack by card at https://agent402.tools/credits
+AGENT402_CREDITS_KEY=a402_... agent402-openclaw setup --write   # key by env (or `--credits-key -` on stdin); buy one by card at https://agent402.tools/credits
 openclaw gateway restart
 ```
 
@@ -33,17 +33,27 @@ export AGENT402_WALLET_KEY=0x...     # an EVM key holding USDC on Base
 With no credits key present the proxy signs an x402 payment per call from that
 wallet. The key never leaves the machine.
 
-## Models
+## Models and pricing
 
-`auto` (routed per prompt) plus every id from `GET https://agent402.tools/v1/models`,
-each routed to its home tier. Prices are per call, not per token, so OpenClaw's
-per-token cost fields are zero. A model sent to the wrong tier is answered with a
-400 naming the right one; nothing is charged. Every forwarded call carries an
-`Idempotency-Key`, so retries replay the paid answer instead of paying twice.
+`auto` (routed per prompt, flat $0.01/call) plus every id from
+`GET https://agent402.tools/v1/models`. Explicit models are **metered by default**:
+the proxy sends them to the gateway's metered route, where each request is quoted
+from its body (exact-BPE input plus your `max_tokens` at the model's list price,
+times 1.15, from $0.001, capped at $2 per call), so a short call costs a fraction
+of a cent and a long one pays for what it asks. `--flat` (or
+`AGENT402_PRICING=flat`) keeps every model on its flat per-call tier instead.
+Either way OpenClaw's per-token cost fields stay zero; the price is per call. A model sent to the wrong tier is answered with a
+400 naming the right one; nothing is charged. A client-supplied `Idempotency-Key`
+is passed through (an x402 retry with the same key replays the paid answer);
+without one, each call is its own payment.
+
+The proxy answers native clients on loopback only: requests carrying a browser
+`Origin` header or a non-loopback `Host` are refused, so a web page cannot spend
+the key.
 
 ## Commands
 
-- `agent402-openclaw setup [--credits-key K] [--write] [--port N]`
+- `agent402-openclaw setup [--credits-key K | --credits-key - (stdin) | AGENT402_CREDITS_KEY env] [--write] [--port N]`
 - `agent402-openclaw proxy [--port N] [--upstream URL]`
 - `agent402-openclaw doctor`
 

package/cli.js

@@ -3,7 +3,8 @@
 //   setup [--credits-key a402_...] [--write]   store the key, print (or merge) the openclaw.json block
 //   proxy [--port N] [--upstream URL]          run the local proxy on its own (no OpenClaw needed)
 //   doctor                                     show what is configured and whether the gateway answers
-import { mkdirSync, writeFileSync, readFileSync, existsSync, chmodSync } from "node:fs";
+import { mkdirSync, writeFileSync, readFileSync, existsSync, chmodSync, statSync, realpathSync, renameSync } from "node:fs";
+import { pathToFileURL } from "node:url";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { STATE_DIR, CREDITS_KEY_FILE, resolveCreditsKey, resolvePayFetch } from "./index.js";
@@ -36,14 +37,21 @@ function mergeInto(target, block) {
 
 async function main() {
   if (cmd === "help" || has("--help")) {
-    out("agent402-openclaw setup [--credits-key a402_...] [--write] | proxy [--port N] [--upstream URL] | doctor");
+    out("agent402-openclaw setup [--credits-key a402_...|-] [--write] [--flat] | proxy [--port N] [--upstream URL] [--flat] | doctor");
     return 0;
   }
   const upstream = stripTrailingSlashes(opt("--upstream") || process.env.AGENT402_UPSTREAM || DEFAULT_UPSTREAM);
   const port = Number(opt("--port")) || DEFAULT_PORT;
+  // Pricing: metered by default (explicit models pay a per-request quote, from
+  // $0.001); --flat (or AGENT402_PRICING=flat) keeps every model on its flat tier.
+  const pricing = has("--flat") || String(process.env.AGENT402_PRICING || "").toLowerCase() === "flat" ? "flat" : "metered";
 
   if (cmd === "setup") {
-    const key = (opt("--credits-key") || "").trim();
+    // The key may arrive on argv (lands in shell history), via AGENT402_CREDITS_KEY,
+    // or on stdin with `--credits-key -` (the form the docs recommend).
+    let key = (opt("--credits-key") || "").trim();
+    if (key === "-") key = readFileSync(0, "utf8").trim();
+    if (!key && process.env.AGENT402_CREDITS_KEY && !has("--no-env")) key = process.env.AGENT402_CREDITS_KEY.trim();
     if (key) {
       if (!/^a402_[A-Za-z0-9_-]{16,80}$/.test(key)) { console.error("that does not look like an Agent402 credits key (a402_...)"); return 2; }
       mkdirSync(STATE_DIR(), { recursive: true });
@@ -54,7 +62,7 @@ async function main() {
       out(`no credits key yet: buy a pack by card at ${upstream}/credits, then rerun with --credits-key a402_...`);
     }
     let routes;
-    try { routes = await loadRoutes(upstream); } catch (e) { console.error(`could not read ${upstream}/v1/models: ${e?.message || e}`); return 2; }
+    try { routes = await loadRoutes(upstream, fetch, { pricing }); } catch (e) { console.error(`could not read ${upstream}/v1/models: ${e?.message || e}`); return 2; }
     const block = configBlock({ port, routes });
     const cfgPath = join(process.env.AGENT402_OPENCLAW_HOME || join(homedir(), ".openclaw"), "openclaw.json");
     if (has("--write")) {
@@ -64,9 +72,14 @@ async function main() {
         catch { console.error(`${cfgPath} is not plain JSON (JSON5 comments?); not touching it. Merge this block by hand:`); out(JSON.stringify(block, null, 2)); return 2; }
       }
       mkdirSync(join(cfgPath, ".."), { recursive: true });
+      // Preserve the file's mode (openclaw.json holds other providers' keys and
+      // is often 0600); a fresh file is created 0600. Never loosen it.
+      let mode = 0o600;
+      try { if (existsSync(cfgPath)) mode = statSync(cfgPath).mode & 0o777; } catch { /* keep 0600 */ }
       const tmp = `${cfgPath}.${process.pid}.tmp`;
-      writeFileSync(tmp, JSON.stringify(mergeInto(existing, block), null, 2) + "\n");
-      const { renameSync } = await import("node:fs"); renameSync(tmp, cfgPath);
+      writeFileSync(tmp, JSON.stringify(mergeInto(existing, block), null, 2) + "\n", { mode });
+      try { chmodSync(tmp, mode); } catch { /* best effort */ }
+      renameSync(tmp, cfgPath);
       out(`wrote provider "${PROVIDER_ID}" + primary model ${PROVIDER_ID}/auto into ${cfgPath}; run: openclaw gateway restart`);
     } else {
       out(`add to ${cfgPath} (or rerun with --write):`);
@@ -78,8 +91,8 @@ async function main() {
   if (cmd === "proxy") {
     const creditsKey = resolveCreditsKey();
     const payFetch = creditsKey ? null : await resolvePayFetch({}, (m) => console.error(m));
-    const p = await startProxy({ upstream, creditsKey, payFetch, port, log: (m) => console.error(m) });
-    out(`${p.baseUrl}/v1 (${p.mode})`);
+    const p = await startProxy({ upstream, creditsKey, payFetch, port, pricing, log: (m) => console.error(m) });
+    out(`${p.baseUrl}/v1 (${p.mode}, ${p.pricing} pricing)`);
     await new Promise(() => {}); // run until killed
   }
 
@@ -88,7 +101,7 @@ async function main() {
     out(`upstream: ${upstream}`);
     out(`credits key: ${key ? `present (${key.slice(0, 8)}…)` : "none"}`);
     out(`wallet key: ${/^0x[0-9a-fA-F]{64}$/.test(process.env.AGENT402_WALLET_KEY || "") ? "present" : "none"}`);
-    try { const r = await loadRoutes(upstream); out(`gateway: ok, ${r.size} models`); } catch (e) { out(`gateway: unreachable (${e?.message || e})`); return 1; }
+    try { const r = await loadRoutes(upstream, fetch, { pricing }); out(`gateway: ok, ${r.size} models (${pricing} pricing: ${[...r.values()].filter((x) => x.metered).length} metered)`); } catch (e) { out(`gateway: unreachable (${e?.message || e})`); return 1; }
     if (key) {
       try {
         const r = await fetch(`${upstream}/api/credits/balance`, { headers: { authorization: `Bearer ${key}` }, signal: AbortSignal.timeout(15_000) });
@@ -102,6 +115,13 @@ async function main() {
   console.error(`unknown command: ${cmd}`); return 2;
 }
 
-if (import.meta.url === `file://${process.argv[1]}`) {
+// Entry guard that survives npm's bin SYMLINK and paths with spaces: Node
+// resolves import.meta.url to the real path but leaves process.argv[1] as the
+// symlink, so a plain string compare is false for every `npx`/global install
+// and the CLI silently did nothing (0.1.0 and 0.1.1 shipped that way).
+function invokedDirectly() {
+  try { return import.meta.url === pathToFileURL(realpathSync(process.argv[1])).href; } catch { return false; }
+}
+if (invokedDirectly()) {
   main().then((c) => process.exit(c ?? 0), (e) => { console.error(e?.message || e); process.exit(1); });
 }

package/index.js

@@ -51,6 +51,7 @@ const plugin = {
     const cfg = api.pluginConfig || {};
     const port = Number(cfg.port) || DEFAULT_PORT;
     const upstream = stripTrailingSlashes(cfg.upstream || process.env.AGENT402_UPSTREAM || DEFAULT_UPSTREAM);
+    const pricing = String(cfg.pricing || process.env.AGENT402_PRICING || "metered").toLowerCase() === "flat" ? "flat" : "metered";
     const log = (m) => api.logger?.info?.(m);
     api.registerProvider(buildProvider({ port }));
     if (!registeredOnce) {
@@ -61,8 +62,8 @@ const plugin = {
           if (started) return;
           const creditsKey = resolveCreditsKey(cfg);
           const payFetch = creditsKey ? null : await resolvePayFetch(cfg, log);
-          try { setCachedRoutes(await loadRoutes(upstream)); } catch (e) { log(`[agent402-openclaw] could not read ${upstream}/v1/models yet: ${e?.message || e}`); }
-          started = await startProxy({ upstream, creditsKey, payFetch, port, log });
+          try { setCachedRoutes(await loadRoutes(upstream, fetch, { pricing })); } catch (e) { log(`[agent402-openclaw] could not read ${upstream}/v1/models yet: ${e?.message || e}`); }
+          started = await startProxy({ upstream, creditsKey, payFetch, port, pricing, log });
           setActiveProxy(started);
           if (started.mode === "unpaid") log("[agent402-openclaw] no payment configured: run `agent402-openclaw setup` (card credits key) - paid calls will answer 402 until then");
         },

package/models.js

@@ -16,19 +16,30 @@ export function stripTrailingSlashes(s) {
 }
 
 
-/** The raw catalog entry -> { id, endpoint, tier, priceUsd, maxTokens, maxInputChars }. */
-export function routesFromCatalog(catalog) {
+/** The raw catalog entry -> { id, endpoint, tier, priceUsd, maxTokens, maxInputChars }.
+ *
+ *  `pricing`: "metered" (default) routes every explicit model to the gateway's
+ *  metered endpoint when the catalog advertises one (`x402.meteredEndpoint`):
+ *  the 402 quotes each request from its body, from `meteredFromUsd`, instead
+ *  of the tier's flat price - a short call costs a fraction of a cent, a long
+ *  one pays for what it asks. "flat" keeps every model on its home tier.
+ *  `auto` always stays on the routed tier (the metered route needs an explicit
+ *  model). */
+export function routesFromCatalog(catalog, { pricing = "metered" } = {}) {
   const data = Array.isArray(catalog?.data) ? catalog.data : [];
   const routes = new Map();
+  const metered = pricing !== "flat";
   for (const m of data) {
     const x = m?.x402;
     if (!m?.id || !x?.endpoint || typeof x.priceUsd !== "number") continue;
     if (String(m.id).endsWith("*")) continue; // family wildcard, not an id
+    const useMetered = metered && typeof x.meteredEndpoint === "string" && x.meteredEndpoint.startsWith("/");
     routes.set(m.id, {
       id: m.id,
-      endpoint: x.endpoint,
-      tier: x.tier || null,
-      priceUsd: x.priceUsd,
+      endpoint: useMetered ? x.meteredEndpoint : x.endpoint,
+      tier: useMetered ? "v1-chat-metered" : (x.tier || null),
+      priceUsd: useMetered ? (Number(x.meteredFromUsd) || x.priceUsd) : x.priceUsd,
+      metered: useMetered,
       maxTokens: Number(x.maxTokens) || 1024,
       maxInputChars: Number(x.maxInputChars) || 32_000,
       stealth: !!x.stealth,
@@ -55,7 +66,7 @@ export function openclawModels(routes) {
   rows.sort((a, b) => (a.id === AUTO_ID ? -1 : b.id === AUTO_ID ? 1 : a.priceUsd - b.priceUsd || a.id.localeCompare(b.id)));
   return rows.map((r) => ({
     id: r.id,
-    name: r.id === AUTO_ID ? `Agent402 auto (routed, ${priceLabel(r.priceUsd)}/call)` : `${r.id} (${priceLabel(r.priceUsd)}/call)`,
+    name: r.id === AUTO_ID ? `Agent402 auto (routed, ${priceLabel(r.priceUsd)}/call)` : r.metered ? `${r.id} (metered, from ${priceLabel(r.priceUsd)}/call)` : `${r.id} (${priceLabel(r.priceUsd)}/call)`,
     reasoning: false,
     input: ["text"],
     // Flat per-call billing: OpenClaw's per-token cost display does not apply.

package/package.json

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

package/proxy.js

@@ -14,20 +14,30 @@
 // gateway's own GET /v1/models at start (never a hand-typed table). "auto"
 // goes to the routed tier with the model field omitted.
 //
-// Retries are safe: every forwarded request carries a fresh Idempotency-Key,
-// so a client retry of the same request replays the paid response instead of
-// paying twice. Streams pass through byte for byte.
+// Idempotency: a client-supplied Idempotency-Key is passed through so an
+// x402 retry with the same key replays the paid answer server-side; without
+// one each forwarded call gets a fresh key (a safety for the fetch layer's
+// own 402->pay retry), which does NOT make two client calls one payment.
+// Streams pass through byte for byte.
+//
+// Loopback only, and browser-hostile on purpose: any web page can POST to
+// 127.0.0.1 with a "simple" no-cors request, and this proxy spends the
+// user's key, so a request carrying an Origin header (browsers always send
+// one on cross-origin POSTs; native clients send none) or a Host that is
+// not loopback is refused before anything is forwarded.
 import { createServer } from "node:http";
+import { readFileSync } from "node:fs";
 import { randomUUID } from "node:crypto";
 import { AUTO_ID, routesFromCatalog, stripTrailingSlashes } from "./models.js";
 
 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;
 
-export async function loadRoutes(upstream, fetchImpl = fetch) {
+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}`);
-  return routesFromCatalog(await r.json());
+  return routesFromCatalog(await r.json(), { pricing });
 }
 
 function readBody(req, limit = MAX_BODY) {
@@ -53,25 +63,34 @@ const json = (res, status, obj, headers = {}) => {
  * @param {number} [o.port]          0 = ephemeral
  * @param {string} [o.host]          default 127.0.0.1 (loopback only: anyone who can reach the port spends your key)
  * @param {Map} [o.routes]           pre-loaded routes (tests); else loaded from upstream
+ * @param {"metered"|"flat"} [o.pricing]  metered (default): explicit models pay per-request quotes; flat: home tiers
  * @param {(msg:string)=>void} [o.log]
  */
-export async function startProxy({ upstream = DEFAULT_UPSTREAM, creditsKey = null, payFetch = null, fetch: fetchImpl = fetch, port = 0, host = "127.0.0.1", routes = null, log = () => {} } = {}) {
+export async function startProxy({ upstream = DEFAULT_UPSTREAM, creditsKey = null, payFetch = null, fetch: fetchImpl = fetch, port = 0, host = "127.0.0.1", routes = null, pricing = "metered", log = () => {} } = {}) {
   upstream = stripTrailingSlashes(upstream);
+  pricing = pricing === "flat" ? "flat" : "metered";
   const key = typeof creditsKey === "string" && /^a402_[A-Za-z0-9_-]{16,80}$/.test(creditsKey) ? creditsKey : null;
   const paid = key ? fetchImpl : payFetch;
   const mode = key ? "credits" : payFetch ? "x402" : "unpaid";
-  let table = routes || await loadRoutes(upstream, fetchImpl);
+  let table = routes || await loadRoutes(upstream, fetchImpl, { pricing });
   const stats = { requests: 0, forwarded: 0, errors: 0, startedAt: new Date().toISOString() };
 
   const server = createServer(async (req, res) => {
     stats.requests++;
     const url = new URL(req.url, "http://localhost");
     try {
+      if (req.headers.origin !== undefined) {
+        return json(res, 403, { error: { message: "Browser-origin requests are refused: this proxy spends a payment key and answers native clients only.", type: "forbidden" } });
+      }
+      const hostName = String(req.headers.host || "").replace(/:\d+$/, "").replace(/^\[|\]$/g, "");
+      if (hostName && !["127.0.0.1", "localhost", "::1"].includes(hostName)) {
+        return json(res, 403, { error: { message: `Host "${hostName.slice(0, 64)}" is not loopback; refused.`, type: "forbidden" } });
+      }
       if (req.method === "GET" && url.pathname === "/health") {
-        return json(res, 200, { ok: true, upstream, mode, models: table.size, stats });
+        return json(res, 200, { ok: true, upstream, mode, pricing, models: table.size, stats });
       }
       if (req.method === "GET" && url.pathname === "/v1/models") {
-        return json(res, 200, { object: "list", data: [...table.values()].filter((r) => !r.stealth).map((r) => ({ id: r.id, object: "model", owned_by: "agent402", agent402: { endpoint: r.endpoint, priceUsd: r.priceUsd, tier: r.tier } })) });
+        return json(res, 200, { object: "list", data: [...table.values()].filter((r) => !r.stealth).map((r) => ({ id: r.id, object: "model", owned_by: "agent402", agent402: { endpoint: r.endpoint, priceUsd: r.priceUsd, tier: r.tier, metered: !!r.metered } })) });
       }
       if (req.method === "POST" && url.pathname === "/v1/chat/completions") {
         const raw = await readBody(req);
@@ -87,7 +106,8 @@ export async function startProxy({ upstream = DEFAULT_UPSTREAM, creditsKey = nul
         }
         const outbound = { ...body };
         if (requested === AUTO_ID) delete outbound.model; else outbound.model = route.id;
-        const headers = { "content-type": "application/json", accept: req.headers.accept || "application/json", "idempotency-key": randomUUID(), "user-agent": "agent402-openclaw/0.1.1" };
+        const clientIdem = typeof req.headers["idempotency-key"] === "string" && /^[\w.:-]{8,128}$/.test(req.headers["idempotency-key"]) ? req.headers["idempotency-key"] : null;
+        const headers = { "content-type": "application/json", accept: req.headers.accept || "application/json", "idempotency-key": clientIdem || randomUUID(), "user-agent": `agent402-openclaw/${PKG_VERSION}` };
         if (key) headers.authorization = `Bearer ${key}`;
         const up = await paid(`${upstream}${route.endpoint}`, { method: "POST", headers, body: JSON.stringify(outbound), signal: AbortSignal.timeout(300_000) });
         stats.forwarded++;
@@ -112,11 +132,11 @@ export async function startProxy({ upstream = DEFAULT_UPSTREAM, creditsKey = nul
   await new Promise((resolve, reject) => { server.once("error", reject); server.listen(port, host, resolve); });
   const actualPort = server.address().port;
   const baseUrl = `http://${host}:${actualPort}`;
-  log(`[agent402-openclaw] proxy on ${baseUrl}/v1 -> ${upstream} (${mode}, ${table.size} models)`);
+  log(`[agent402-openclaw] proxy on ${baseUrl}/v1 -> ${upstream} (${mode}, ${pricing} pricing, ${table.size} models)`);
   return {
-    baseUrl, port: actualPort, mode, upstream,
+    baseUrl, port: actualPort, mode, upstream, pricing,
     stats: () => ({ ...stats }),
-    refreshModels: async () => { table = await loadRoutes(upstream, fetchImpl); return table.size; },
+    refreshModels: async () => { table = await loadRoutes(upstream, fetchImpl, { pricing }); return table.size; },
     close: () => new Promise((resolve) => server.close(() => resolve())),
   };
 }