wolverine-ai 3.6.0 → 3.7.0

package/bin/wolverine.js

@@ -127,6 +127,10 @@ if (args.includes("--backups")) {
 
 const scriptPath = args.find(a => !a.startsWith("--")) || "server/index.js";
 
+// Initialize server/ from template if it doesn't exist (first run)
+const { initServer } = require("../src/core/init-server");
+initServer(process.cwd(), scriptPath);
+
 // System detection (for analytics + dashboard, NOT for forking)
 // Wolverine runs as a single process manager. If users want clustering,
 // they handle it inside their server (e.g. @fastify/cluster, pm2 cluster mode).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wolverine-ai",
-  "version": "3.6.0",
+  "version": "3.7.0",
   "description": "Self-healing Node.js server framework powered by AI. Catches crashes, diagnoses errors, generates fixes, verifies, and restarts — automatically.",
   "main": "src/index.js",
   "bin": {
@@ -47,7 +47,6 @@
   "files": [
     "bin/",
     "src/",
-    "server/",
     "examples/",
     ".env.example"
   ],

package/src/agent/agent-engine.js

@@ -250,7 +250,7 @@ const TOOL_DEFINITIONS = [
     type: "function",
     function: {
       name: "run_db_fix",
-      description: "Run a write query on a SQLite database to fix data issues: UPDATE invalid entries, DELETE corrupt rows, ALTER schema. Creates a backup first.",
+      description: "Run a write query on a SQLite database to fix data issues. IMPORTANT: Always use inspect_db FIRST to see the current state before writing. This tool auto-snapshots affected rows before and after the write. Creates a backup. Returns before/after state so you can verify the fix is correct.",
       parameters: {
         type: "object",
         properties: {
@@ -953,15 +953,60 @@ class AgentEngine {
       if (upper.startsWith("DROP DATABASE") || upper.includes("DROP TABLE sqlite_")) {
         return { content: "BLOCKED: Cannot drop system tables" };
       }
+
       // Backup the DB file first
       const backupPath = dbPath + ".wolverine-backup";
       fs.copyFileSync(dbPath, backupPath);
+
       const db = new Database(dbPath);
+
+      // SAFETY: Snapshot affected rows BEFORE the write
+      // Extract table name and WHERE clause to SELECT the rows that will change
+      let beforeSnapshot = "";
+      try {
+        const tableMatch = upper.match(/(?:UPDATE|DELETE\s+FROM|INSERT\s+INTO)\s+(\w+)/i);
+        const whereMatch = args.sql.match(/WHERE\s+(.+?)(?:;|$)/i);
+        if (tableMatch) {
+          const table = tableMatch[1];
+          const whereClause = whereMatch ? `WHERE ${whereMatch[1]}` : "";
+          const selectSql = `SELECT * FROM ${table} ${whereClause} LIMIT 20`;
+          try {
+            const before = db.prepare(selectSql).all();
+            if (before.length > 0) {
+              beforeSnapshot = `\n\nBEFORE STATE (${before.length} rows affected):\n${JSON.stringify(before, null, 2).slice(0, 2000)}`;
+              console.log(chalk.gray(`    🗃️ Snapshot: ${before.length} rows from ${table} ${whereClause ? whereClause.slice(0, 40) : "(all)"}`));
+            }
+          } catch { /* SELECT failed, might be INSERT into new table — that's fine */ }
+        }
+      } catch { /* snapshot failed, proceed with caution */ }
+
+      // Execute the fix
       const result = db.prepare(args.sql).run();
+
+      // SAFETY: Snapshot AFTER to show what changed
+      let afterSnapshot = "";
+      try {
+        const tableMatch = upper.match(/(?:UPDATE|DELETE\s+FROM|INSERT\s+INTO)\s+(\w+)/i);
+        const whereMatch = args.sql.match(/WHERE\s+(.+?)(?:;|$)/i);
+        if (tableMatch) {
+          const table = tableMatch[1];
+          const whereClause = whereMatch ? `WHERE ${whereMatch[1]}` : "";
+          const selectSql = `SELECT * FROM ${table} ${whereClause} LIMIT 20`;
+          try {
+            const after = db.prepare(selectSql).all();
+            afterSnapshot = `\n\nAFTER STATE (${after.length} rows):\n${JSON.stringify(after, null, 2).slice(0, 2000)}`;
+          } catch {}
+        }
+      } catch {}
+
       db.close();
       this.filesModified.push(args.db_path);
+
+      const summary = `SQL executed. Changes: ${result.changes}. Backup at: ${backupPath}${beforeSnapshot}${afterSnapshot}`;
       console.log(chalk.green(`    🗃️ DB fix applied: ${args.sql.slice(0, 60)} (changes: ${result.changes})`));
-      return { content: `SQL executed. Changes: ${result.changes}. Backup at: ${backupPath}` };
+      if (beforeSnapshot) console.log(chalk.gray(`    🗃️ Before/after snapshot captured for audit`));
+
+      return { content: summary };
     } catch (e) { return { content: `DB error: ${e.message}` }; }
   }
 
@@ -1094,14 +1139,23 @@ FAST FIXES (act immediately, don't investigate):
 - Missing env var → check_env → report it → done
 
 INVESTIGATION (only when cause is unclear):
-- Database error → inspect_db then run_db_fix
+- Database error → inspect_db FIRST to see current state → understand what went wrong → run_db_fix with targeted fix
 - Unknown errors → grep_code, list_dir to find root cause
 
+DATABASE SAFETY:
+- ALWAYS inspect_db before run_db_fix — never write blind
+- run_db_fix auto-snapshots affected rows before/after — check the response to verify your fix
+- For bad data: understand WHY the data is wrong before changing it
+- For NaN/null errors: check if the data was corrupted or if the code should handle it
+- Prefer fixing code to handle edge cases over modifying production data
+- A database backup is created automatically before every write
+
 RULES:
 1. Fix on turn 1-2 when possible. Investigation is a last resort.
 2. For ENOENT config files: read the code that requires the file, then create it with the expected structure.
 3. bash_exec for operational fixes, edit_file for code, write_file for missing files, run_db_fix for data
-4. Always call done with summary when finished — never end without calling done.
+4. For database errors: inspect first, fix data only when code can't reasonably handle the edge case
+5. Always call done with summary when finished — never end without calling done.
 ${primaryFile ? `\nFile: ${primaryFile}` : ""}
 Project: ${cwd}`;
 }

package/src/brain/brain.js

@@ -218,7 +218,7 @@ const SEED_DOCS = [
     metadata: { topic: "error-monitor" },
   },
   {
-    text: "Agent tool details: read_file supports offset/limit for large files. edit_file does surgical find-and-replace (preferred for small fixes). glob_files discovers files by pattern (**/*.js). grep_code does regex search with context lines. list_dir shows directory contents with file sizes. move_file relocates/renames files. bash_exec runs shell commands (30s default timeout, 60s hard cap, dangerous commands blocked: rm -rf /, git push --force, npm publish). inspect_db reads SQLite: action=tables (list), action=schema (CREATE statements), action=query (SELECT/PRAGMA only). run_db_fix writes SQLite: UPDATE/DELETE/INSERT/ALTER, auto-backs up db file first. check_port finds what process is using a port (netstat/lsof). check_env lists environment variables with values redacted. audit_deps runs full npm health check (vulnerabilities, outdated, peer deps, unused, lock file). check_migration returns known upgrade paths with before/after code patterns. web_fetch retrieves URL content.",
+    text: "Agent tool details: read_file supports offset/limit for large files. edit_file does surgical find-and-replace (preferred for small fixes). glob_files discovers files by pattern (**/*.js). grep_code does regex search with context lines. list_dir shows directory contents with file sizes. move_file relocates/renames files. bash_exec runs shell commands (30s default timeout, 60s hard cap, dangerous commands blocked: rm -rf /, git push --force, npm publish). inspect_db reads SQLite: action=tables (list), action=schema (CREATE statements), action=query (SELECT/PRAGMA only). run_db_fix writes SQLite with SAFETY: auto-snapshots affected rows BEFORE write (SELECT WHERE matching the UPDATE/DELETE), executes the fix, snapshots AFTER, returns before/after comparison so agent can verify. Always backs up the DB file. Agent MUST inspect_db before run_db_fix — never write blind. For NaN/null data errors: prefer fixing code to handle edge cases over modifying production data. check_port finds what process is using a port (netstat/lsof). check_env lists environment variables with values redacted. audit_deps runs full npm health check. check_migration returns known upgrade paths. web_fetch retrieves URL content.",
     metadata: { topic: "agent-tools-detail" },
   },
   {
@@ -242,7 +242,7 @@ const SEED_DOCS = [
     metadata: { topic: "backup-skill" },
   },
   {
-    text: "CRITICAL: Never run raw 'npm install wolverine-ai' or 'git pull' to update — these OVERWRITE server/, .wolverine/ (brain, backups, events), and .env.local. Always use the safe update skill: wolverine --update (CLI), safeUpdate(cwd) (programmatic), or let auto-update handle it. ALL backups (heal snapshots + update snapshots) stored in ~/.wolverine-safe-backups/ (OUTSIDE project, survives git clean, rm -rf, project deletion). Structure: ~/.wolverine-safe-backups/snapshots/ (heal backups), ~/.wolverine-safe-backups/updates/ (pre-update snapshots), ~/.wolverine-safe-backups/manifest.json (backup registry). Old .wolverine/backups/ auto-migrated on first run. Restore with: wolverine --restore <name>. List: wolverine --backups.",
+    text: "CRITICAL: Never run raw 'npm install wolverine-ai' or 'git pull' to update — these OVERWRITE server/, .wolverine/ (brain, backups, events), and .env.local. Always use the safe update skill: wolverine --update (CLI), safeUpdate(cwd) (programmatic), or let auto-update handle it. Startup backup: wolverine creates a safety snapshot of server/ before first spawn on every start. If the server crashes immediately after a bad update and healing fails/is blocked, wolverine auto-rollbacks to the startup snapshot after max retries — prevents permanent breakage from corrupted server/ files. ALL backups (heal snapshots + update snapshots + startup snapshots) stored in ~/.wolverine-safe-backups/ (OUTSIDE project, survives git clean, rm -rf, project deletion). Restore with: wolverine --restore <name>. List: wolverine --backups.",
     metadata: { topic: "safe-update-warning" },
   },
   {
@@ -304,6 +304,13 @@ class Brain {
       console.log(chalk.gray("  🧠 Framework updated — merging new seed docs..."));
       await this._mergeSeedDocs();
       try { fs.unlinkSync(seedRefreshPath); } catch {}
+    } else {
+      // Auto-detect new seeds: if SEED_DOCS count > docs namespace count, merge
+      const docsCount = (this.store.getNamespace("docs") || []).length;
+      if (SEED_DOCS.length > docsCount) {
+        console.log(chalk.gray(`  🧠 New seed docs detected (${SEED_DOCS.length} vs ${docsCount}) — merging...`));
+        await this._mergeSeedDocs();
+      }
     }
 
     // 2. Scan project for live function map

package/src/core/ai-client.js

@@ -42,12 +42,13 @@ function getClient(provider) {
 
 function _getWolverineClient() {
   if (!_wolverineClient) {
-    // Wolverine inference: direct to GPU (WOLVERINE_INFERENCE_URL) or via proxy (api.wolverinenode.xyz/v1)
-    // Direct URL = no auth needed (Vast tunnel). Proxy URL = needs WOLVERINE_API_KEY for billing.
+    // Wolverine inference: direct to GPU or via proxy
+    // WOLVERINE_GPU_KEY = internal key for direct GPU access (llama.cpp --api-key)
+    // WOLVERINE_API_KEY = user key for billed proxy access (api.wolverinenode.xyz)
     const baseURL = process.env.WOLVERINE_INFERENCE_URL
       ? process.env.WOLVERINE_INFERENCE_URL + "/v1"
       : "https://api.wolverinenode.xyz/v1";
-    const apiKey = process.env.WOLVERINE_API_KEY || "none";
+    const apiKey = process.env.WOLVERINE_GPU_KEY || process.env.WOLVERINE_API_KEY || "none";
     _wolverineClient = new OpenAI({ apiKey, baseURL });
   }
   return _wolverineClient;

package/src/core/error-parser.js

@@ -97,11 +97,11 @@ function classifyError(errorMessage, fullStderr) {
   const full = (fullStderr || "").toLowerCase();
 
   // Missing npm package: Cannot find module 'cors' (not a relative path)
-  if (/cannot find module '(?![./\\])/.test(msg) || /module_not_found/.test(full)) {
+  if (/cannot find module ['"](?![./\\])/.test(msg) || /module_not_found/.test(full)) {
     return "missing_module";
   }
   // Missing local file: Cannot find module './routes/api'
-  if (/cannot find module '[./\\]/.test(msg) || /enoent/.test(msg)) {
+  if (/cannot find module ['"][./\\]/.test(msg) || /enoent/.test(msg)) {
     return "missing_file";
   }
   // Permission denied

package/src/core/init-server.js

@@ -0,0 +1,58 @@
+const fs = require("fs");
+const path = require("path");
+const chalk = require("chalk");
+
+/**
+ * Initialize the server/ directory from the built-in template.
+ *
+ * Called on first run if server/ doesn't exist. NEVER overwrites existing files.
+ * This is why wolverine ships without a server/ directory in the npm package —
+ * so `npm install` and `git pull` can never destroy user code.
+ *
+ * The template lives in src/templates/server/ and contains a minimal Fastify
+ * server with health, api, and time routes + default settings.json.
+ */
+function initServer(cwd, scriptPath) {
+  const serverDir = path.join(cwd, "server");
+  const scriptFile = path.resolve(cwd, scriptPath);
+
+  // If the script file already exists, nothing to do
+  if (fs.existsSync(scriptFile)) return false;
+
+  // If server/ exists but the specific script doesn't, don't create — user has their own structure
+  if (fs.existsSync(serverDir) && fs.readdirSync(serverDir).length > 0) {
+    console.log(chalk.yellow(`  ⚠️  ${scriptPath} not found but server/ exists — skipping template init`));
+    return false;
+  }
+
+  // Create server/ from template
+  const templateDir = path.join(__dirname, "..", "templates", "server");
+  if (!fs.existsSync(templateDir)) {
+    console.log(chalk.yellow("  ⚠️  No server template found — create server/index.js manually"));
+    return false;
+  }
+
+  console.log(chalk.blue("  📦 Creating default server/ from template..."));
+  _copyDir(templateDir, serverDir);
+  console.log(chalk.green("  ✅ Server initialized. Edit server/ to build your app."));
+  return true;
+}
+
+function _copyDir(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      _copyDir(srcPath, destPath);
+    } else {
+      // NEVER overwrite existing files
+      if (!fs.existsSync(destPath)) {
+        fs.copyFileSync(srcPath, destPath);
+        console.log(chalk.gray(`    + ${path.relative(dest, destPath)}`));
+      }
+    }
+  }
+}
+
+module.exports = { initServer };

package/src/core/runner.js

@@ -246,6 +246,15 @@ class WolverineRunner {
       console.log(chalk.gray("  🔄 Auto-update: disabled"));
     }
 
+    // Create startup backup — safety net for corrupted server/ from bad updates
+    // If the child crashes immediately after this, we can rollback to this known state
+    try {
+      this._startupBackupId = this.backupManager.createBackup("pre-start (safety snapshot)");
+      console.log(chalk.gray(`  📸 Startup backup: ${this._startupBackupId}`));
+    } catch (err) {
+      console.log(chalk.yellow(`  ⚠️  Startup backup failed (non-fatal): ${err.message}`));
+    }
+
     this._spawn();
   }
 
@@ -566,6 +575,20 @@ class WolverineRunner {
           console.log(chalk.yellow("   Retrying...\n"));
           this._spawn();
         } else {
+          // Max retries — try rolling back to startup backup as last resort
+          if (this._startupBackupId) {
+            console.log(chalk.yellow(`\n  🔄 Max retries reached — rolling back to startup backup ${this._startupBackupId}...`));
+            try {
+              this.backupManager.rollbackTo(this._startupBackupId);
+              console.log(chalk.green("  ✅ Rolled back to startup state. Restarting..."));
+              this.retryCount = 0;
+              this._startupBackupId = null; // don't rollback again if this also fails
+              this._spawn();
+              return;
+            } catch (rbErr) {
+              console.log(chalk.red(`  ❌ Rollback failed: ${rbErr.message}`));
+            }
+          }
           console.log(chalk.red("   Max retries reached."));
           this._logRollbackHint();
           this.running = false;
@@ -590,11 +613,37 @@ class WolverineRunner {
     this._healStatus = { active: true, route: routePath, error: errorDetails?.message?.slice(0, 200), phase: "diagnosing", startedAt: Date.now() };
     this.logger.info("heal.error_monitor", `Healing caught 500 on ${routePath}`, { route: routePath });
 
-    // Build a synthetic stderr from the error details
+    // Build synthetic stderr that matches the error parser's expected format
+    // If IPC didn't include a file, try to resolve from the route path or stack
+    let file = errorDetails.file;
+    let line = errorDetails.line || 1;
+    if (!file && errorDetails.stack) {
+      // Try to find user-land file in stack (not node_modules, not node:)
+      const frames = (errorDetails.stack || "").split("\n");
+      for (const frame of frames) {
+        const m = frame.match(/\(([^)]+):(\d+):(\d+)\)/) || frame.match(/at\s+([^\s(]+):(\d+):(\d+)/);
+        if (m && !m[1].includes("node_modules") && !m[1].includes("node:")) {
+          file = m[1]; line = parseInt(m[2], 10); break;
+        }
+      }
+    }
+    if (!file && routePath) {
+      // Last resort: map route path to likely file (e.g., /breakable → server/routes/breakable.js)
+      const routeName = routePath.split("/").filter(Boolean).pop();
+      if (routeName) {
+        const path = require("path");
+        const guess = path.join(this.cwd, "server", "routes", routeName + ".js");
+        if (require("fs").existsSync(guess)) { file = guess; line = 1; }
+      }
+    }
+
+    const msg = errorDetails.message || "Unknown error";
+    const hasErrorPrefix = /^\w*Error:/.test(msg);
     const stderr = [
-      errorDetails.message || "Unknown error",
+      file ? `${file}:${line}` : "",
+      hasErrorPrefix ? msg : `Error: ${msg}`,
       errorDetails.stack || "",
-      errorDetails.file ? `    at ${errorDetails.file}:${errorDetails.line || 0}` : "",
+      file ? `    at ${file}:${line}:1` : "",
     ].filter(Boolean).join("\n");
 
     try {

package/server/routes/inference.js

@@ -1,324 +0,0 @@
-const https = require("https");
-const http = require("http");
-const crypto = require("crypto");
-
-/**
- * Wolverine Inference API
- *
- * Credit system: $1 = 100 credits. 1 credit = $0.01 of compute.
- * Token pricing (in credits per million tokens):
- *   wolverine-test-1: 1 credit input / 4 credits output per 1M tokens
- *   (= $0.01/$0.04 per 1M — 15x cheaper than gpt-4o-mini, 80x cheaper than haiku)
- *
- * Rate limiting: per API key, configurable per tier.
- * Queue: when GPU is at capacity, requests queue with timeout.
- */
-
-const INFERENCE_URL = process.env.WOLVERINE_INFERENCE_URL || "https://clips-third-players-binding.trycloudflare.com";
-
-// Pricing in CREDITS per million tokens ($1 = 100 credits)
-const MODEL_PRICING = {
-  "wolverine-test-1":  { input: 1.0, output: 4.0 },   // $0.01/$0.04 per 1M
-  "wolverine-coding":  { input: 1.0, output: 4.0 },
-  "wolverine-reasoning": { input: 2.5, output: 10.0 }, // heavier model when available
-};
-
-const MODEL_MAP = {
-  "wolverine-test-1": "wolverine-test-1",
-  "wolverine-coding": "wolverine-test-1",
-  "wolverine-reasoning": "wolverine-test-1",
-};
-
-const TIER_LIMITS = {
-  free: { rpm: 10, maxTokens: 1024 },
-  starter: { rpm: 60, maxTokens: 4096 },
-  pro: { rpm: 300, maxTokens: 4096 },
-  admin: { rpm: 9999, maxTokens: 4096 },
-};
-
-function tokenCost(model, inputTokens, outputTokens) {
-  const p = MODEL_PRICING[model] || MODEL_PRICING["wolverine-test-1"];
-  return ((inputTokens / 1_000_000) * p.input) + ((outputTokens / 1_000_000) * p.output);
-}
-
-// ── Request Queue (handles GPU saturation) ──
-const queue = [];
-let activeRequests = 0;
-const MAX_CONCURRENT = 8; // vLLM max-num-seqs
-const QUEUE_TIMEOUT_MS = 30000;
-
-function enqueue() {
-  return new Promise((resolve, reject) => {
-    if (activeRequests < MAX_CONCURRENT) {
-      activeRequests++;
-      resolve();
-      return;
-    }
-    const timer = setTimeout(() => {
-      const idx = queue.indexOf(entry);
-      if (idx >= 0) queue.splice(idx, 1);
-      reject(new Error("Queue timeout — GPU at capacity. Try again in a few seconds."));
-    }, QUEUE_TIMEOUT_MS);
-    const entry = { resolve: () => { clearTimeout(timer); activeRequests++; resolve(); }, reject };
-    queue.push(entry);
-  });
-}
-
-function dequeue() {
-  activeRequests = Math.max(0, activeRequests - 1);
-  if (queue.length > 0) {
-    const next = queue.shift();
-    next.resolve();
-  }
-}
-
-async function routes(fastify) {
-  const { pool } = require("../lib/db");
-
-  // Rate limit state (in-memory)
-  const rateWindows = new Map();
-
-  async function authenticate(request, reply) {
-    const apiKey = request.headers.authorization?.replace("Bearer ", "") || request.headers["x-api-key"];
-    if (!apiKey) return reply.code(401).send({ error: { message: "API key required. Pass via Authorization: Bearer <key>", type: "auth_error" } });
-
-    // Platform key bypass
-    let settings = {};
-    try { settings = require("../config/settings.json"); } catch {}
-    if (apiKey === settings.platform?.apiKey) {
-      request.account = { api_key: apiKey, owner: "platform", tier: "admin", credits_remaining: 999999, rate_limit_rpm: 9999 };
-      return;
-    }
-
-    const result = await pool.query("SELECT * FROM api_credits WHERE api_key = $1", [apiKey]);
-    if (result.rows.length === 0) return reply.code(401).send({ error: { message: "Invalid API key", type: "auth_error" } });
-
-    const account = result.rows[0];
-
-    // Credit check
-    if (parseFloat(account.credits_remaining) <= 0) {
-      return reply.code(402).send({ error: { message: "Insufficient credits. Add credits at wolverinenode.xyz", type: "billing_error", credits_remaining: 0 } });
-    }
-
-    // Rate limit
-    const now = Date.now();
-    const window = rateWindows.get(apiKey) || { count: 0, resetAt: now + 60000 };
-    if (now > window.resetAt) { window.count = 0; window.resetAt = now + 60000; }
-    const limit = account.rate_limit_rpm || TIER_LIMITS[account.tier]?.rpm || 10;
-    if (window.count >= limit) {
-      const retryAfter = Math.ceil((window.resetAt - now) / 1000);
-      return reply.code(429).send({ error: { message: `Rate limit: ${limit} requests/min. Retry in ${retryAfter}s`, type: "rate_limit", retry_after: retryAfter } });
-    }
-    window.count++;
-    rateWindows.set(apiKey, window);
-
-    request.account = account;
-  }
-
-  // ── POST /chat/completions ──
-  fastify.post("/chat/completions", { preHandler: authenticate }, async (request, reply) => {
-    const body = request.body || {};
-    const requestedModel = body.model || "wolverine-test-1";
-    const account = request.account;
-    const tier = TIER_LIMITS[account.tier] || TIER_LIMITS.free;
-    const startMs = Date.now();
-
-    // Enforce max tokens per tier
-    if (body.max_tokens && body.max_tokens > tier.maxTokens) {
-      body.max_tokens = tier.maxTokens;
-    }
-
-    // Map model name for backend
-    const backendBody = { ...body, model: MODEL_MAP[requestedModel] || requestedModel };
-
-    // Queue if GPU saturated
-    try {
-      await enqueue();
-    } catch (err) {
-      return reply.code(503).send({ error: { message: err.message, type: "capacity_error", queue_length: queue.length } });
-    }
-
-    try {
-      const result = await proxyToInference("/v1/chat/completions", backendBody);
-      const latencyMs = Date.now() - startMs;
-
-      const usage = result.usage || {};
-      const inputTokens = usage.prompt_tokens || 0;
-      const outputTokens = usage.completion_tokens || 0;
-      const cost = tokenCost(requestedModel, inputTokens, outputTokens);
-
-      // Bill credits (skip for platform)
-      if (account.owner !== "platform") {
-        await pool.query(
-          "UPDATE api_credits SET credits_remaining = credits_remaining - $1, credits_used = credits_used + $1, last_used = NOW() WHERE api_key = $2",
-          [cost, account.api_key]
-        );
-        await pool.query(
-          "INSERT INTO api_usage_log (api_key, model, input_tokens, output_tokens, total_tokens, cost, latency_ms, success, endpoint) VALUES ($1, $2, $3, $4, $5, $6, $7, true, $8)",
-          [account.api_key, requestedModel, inputTokens, outputTokens, inputTokens + outputTokens, cost, latencyMs, "/v1/chat/completions"]
-        );
-      }
-
-      // Rewrite response
-      if (result.model) result.model = requestedModel;
-      result.x_wolverine = {
-        credits_used: Math.round(cost * 1000000) / 1000000,
-        credits_remaining: Math.max(0, parseFloat(account.credits_remaining) - cost),
-        latency_ms: latencyMs,
-        queued: activeRequests > MAX_CONCURRENT,
-      };
-
-      return result;
-    } catch (err) {
-      if (account.owner !== "platform") {
-        await pool.query(
-          "INSERT INTO api_usage_log (api_key, model, input_tokens, output_tokens, total_tokens, cost, latency_ms, success, endpoint) VALUES ($1, $2, 0, 0, 0, 0, $3, false, $4)",
-          [account.api_key, requestedModel, Date.now() - startMs, "/v1/chat/completions"]
-        ).catch(() => {});
-      }
-      return reply.code(502).send({ error: { message: `Inference error: ${err.message}`, type: "inference_error" } });
-    } finally {
-      dequeue();
-    }
-  });
-
-  // ── GET /models ──
-  fastify.get("/models", async () => ({
-    object: "list",
-    data: Object.entries(MODEL_PRICING).map(([id, p]) => ({
-      id, object: "model", owned_by: "wolverine",
-      created: Math.floor(Date.now() / 1000),
-      pricing: { input_credits_per_million: p.input, output_credits_per_million: p.output, usd_per_credit: 0.01 },
-    })),
-  }));
-
-  // ── POST /keys/create — generate new API key ──
-  fastify.post("/keys/create", { preHandler: authenticate }, async (request, reply) => {
-    const account = request.account;
-    if (account.tier !== "admin") return reply.code(403).send({ error: { message: "Only admins can create API keys", type: "auth_error" } });
-
-    const { owner, email, credits, tier, rpm } = request.body || {};
-    if (!owner) return reply.code(400).send({ error: { message: "owner required", type: "validation_error" } });
-
-    const newKey = "wlv_" + crypto.randomBytes(24).toString("hex");
-    const keyTier = tier || "free";
-    const keyCredits = credits || (keyTier === "free" ? 10 : 0);
-    const keyRpm = rpm || TIER_LIMITS[keyTier]?.rpm || 10;
-
-    await pool.query(
-      "INSERT INTO api_credits (api_key, owner, email, credits_remaining, tier, plan_name, rate_limit_rpm) VALUES ($1, $2, $3, $4, $5, $6, $7)",
-      [newKey, owner, email || null, keyCredits, keyTier, keyTier, keyRpm]
-    );
-
-    return { api_key: newKey, owner, tier: keyTier, credits: keyCredits, rate_limit_rpm: keyRpm };
-  });
-
-  // ── POST /keys/add-credits — add credits to a key ──
-  fastify.post("/keys/add-credits", { preHandler: authenticate }, async (request, reply) => {
-    const account = request.account;
-    if (account.tier !== "admin") return reply.code(403).send({ error: { message: "Only admins can add credits", type: "auth_error" } });
-
-    const { api_key, credits } = request.body || {};
-    if (!api_key || !credits) return reply.code(400).send({ error: { message: "api_key and credits required" } });
-
-    await pool.query("UPDATE api_credits SET credits_remaining = credits_remaining + $1 WHERE api_key = $2", [credits, api_key]);
-    const updated = await pool.query("SELECT credits_remaining FROM api_credits WHERE api_key = $1", [api_key]);
-    return { api_key, credits_added: credits, credits_remaining: parseFloat(updated.rows[0]?.credits_remaining || 0) };
-  });
-
-  // ── GET /keys — list all keys (admin only) ──
-  fastify.get("/keys", { preHandler: authenticate }, async (request, reply) => {
-    if (request.account.tier !== "admin") return reply.code(403).send({ error: { message: "Admin only" } });
-    const { rows } = await pool.query("SELECT api_key, owner, email, tier, credits_remaining, credits_used, rate_limit_rpm, created_at, last_used FROM api_credits ORDER BY created_at DESC");
-    return { keys: rows };
-  });
-
-  // ── GET /credits ──
-  fastify.get("/credits", { preHandler: authenticate }, async (request, reply) => {
-    const a = request.account;
-    return {
-      credits_remaining: parseFloat(a.credits_remaining),
-      credits_used: parseFloat(a.credits_used || 0),
-      usd_remaining: parseFloat(a.credits_remaining) * 0.01,
-      usd_used: parseFloat(a.credits_used || 0) * 0.01,
-      tier: a.tier, rate_limit_rpm: a.rate_limit_rpm, owner: a.owner,
-    };
-  });
-
-  // ── GET /usage ──
-  fastify.get("/usage", { preHandler: authenticate }, async (request, reply) => {
-    const apiKey = request.account.api_key;
-    const period = request.query.period || "7d";
-    const interval = { "1h": "1 hour", "1d": "1 day", "7d": "7 days", "30d": "30 days" }[period] || "7 days";
-
-    const summary = await pool.query(
-      `SELECT model, COUNT(*) AS calls, SUM(input_tokens) AS input, SUM(output_tokens) AS output,
-              SUM(total_tokens) AS tokens, SUM(cost) AS credits_spent, AVG(latency_ms) AS avg_latency,
-              COUNT(*) FILTER (WHERE success) AS successes
-       FROM api_usage_log WHERE api_key = $1 AND timestamp > NOW() - $2::interval
-       GROUP BY model ORDER BY credits_spent DESC`, [apiKey, interval]
-    );
-
-    const timeline = await pool.query(
-      `SELECT date_trunc('hour', timestamp) AS hour, SUM(cost) AS credits, SUM(total_tokens) AS tokens, COUNT(*) AS calls
-       FROM api_usage_log WHERE api_key = $1 AND timestamp > NOW() - $2::interval
-       GROUP BY hour ORDER BY hour`, [apiKey, interval]
-    );
-
-    const totalCredits = summary.rows.reduce((s, r) => s + parseFloat(r.credits_spent || 0), 0);
-
-    return {
-      period,
-      total_credits_spent: Math.round(totalCredits * 1000000) / 1000000,
-      total_usd_spent: Math.round(totalCredits * 0.01 * 1000000) / 1000000,
-      byModel: summary.rows.map(r => ({
-        model: r.model, calls: parseInt(r.calls), input: parseInt(r.input || 0), output: parseInt(r.output || 0),
-        tokens: parseInt(r.tokens || 0), credits_spent: parseFloat(r.credits_spent || 0),
-        usd_spent: parseFloat(r.credits_spent || 0) * 0.01,
-        avgLatencyMs: Math.round(parseFloat(r.avg_latency || 0)),
-        successRate: parseInt(r.calls) > 0 ? parseFloat(((parseInt(r.successes) / parseInt(r.calls)) * 100).toFixed(2)) : 0,
-      })),
-      timeline: timeline.rows.map(r => ({
-        hour: r.hour, credits: parseFloat(r.credits), tokens: parseInt(r.tokens), calls: parseInt(r.calls),
-      })),
-      queue: { active: activeRequests, waiting: queue.length, max: MAX_CONCURRENT },
-    };
-  });
-
-  // ── GET /health ──
-  fastify.get("/health", async () => {
-    try {
-      const result = await proxyToInference("/health", null, "GET");
-      return { status: "ok", inference: result, queue: { active: activeRequests, waiting: queue.length, max: MAX_CONCURRENT } };
-    } catch (err) {
-      return { status: "down", error: err.message, queue: { active: activeRequests, waiting: queue.length, max: MAX_CONCURRENT } };
-    }
-  });
-}
-
-function proxyToInference(path, body, method = "POST") {
-  return new Promise((resolve, reject) => {
-    const url = new (require("url").URL)(INFERENCE_URL + path);
-    const client = url.protocol === "https:" ? https : http;
-    const bodyStr = body ? JSON.stringify(body) : null;
-
-    const req = client.request({
-      hostname: url.hostname,
-      port: url.port || (url.protocol === "https:" ? 443 : 80),
-      path: url.pathname,
-      method,
-      timeout: 120000,
-      headers: { "Content-Type": "application/json", ...(bodyStr ? { "Content-Length": Buffer.byteLength(bodyStr) } : {}) },
-    }, (res) => {
-      let data = "";
-      res.on("data", (c) => { data += c; });
-      res.on("end", () => { try { resolve(JSON.parse(data)); } catch { resolve({ raw: data }); } });
-    });
-    req.on("error", reject);
-    req.on("timeout", () => { req.destroy(); reject(new Error("Inference timeout")); });
-    if (bodyStr) req.write(bodyStr);
-    req.end();
-  });
-}
-
-module.exports = routes;