openzoo 0.15.0 → 0.17.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/cursorcfg.js

@@ -0,0 +1,83 @@
+/**
+ * Write Cursor / VS Code-fork provider settings directly.
+ *
+ * These live as PLAIN JSON in the editor's globalStorage SQLite (`state.vscdb`,
+ * table ItemTable), under the reactive-storage `applicationUser` blob — NOT in
+ * an encrypted store. The fields that matter:
+ *   openAIBaseUrl        the "Override OpenAI Base URL" box
+ *   useOpenAIKey         the toggle next to it
+ *   availableAPIKeyModels  the custom model names the picker offers
+ *
+ * So the whole "paste these four things into Settings" ritual is scriptable,
+ * and `openzoo cursor` should just do it. The editor must be CLOSED while we
+ * write, or it will overwrite us from memory on exit.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+
+const KEY = 'src.vs.platform.reactivestorage.browser.reactiveStorageServiceImpl.persistentStorage.applicationUser';
+
+const STORAGE = {
+  cursor: path.join(os.homedir(), 'Library', 'Application Support', 'Cursor', 'User', 'globalStorage', 'state.vscdb'),
+  vscode: path.join(os.homedir(), 'Library', 'Application Support', 'Code', 'User', 'globalStorage', 'state.vscdb'),
+};
+
+/** Linux/Windows put globalStorage elsewhere; resolve per platform. */
+function storagePath(which) {
+  if (process.platform === 'darwin') return STORAGE[which];
+  const dir = which === 'vscode' ? 'Code' : 'Cursor';
+  if (process.platform === 'win32') {
+    return path.join(process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming'), dir, 'User', 'globalStorage', 'state.vscdb');
+  }
+  return path.join(os.homedir(), '.config', dir, 'User', 'globalStorage', 'state.vscdb');
+}
+
+const sqlite = (db, sql) => execFileSync('sqlite3', [db, sql], { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
+
+/** True when the editor process is running — writing under it gets clobbered. */
+export function editorRunning(which) {
+  try {
+    const name = which === 'vscode' ? 'Visual Studio Code' : 'Cursor';
+    const out = execFileSync('pgrep', ['-f', name], { encoding: 'utf8' });
+    return out.trim().length > 0;
+  } catch { return false; }
+}
+
+/**
+ * Point the editor at the zoo: base URL, key toggle, and the models the picker
+ * should offer. Returns what changed, or null when the store is unavailable
+ * (a fresh install with no globalStorage yet).
+ */
+export function writeEditorProviderConfig(which, { baseUrl, models }) {
+  const db = storagePath(which);
+  if (!fs.existsSync(db)) return null;
+  try { execFileSync('sqlite3', ['-version'], { stdio: 'ignore' }); } catch { return { error: 'sqlite3 not available' }; }
+
+  const raw = sqlite(db, `SELECT value FROM ItemTable WHERE key='${KEY}';`).trim();
+  if (!raw) return null;
+  let doc;
+  try { doc = JSON.parse(raw); } catch { return { error: 'could not parse editor config' }; }
+
+  const before = { openAIBaseUrl: doc.openAIBaseUrl, models: (doc.availableAPIKeyModels || []).length };
+  doc.openAIBaseUrl = baseUrl;
+  doc.useOpenAIKey = true;
+  // Merge, don't clobber: a user may have their own custom models listed.
+  const existing = Array.isArray(doc.availableAPIKeyModels) ? doc.availableAPIKeyModels : [];
+  const names = new Set(existing.map((m) => (typeof m === 'string' ? m : m?.name)).filter(Boolean));
+  const added = [];
+  for (const m of models) {
+    if (names.has(m)) continue;
+    // Match the shape already present, so the picker renders it correctly.
+    existing.push(typeof existing[0] === 'string' ? m : { name: m, defaultOn: true, supportsAgent: true });
+    names.add(m);
+    added.push(m);
+  }
+  doc.availableAPIKeyModels = existing;
+
+  // Single-quote escaping for the SQL literal.
+  const json = JSON.stringify(doc).replace(/'/g, "''");
+  sqlite(db, `UPDATE ItemTable SET value='${json}' WHERE key='${KEY}';`);
+  return { db, before, baseUrl, added };
+}

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

@@ -20,6 +20,9 @@ import os from 'node:os';
 import path from 'node:path';
 import { spawn } from 'node:child_process';
 import { config } from './config.js';
+import { writeEditorProviderConfig, editorRunning } from './cursorcfg.js';
+
+const DEFAULT_MODELS = ['anthropic/claude-opus-5', 'deepseek/deepseek-v4-pro-0813'];
 
 const MCP_FILES = {
   cursor: path.join(os.homedir(), '.cursor', 'mcp.json'),
@@ -147,11 +150,34 @@ 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`);
-  if (publicUrl) {
-    console.log(`tunnel:  ${publicUrl}/v1   api_key ${tunnelKey}`);
-    console.log('         (use the tunnel for any cloud-run harness — it cannot reach localhost)');
-  }
   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.
+  // WRITE THE PROVIDER SETTINGS. These are plain JSON in the editor's
+  // globalStorage sqlite — not an encrypted store, as previously assumed — so
+  // the "paste four things into Settings" ritual is unnecessary. Must happen
+  // while the editor is CLOSED or it rewrites them from memory on exit.
+  const picked0 = pickEditor(which);
+  const target0 = picked0?.which || which || 'cursor';
+  if (editorRunning(target0)) {
+    console.log(`NOTE: ${target0} is already running — quit it and re-run so settings stick.`);
+  }
+  const models = [DEFAULT_MODELS[0], ...DEFAULT_MODELS.slice(1)];
+  let wrote = null;
+  try { wrote = writeEditorProviderConfig(target0, { baseUrl: base, models }); } catch (e) { wrote = { error: e.message }; }
+  if (wrote?.error) {
+    console.log(`settings: could not write automatically (${wrote.error}) — set them in Settings → Models`);
+  } else if (wrote) {
+    console.log(`settings: openAIBaseUrl -> ${base}  (was ${wrote.before.openAIBaseUrl || 'unset'})`);
+    console.log(`          useOpenAIKey  -> true`);
+    console.log(`          models added  -> ${wrote.added.length ? wrote.added.join(', ') : '(already present)'}`);
+    console.log('          pick one of those in the model dropdown; built-ins bypass the zoo.');
+  }
 
   // 3. LAUNCH with that env. Editor resolved platform-agnostically; Cursor
   //    wins when both are installed.

package/package.json

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