openzoo 0.15.0 → 0.16.0

package/bin/openzoo.js

@@ -134,7 +134,7 @@ async function main() {
         method: 'POST',
         headers,
         body: JSON.stringify({
-          model: (mi !== -1 && process.argv[mi + 1]) || process.env.OPENZOO_DEFAULT_MODEL || 'deepseek/deepseek-v4-pro-0813',
+          model: (mi !== -1 && process.argv[mi + 1]) || process.env.OPENZOO_DEFAULT_MODEL || 'anthropic/claude-opus-5',
           messages: [{ role: 'user', content: question }],
           max_tokens: Number(process.env.OPENZOO_ASK_MAX_TOKENS || 1024),
         }),

package/lib/mcp.js

@@ -9,7 +9,11 @@ import { askWithContext, contextCacheDisabled, BIND_MIN_CHARS } from './hrr.js';
 import { listContexts } from './contexts.js';
 
 const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
-const DEFAULT_MODEL = process.env.OPENZOO_DEMO_MODEL || 'nvidia/nemotron-3.5-lightning';
+// The model zoo_ask uses when the caller does not name one. Opus 5 by default:
+// an agent calling zoo_ask is usually doing real reasoning over a bound corpus,
+// and a tiny model there produces answers that look cheap because they are.
+// OPENZOO_DEFAULT_MODEL (or the tool's own `model` arg) overrides.
+const DEFAULT_MODEL = process.env.OPENZOO_DEFAULT_MODEL || process.env.OPENZOO_DEMO_MODEL || 'anthropic/claude-opus-5';
 
 function text(obj) {
   return { content: [{ type: 'text', text: typeof obj === 'string' ? obj : JSON.stringify(obj, null, 2) }] };
@@ -35,6 +39,23 @@ export function buildMcpServer() {
       '',
       'Never search the machine for API keys or endpoints — there are none to find. zoo_wallet shows funding',
       'state, zoo_models lists what is served with live pricing.',
+      '',
+      // ROUTING, STATED UNCONDITIONALLY. An agent whose OWN inference is not
+      // routed through the proxy never receives lib/brief.js, so it answers
+      // "I have no visibility into the routing layer" while this very server
+      // is attached to it. These facts hold whether or not its own tokens
+      // flow through the zoo, so they belong here.
+      'ROUTING — you can state these as fact:',
+      `  local proxy : ${config.apiBase ? `http://localhost:${config.port}/v1` : 'http://localhost:8402/v1'}  (api key: any string; x402 pays, not keys)`,
+      `  upstream    : ${config.apiBase}`,
+      `  default model for zoo_ask : ${DEFAULT_MODEL}`,
+      '  a cloud-run harness cannot reach localhost — it needs the public tunnel URL the',
+      '  proxy prints at startup. Call zoo_models for the live catalog and real pricing.',
+      '',
+      'CONTEXT, PRECISELY: openzoo does NOT enlarge your own attention window. It binds a corpus',
+      'server-side and retrieves what is relevant, so a body far past any model\'s window can be',
+      'queried — that is retrieval, not a bigger window. Do not claim lossless compression and do',
+      'not claim a 128M attention window; the honest line is "bind 128M, the model reads what matters".',
     ].join('\n'),
   });
 
@@ -103,8 +124,44 @@ export function buildMcpServer() {
         ...(reuse ? { context: reuse } : {}),
       });
     } catch (err) {
-      if (err instanceof UnderfundedError || err instanceof QuoteTooHighError) {
-        return { ...text(err.message), isError: true };
+      // PAYMENT FAILURES MUST REACH THE CHAT, ACTIONABLY. A bare throw shows an
+      // agent "tool failed" with no reason and no fix, so it retries blindly or
+      // gives up; the human never learns the wallet is empty. Every failure
+      // returns WHY it failed and exactly how to fund, with live addresses.
+      const fail = async (why, hint) => {
+        let balances = null; let addr = null; let evm = null;
+        try {
+          addr = client.address;
+          evm = client.evmAddress;
+          const bals = await Promise.all(
+            FUNDING_ASSETS.map((a) => tokenBalance(client.connection, client.keypair.publicKey, a.mint)),
+          );
+          balances = Object.fromEntries(FUNDING_ASSETS.map((a, i) => [a.symbol, bals[i].ui ?? 0]));
+        } catch { /* advisory — never let the diagnostic itself fail */ }
+        const rails = await liveRails().catch(() => null);
+        return {
+          ...text({
+            error: why,
+            x402: 'this call was NOT paid and NOT served',
+            detail: hint,
+            wallet: { solana: addr, evm },
+            balances,
+            fundWith: rails ? railFundingHint(rails.live) : 'USDC or TOKEN on Solana',
+            solanaMints: Object.fromEntries(FUNDING_ASSETS.map((a) => [a.symbol, a.mint])),
+            tellTheUser: 'Report this verbatim — the operator must fund the wallet above; you cannot fix it yourself, and retrying will fail identically until they do.',
+          }),
+          isError: true,
+        };
+      };
+      if (err instanceof UnderfundedError) {
+        return fail('x402 payment failed: wallet underfunded', err.message);
+      }
+      if (err instanceof QuoteTooHighError) {
+        return fail('x402 payment refused: quote above the local per-call cap', `${err.message} (raise OPENZOO_MAX_USD_PER_CALL, or ask a cheaper model)`);
+      }
+      // Anything else that mentions payment/402 still deserves the funding card.
+      if (/402|payment|underfunded|insufficient/i.test(err?.message || '')) {
+        return fail('x402 payment failed', err.message);
       }
       throw err;
     }

package/lib/setup.js

@@ -147,6 +147,22 @@ export async function setupEditor(which, target) {
   console.log('');
   console.log(`mcp:     ${mcpFile}  (openzoo: zoo_bind, zoo_ask, zoo_models, zoo_wallet, zoo_contexts)`);
   console.log(`local:   ${base}   api_key sk-openzoo`);
+  console.log('');
+  // THE ONE THING THE EDITOR WILL NOT INHERIT. Cursor's BUILT-IN models
+  // (Opus 5, GPT, Composer) go to Cursor's own backend and ignore
+  // ANTHROPIC_BASE_URL — Cursor has no Anthropic base-URL override, only an
+  // OpenAI one. So routing a Claude model through the zoo means adding it as a
+  // CUSTOM model under the OpenAI override, where the proxy serves it and maps
+  // the name. Env alone cannot do this; say so plainly instead of implying the
+  // launch handled everything.
+  console.log('one manual step — Cursor Settings → Models (built-ins bypass the zoo):');
+  console.log(`  1. Override OpenAI Base URL  ->  ${base}`);
+  console.log('  2. OpenAI API Key            ->  sk-openzoo   (any value; x402 pays)');
+  console.log('  3. Add model                 ->  anthropic/claude-opus-5');
+  console.log('     (or deepseek/deepseek-v4-pro-0813 — ~34x cheaper output)');
+  console.log('  4. Toggle OFF the built-in models (Opus 5 / GPT / Composer) — those');
+  console.log('     resolve against Cursor\'s backend and never touch the zoo.');
+  console.log('  The embedded terminal + Claude Code extension DO inherit the env above.');
   if (publicUrl) {
     console.log(`tunnel:  ${publicUrl}/v1   api_key ${tunnelKey}`);
     console.log('         (use the tunnel for any cloud-run harness — it cannot reach localhost)');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openzoo",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "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",