mycomesh-consumer 0.9.6 → 0.9.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mycomesh-consumer",
-  "version": "0.9.6",
+  "version": "0.9.8",
   "description": "MycoMesh V11 Consumer: a custodied deposit, relay-blind encrypted requests to any Provider, and a local OpenAI-compatible endpoint.",
   "repository": {
     "type": "git",

package/src/consumer.mjs

@@ -6,7 +6,7 @@ import { dirname, resolve } from "node:path";
 import { rootCertificates } from "node:tls";
 import { addressOf, encodeCall } from "./eip712.mjs";
 import { rpcCall } from "./chain.mjs";
-import { openDelta, openResponse, outputText, prepareRequest, verifiedProvider } from "./protocol.mjs";
+import { openDelta, openResponse, outputText, planRequest, prepareRequest, verifiedProvider } from "./protocol.mjs";
 import { recordRequest } from "./disputes.mjs";
 import { chatStream, responseStream } from "./sse.mjs";
 import { consoleRoutes, localRequestAllowed } from "./console.mjs";
@@ -248,6 +248,7 @@ export class Consumer {
 
   async attempt({ endpoint, model, content, maxOutputTokens = 4096, options = {}, provider, onDelta }) {
     let lastError;
+    let raisedFee = 0;
     for (const relay of await this.relays()) {
       let candidates;
       try {
@@ -267,10 +268,15 @@ export class Consumer {
       const keyed = candidates.map((descriptor) => [key(descriptor), descriptor]);
       keyed.sort((a, b) => compareRank(a[0], b[0]));
       candidates = keyed.map(([, descriptor]) => descriptor);
-      for (const descriptor of candidates) {
+      let retried = false;
+      for (let index = 0; index < candidates.length; index += 1) {
+        const descriptor = candidates[index];
+        // Authorize what this request can really cost, not the Consumer's whole per-request cap.
+        const plan = planRequest(descriptor, endpoint, content, maxOutputTokens, this.maxFee);
+        const maxFee = Math.min(Number(this.maxFee), Math.max(raisedFee || 0, plan.maxFee));
         const prepared = prepareRequest({
           descriptor, deployment: this.deployment, keyPrivate: this.keyPrivate, relaySigner: relay.signer,
-          endpoint, model, content, maxOutputTokens, maxFee: this.maxFee, options, now: this.now(),
+          endpoint, model, content, maxOutputTokens: plan.maxOutputTokens, maxFee, options, now: this.now(),
         });
         let reply;
         const streamed = [];
@@ -312,6 +318,17 @@ export class Consumer {
         }
         lastError = Object.assign(new Error(reply.body?.error || `Relay returned ${reply.status}`),
           { status: reply.status, dispatched: reply.body?.dispatched });
+        // A Provider that found the max fee too low for this request says what it needs; ask again with that.
+        const needed = /worst-case price (\d+)/.exec(String(reply.body?.error || ""));
+        if (needed && reply.body?.dispatched === false) {
+          const required = Number(needed[1]);
+          if (required > Number(this.maxFee)) {
+            throw Object.assign(new Error(`this request may cost up to ${required}, above the per-request limit ${this.maxFee}`), { status: 402 });
+          }
+          raisedFee = Math.ceil(required * 1.2);
+          if (!retried) { retried = true; index -= 1; } // the same Provider, once, with the fee it asked for
+          continue;
+        }
         if (reply.body?.dispatched !== false || ![502, 503].includes(reply.status)) throw lastError;
       }
     }

package/src/protocol.mjs

@@ -111,3 +111,42 @@ export function openResponse(prepared, result, deployment, now = Math.floor(Date
   }
   return { response, receipt: signed, responsePlaintext: opened.payload };
 }
+
+/**
+ * (input, output) tokens a request can cost at most, estimated exactly as the Provider does
+ * (mycomesh/protocol.py worst_case_tokens): content UTF-8 length / 3, plus the backend's own input, plus
+ * the full max_output_tokens.
+ */
+export function worstCaseTokens(endpoint, content, maxOutputTokens, inputOverheadTokens = 0) {
+  const bytes = Buffer.byteLength(JSON.stringify(content ?? null), "utf8");
+  return [Math.ceil(bytes / 3) + Number(inputOverheadTokens || 0), Number(maxOutputTokens)];
+}
+
+/**
+ * The max fee to authorize for one request, and the output it may use: its worst-case price at the Provider's
+ * advertised network price with 50% headroom (a day's price step, estimation error), never above the
+ * Consumer's own cap. Relays reserve this amount while the request runs, so a realistic figure is what lets
+ * many requests share one deposit and one Provider's daily capacity at once. When even the worst case does
+ * not fit the cap, the output is trimmed to what the cap pays for, rather than having the Provider refuse.
+ */
+export function planRequest(descriptor, endpoint, content, maxOutputTokens, cap) {
+  const prices = descriptor.prices || {};
+  const inPrice = Number(prices.input_per_1k || 0);
+  const outPrice = Number(prices.output_per_1k || 0);
+  const floor = Math.max(Number(prices.minimum_fee || 0), 1);
+  const [input] = worstCaseTokens(endpoint, content, 0, descriptor.input_overhead_tokens);
+  const worst = (output) => Math.max(Math.ceil((input * inPrice + output * outPrice) / 1000), floor);
+  let output = Number(maxOutputTokens);
+  if (worst(output) > Number(cap) && outPrice > 0) {
+    // What the cap pays for, keeping 10% for a price step between authorization and settlement.
+    output = Math.floor(((Number(cap) / 1.1) * 1000 - input * inPrice) / outPrice);
+    if (output < 16) {
+      throw Object.assign(new Error(`the per-request limit ${cap} cannot pay for this request at today's price`), { status: 402 });
+    }
+  }
+  return { maxFee: Math.min(Number(cap), Math.ceil(worst(output) * 1.5)), maxOutputTokens: output };
+}
+
+export function pricedMaxFee(descriptor, endpoint, content, maxOutputTokens, cap) {
+  return planRequest(descriptor, endpoint, content, maxOutputTokens, cap).maxFee;
+}