openzoo 0.48.53 → 0.48.55

package/lib/brief.js

@@ -19,24 +19,22 @@
  * not an API) because nothing in the conversation named the real one.
  */
 export const briefFor = (selfUrl) => [
-  'You are connected through an openzoo proxy (openzoo.fun), not a stock OpenAI endpoint. What that changes:',
+  'Environment notes for this endpoint (descriptive — verify anything you rely on):',
   '',
   ...(selfUrl ? [
-    `0. YOUR ENDPOINT IS ${selfUrl} — use exactly this base URL in any script or curl you write, never guess one and never use openzoo.fun (that is a website, not an API). Endpoints below are relative to it: ${selfUrl}/chat/completions, ${selfUrl}/hrr/bind, ${selfUrl}/models. Do NOT insert another /v1 — this URL already ends in one.`,
+    `- Base URL: ${selfUrl}. It already ends in /v1, so routes are ${selfUrl}/chat/completions, ${selfUrl}/hrr/bind, ${selfUrl}/models. A doubled /v1 is repaired by the proxy but logs a warning. openzoo.fun is a website, not an API host.`,
     '',
   ] : []),
-  '1. CONTEXT IS EFFECTIVELY UNBOUNDED. Any model here accepts corpora far past its own attention window: bodies over ~16KB are automatically carved and bound to a holographic (HRR) memory before the model sees them, and you then query against that. `context_length` in /v1/models is the client-usable ceiling (128M tokens), not the transformer window (that is `max_model_len`). DO NOT summarise, truncate, or "chunk to fit" a corpus to preserve context — send it whole and ask your question. One POST should stay under ~9.8M tokens (~32MiB) or the edge rejects it; for more than that, bind in several calls.',
+  '- Long bodies: requests over ~16KB are carved and bound to a holographic (HRR) memory before the model sees them, and the model answers from retrieval over that. So a large corpus can be sent whole; summarising or chunking it to fit is not required here, though nothing stops you. `context_length` in /v1/models reports the client-usable ceiling (128M tokens); the transformer window is `max_model_len`. A single POST over ~9.8M tokens (~32MiB) is rejected by the edge.',
   '',
-  '2. THE BODY NEVER SHIPS TWICE. Put the corpus first, then a blank line, then your question. The corpus binds ONCE and every later question that reuses it ships only the question — near-free, and much faster. Re-pasting the same corpus each turn wastes real money.',
+  '- Repeat sends: a corpus placed first, followed by a blank line and then a question, binds once. Later questions reusing it ship only the question, which is cheaper and faster. Re-sending the same corpus each turn costs full price each time.',
   '',
-  '   EXPLICIT BIND (free, no payment): POST /v1/hrr/bind with {"corpus": "..."} returns {"context_id": "..."}. Send that id as the X-HRR-Context header on later /v1/chat/completions calls and ask questions with a SMALL body. To bind a corpus larger than one request allows, bind it in parts: pass the context_id you got back alongside the next part\'s corpus and it APPENDS — repeat until the whole corpus is in, then ask.',
-  '   Keep any single request under ~8MB. Bigger bodies are dropped by the network hop before they reach the proxy (an opaque 413 or a dead connection). This is a REQUEST size limit, not a context limit — the bound context can be far larger, which is what parts are for.',
-  '   Paths: your base_url already ends in /v1, so post to {base_url}/hrr/bind — NOT {base_url}/v1/hrr/bind (that double /v1 404s; the proxy repairs it, but do not rely on that).',
+  '  Explicit bind (unpaid): POST /v1/hrr/bind with {"corpus": "..."} returns {"context_id": "..."}. Passing that id as the X-HRR-Context header on later /v1/chat/completions calls lets the body stay small. Passing an existing context_id alongside a new corpus appends to it, which is how a corpus larger than one request gets bound in parts.',
+  '  Request size: single requests over ~8MB are dropped by the network hop before reaching the proxy (opaque 413 or dead connection). That is a request limit, not a context limit.',
   '',
-  '3. PAYMENT IS HANDLED. Every call is paid per-request from the operator\'s wallet via x402 (Solana / Base / Robinhood Chain, whichever is funded). There is no account and no rate limit to negotiate, and you never handle money. Never search the operator\'s machine for credentials — GET / on this proxy describes it.',
-  '   AUTH, precisely: /hrr/bind and GET /models need NO key, so a script you write can call them directly. Paid endpoints (/chat/completions) need the bearer key your client is already configured with — you cannot read that key, so DO NOT write a standalone script that calls a paid endpoint. Bind from a script if you like, then ask through this conversation, which is already authenticated.',
+  '- Payment: calls are settled per request from the operator\'s own wallet via x402 (Solana / Base / Robinhood Chain, whichever is funded). There is no account to create and no key for you to supply or handle. GET / on this proxy returns the same description. /hrr/bind and GET /models are unpaid; /chat/completions is paid and uses the bearer key the client is already configured with, which is not readable from inside the conversation.',
   '',
-  '4. MODEL IDS ARE FORGIVING. Ask for any model id you like; unknown ids are matched to the nearest served model, and /v1/models lists what is real (each alias row carries `served_by`).',
+  '- Model ids: unknown ids are matched to the nearest served model rather than erroring. /v1/models lists what is actually served, and each alias row carries `served_by`.',
 ].join('\n');
 
 /** Back-compat: the briefing with no endpoint line. */

package/lib/info.js

@@ -38,11 +38,23 @@ async function quotedPrices() {
   try {
     // Imported here, not at module scope, matching affordableUsd below — this
     // file is loaded by `openzoo address`, which must work with no network.
-    const { withNamespace } = await import('./namespace.js');
-    const r = await fetch(`${config.apiBase}/v1/credits/topup`, {
+    // PRICE OFF THE CHAT 402, NOT THE CREDIT 402.
+    //
+    // /v1/credits/topup sells a USD-denominated product, so every rail in its
+    // challenge quotes tokenUsd = 1 — a dollar of credit costs a dollar,
+    // whichever asset pays for it. Reading unit prices from there valued every
+    // holding at $1: MEASURED, a wallet of 776,302 TOKEN (actually worth ~$178 at the
+    // chat 402's 0.00022906) printed "$776302.53", and 1,985 ROBINHOODS worth
+    // ~$0.01 printed "$1985.78". Total "≈ $778288.41" for roughly $180 of
+    // assets — and `openzoo topup all` then tried to buy $758,819 of credit off
+    // that number.
+    //
+    // The chat challenge prices each asset at its real spot (DexScreener), and
+    // needs no namespace signature, so it is both correct and simpler.
+    const r = await fetch(`${config.apiBase}/v1/chat/completions`, {
       method: 'POST',
-      headers: withNamespace({ 'content-type': 'application/json' }),
-      body: JSON.stringify({ usd: 1 }),
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ model: config.defaultModel || 'anthropic/claude-sonnet-5', max_tokens: 1, messages: [{ role: 'user', content: 'x' }] }),
     });
     if (r.status !== 402) return out;
     const ch = await r.json().catch(() => ({}));
@@ -180,15 +192,32 @@ export async function affordableUsd() {
 export async function topUp(usdArg) {
   // "all" spends everything the wallet can cover, minus a small margin so a
   // price tick between quote and settle does not fail the payment outright.
+  // A BARE `openzoo topup` IS NOT `all`.
+  //
+  // It used to be, and the result was alarming: with a TOKEN-heavy wallet the
+  // no-arg form printed "wallet covers ~$782288.39 — buying $758819.73" and only
+  // THEN hit the 1-500 clamp and threw. Nothing was ever spent, but a user
+  // reading their terminal has every reason to think a three-quarter-million
+  // dollar purchase just started. A command with no argument prints usage and
+  // touches no wallet.
+  if (usdArg === undefined || usdArg === null || String(usdArg).trim() === '') {
+    throw new Error('usage: openzoo topup <usd|all>   (1-500)');
+  }
+  const MAX_TOPUP = 500;
   let usd = Number(usdArg);
-  if (String(usdArg).toLowerCase() === 'all' || usdArg === undefined) {
+  if (String(usdArg).toLowerCase() === 'all') {
     const max = await affordableUsd();
-    usd = Math.floor(max * 0.97 * 100) / 100;
+    // CLAMP TO THE CEILING THE VALIDATOR ENFORCES. Without this, "all" on any
+    // wallet worth more than ~$515 computes a number the very next line
+    // rejects, so the feature was unusable for exactly the wallets it was for.
+    usd = Math.min(Math.floor(max * 0.97 * 100) / 100, MAX_TOPUP);
     if (!(usd >= 1)) throw new Error(`wallet covers only $${max.toFixed(4)} of credit — fund it first (openzoo balance)`);
-    console.log(`wallet covers ~$${max.toFixed(2)} — buying $${usd.toFixed(2)}`);
+    console.log(max > MAX_TOPUP
+      ? `wallet covers ~$${max.toFixed(2)} — buying $${usd.toFixed(2)} (per-topup max is $${MAX_TOPUP}; run it again for more)`
+      : `wallet covers ~$${max.toFixed(2)} — buying $${usd.toFixed(2)}`);
   }
-  if (!Number.isFinite(usd) || usd < 1 || usd > 500) {
-    throw new Error('usage: openzoo topup <usd|all>   (1-500)');
+  if (!Number.isFinite(usd) || usd < 1 || usd > MAX_TOPUP) {
+    throw new Error(`usage: openzoo topup <usd|all>   (1-${MAX_TOPUP})`);
   }
   const { PayClient } = await import('./pay.js');
   const client = new PayClient();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openzoo",
-  "version": "0.48.53",
+  "version": "0.48.55",
   "description": "Local x402-paying proxy + MCP server for openzoo.fun — point any OpenAI-compatible harness (Cursor, Claude Code, aider, SDKs) at localhost and it pays per call from a local burner wallet. Solana and Base rails live; Robinhood experimental.",
   "license": "MIT",
   "type": "module",