total-recall-brain 3.12.2 → 3.13.0

package/src/server/rest.mjs

@@ -806,6 +806,7 @@ router.get('/api/import/rules', requireAuth, requireScope('memory:read'), (req,
     if (dirs.length === 0) return badRequest(res, 'No permitted directories specified');
     const detected = detectRuleFiles(dirs);
     res.json({ dirs, detected });
+    
   } catch (err) { serverError(res, err); }
 });
 
@@ -825,6 +826,7 @@ router.post('/api/import/rules', requireAuth, requireScope('memory:write'), (req
     if (dryRun) return res.json({ dryRun: true, detected, toImport, imported: [], skipped: [], failed: [] });
     const result = importRuleFiles(toImport, { force, vaultDir: VAULT_DIR });
     res.json({ detected, ...result });
+    
   } catch (err) { serverError(res, err); }
 });
 
@@ -859,6 +861,7 @@ router.get('/api/brain/export', requireAuth, requireScope('brain:export'), async
     tar.stdout.pipe(res);
     tar.on('error', err => { if (!res.headersSent) serverError(res, err); });
     tar.on('close', code => { if (code !== 0 && !res.writableEnded) res.end(); });
+    
   } catch (err) { serverError(res, err); }
 });
 
@@ -921,6 +924,7 @@ router.get('/api/extension/status', requireAuth, requireScope('config:read'), as
     const connected = fs.existsSync(markerPath);
 
     res.json({ available, connected, version });
+    
   } catch (err) { serverError(res, err); }
 });
 
@@ -945,6 +949,7 @@ router.get('/api/graph', requireAuth, requireScope('ssss:read'), (req, res) => {
       ? fs.readFileSync(routesFile, 'utf8').split('\n').filter(Boolean).map(l => JSON.parse(l))
       : [];
     res.json({ nodes, routes });
+    
   } catch (err) { serverError(res, err); }
 });
 
@@ -1040,6 +1045,7 @@ router.get('/api/files', requireAuth, requireScope('files:read'), (req, res) =>
       };
     });
     res.json(files);
+    
   } catch (err) { serverError(res, err); }
 });
 
@@ -1170,6 +1176,7 @@ router.get('/api/logs/:type', requireAuth, requireScope('health:read'), (req, re
     const lines = content.split('\n');
     const lastLines = lines.slice(-200).join('\n');
     res.json({ content: lastLines });
+    
   } catch (err) { serverError(res, err); }
 });
 
@@ -1199,6 +1206,7 @@ router.get('/api/tasks', requireAuth, requireScope('tasks:read'), (req, res) =>
       }
     }
     res.json(tasks.sort((a, b) => (a.priority || 5) - (b.priority || 5)));
+    
   } catch (err) { serverError(res, err); }
 });
 
@@ -1224,6 +1232,7 @@ router.delete('/api/tasks/cleanup', requireAuth, requireScope('tasks:write'), (r
       }
     }
     res.json({ deleted });
+    
   } catch (err) { serverError(res, err); }
 });
 
@@ -1252,6 +1261,7 @@ router.post('/api/tasks', requireAuth, requireScope('tasks:write'), (req, res) =
     const raw = safeStringify(body || '', frontmatter);
     fs.writeFileSync(path.join(TASKS_DIR, `${slug}.md`), raw, 'utf8');
     res.json({ slug, ...frontmatter });
+    
   } catch (err) { serverError(res, err); }
 });
 
@@ -1313,6 +1323,7 @@ router.get('/api/config-json', requireAuth, requireScope('config:read'), (req, r
     }
 
     res.json({ security, budget, brain: safeBrain, secrets: safeSecrets });
+    
   } catch (err) { serverError(res, err); }
 });
 
@@ -1369,12 +1380,18 @@ router.post('/api/config-json', requireAuth, requireScope('config:write'), (req,
     }
 
     res.json({ success: true });
+    
   } catch (err) { serverError(res, err); }
 });
 
 router.get('/api/usage', requireAuth, async (req, res) => {
   try {
-    const { calculateCurrentCost } = await import('../core/usage-tracker.mjs');
+    const { syncUsageLedger, calculateCurrentCost } = await import('../core/usage-tracker.mjs');
+    
+    // Sync the ledger first to capture new logs and lock in current prices
+    const pricingMap = await getPricingMap();
+    syncUsageLedger(pricingMap);
+    
     res.json(calculateCurrentCost());
   } catch (err) { serverError(res, err); }
 });
@@ -1391,6 +1408,7 @@ router.get('/api/config/:name', requireAuth, requireScope('config:read'), (req,
     }
     const content = fs.readFileSync(filePath, 'utf8');
     res.json({ content });
+    
   } catch (err) { serverError(res, err); }
 });
 
@@ -1403,6 +1421,7 @@ router.put('/api/config/:name', requireAuth, requireScope('config:write'), (req,
     }
     fs.writeFileSync(filePath, req.body.content, 'utf8');
     res.json({ success: true });
+    
   } catch (err) { serverError(res, err); }
 });
 
@@ -1427,6 +1446,41 @@ router.post('/api/capture/:source', requireAuth, requireScope('memory:write'), a
     const result = captureMessage({ text, author, channel, source });
     res.json({ ok: true, slug: result.slug });
   } catch (err) {
+    console.error("API ERROR:", err);
+    res.status(500).json({ error: err.message });
+  }
+});
+
+/**
+ * GET /api/openrouter-models
+ * Dynamically fetches the list of available OpenRouter models.
+ */
+router.get('/api/openrouter-models', requireAuth, async (req, res) => {
+  try {
+    const response = await fetch('https://openrouter.ai/api/v1/models');
+    if (response.ok) {
+      const data = await response.json();
+      const models = data.data.map(m => {
+        return {
+          id: m.id,
+          displayName: m.name,
+          pricing: m.pricing,
+          created: m.created || 0
+        };
+      });
+      // Sort first by provider (alphabetical), then by created (descending)
+      models.sort((a, b) => {
+        const provA = a.id.split('/')[0];
+        const provB = b.id.split('/')[0];
+        if (provA < provB) return -1;
+        if (provA > provB) return 1;
+        return b.created - a.created;
+      });
+      return res.json({ models });
+    }
+    throw new Error(`OpenRouter API responded with ${response.status}`);
+  } catch (err) {
+    console.error("API ERROR:", err);
     res.status(500).json({ error: err.message });
   }
 });
@@ -1687,6 +1741,7 @@ router.get('/api/brains', requireAuth, requireScope('ssss:read'), (req, res) =>
     }
 
     res.json({ brains });
+    
   } catch (err) { serverError(res, err); }
 });
 
@@ -1740,6 +1795,35 @@ router.get('/api/brains/:id/nodes', requireAuth, requireScope('ssss:read', 'memo
   } catch (err) { serverError(res, err); }
 });
 
+let cachedPricingMap = null;
+let lastPricingFetch = 0;
+
+async function getPricingMap() {
+  if (cachedPricingMap && Date.now() - lastPricingFetch < 1000 * 60 * 60) {
+    return cachedPricingMap;
+  }
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 3000);
+    const response = await fetch('https://openrouter.ai/api/v1/models', { signal: controller.signal });
+    clearTimeout(timeoutId);
+    if (response.ok) {
+      const data = await response.json();
+      const map = {};
+      for (const m of (data.data || [])) {
+        const parts = m.id.split('/');
+        const baseId = parts[parts.length - 1];
+        map[baseId] = m.pricing;
+        map[m.id] = m.pricing;
+      }
+      cachedPricingMap = map;
+      lastPricingFetch = Date.now();
+      return map;
+    }
+  } catch (e) {}
+  return {};
+}
+
 /**
  * GET /api/gemini-models
  * Dynamically fetches the list of available Gemini models using the user's GOOGLE_API_KEY.
@@ -1773,10 +1857,11 @@ router.get('/api/gemini-models', requireAuth, async (req, res) => {
 
           const uniqueModels = [...new Set(discovered)];
           if (uniqueModels.length > 0) {
+            const pricingMap = await getPricingMap();
             const cliModels = uniqueModels.map(modelId => {
               const parts = modelId.split('-');
               const displayName = parts.map(p => p.charAt(0).toUpperCase() + p.slice(1)).join(' ');
-              return { id: modelId, displayName };
+              return { id: modelId, displayName, pricing: pricingMap[modelId] || pricingMap[`google/${modelId}`] };
             });
             return res.json({ models: cliModels, source: 'cli' });
           }
@@ -1786,38 +1871,20 @@ router.get('/api/gemini-models', requireAuth, async (req, res) => {
       // Fail silently and fall back
     }
 
-    let apiKey = process.env.GOOGLE_API_KEY;
+    let apiKey = process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY;
     if (!apiKey) {
-      // Find GOOGLE_API_KEY in upwards .env files
       try {
-        let dir = process.cwd();
-        while (dir !== path.dirname(dir)) {
-          const envPath = path.join(dir, '.env');
-          if (fs.existsSync(envPath)) {
-            const content = fs.readFileSync(envPath, 'utf8');
-            for (const line of content.split('\n')) {
-              const match = line.match(/^\s*GOOGLE_API_KEY\s*=\s*(["']?)(.*?)\1\s*$/);
-              if (match) {
-                apiKey = match[2];
-                break;
-              }
-            }
-          }
-          if (apiKey) break;
-          dir = path.dirname(dir);
+        const secretsPath = path.join(AGENT_DIR, 'secrets.enc');
+        if (fs.existsSync(secretsPath)) {
+          const secrets = JSON.parse(fs.readFileSync(secretsPath, 'utf8')) || {};
+          apiKey = secrets.gemini_api_key || secrets.google_api_key;
         }
       } catch {}
     }
 
-    const fallbackModels = [
-      { id: 'gemini-3.5-flash', displayName: 'Gemini 3.5 Flash' },
-      { id: 'gemini-3.1-pro-preview', displayName: 'Gemini 3.1 Pro Preview' },
-      { id: 'gemini-3.1-flash-lite', displayName: 'Gemini 3.1 Flash Lite' }
-    ];
 
-    if (!apiKey) {
-      return res.json({ models: fallbackModels, source: 'fallback' });
-    }
+
+    if (!apiKey) return res.json({ models: [], source: 'missing_key' });
 
     try {
       const controller = new AbortController();
@@ -1829,6 +1896,7 @@ router.get('/api/gemini-models', requireAuth, async (req, res) => {
 
       if (response.ok) {
         const data = await response.json();
+        const pricingMap = await getPricingMap();
         const models = (data.models || [])
           .filter(m => m.name.startsWith('models/gemini-') || m.name.startsWith('models/gemini'))
           .map(m => {
@@ -1836,30 +1904,126 @@ router.get('/api/gemini-models', requireAuth, async (req, res) => {
             // Create nice display name e.g., "gemini-3.5-flash" -> "Gemini 3.5 Flash"
             const parts = id.split('-');
             const displayName = parts.map(p => p.charAt(0).toUpperCase() + p.slice(1)).join(' ');
-            return { id, displayName };
+            const pricing = pricingMap[`google/${id}`] || pricingMap[id] || null;
+            return { id, displayName, pricing };
           })
-          .filter(m => {
-            // Only keep Gemini 3.1 and newer models
-            const match = m.id.match(/^gemini-(\d+)\.(\d+)/);
-            if (match) {
-              const major = parseInt(match[1], 10);
-              const minor = parseInt(match[2], 10);
-              return major > 3 || (major === 3 && minor >= 1);
-            }
-            const majorMatch = m.id.match(/^gemini-(\d+)/);
-            if (majorMatch) {
-              const major = parseInt(majorMatch[1], 10);
-              return major >= 3;
-            }
-            return false;
+          ;
+        if (models.length > 0) {
+          return res.json({ models, source: 'dynamic' });
+        }
+      }
+    } catch {}
+
+    res.json({ models: [], source: 'api_error' });
+  } catch (err) {
+    serverError(res, err);
+  }
+});
+
+/**
+ * GET /api/claude-models
+ * Dynamically fetches the list of available Anthropic models using the user's ANTHROPIC_API_KEY.
+ */
+router.get('/api/claude-models', requireAuth, async (req, res) => {
+  try {
+    let apiKey = process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) {
+      try {
+        const secretsPath = path.join(AGENT_DIR, 'secrets.enc');
+        if (fs.existsSync(secretsPath)) {
+          const secrets = JSON.parse(fs.readFileSync(secretsPath, 'utf8')) || {};
+          apiKey = secrets.anthropic_api_key;
+        }
+      } catch {}
+    }
+
+
+
+    if (!apiKey) return res.json({ models: [], source: 'missing_key' });
+
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 5000);
+      const response = await fetch('https://api.anthropic.com/v1/models', {
+        headers: {
+          'x-api-key': apiKey,
+          'anthropic-version': '2023-06-01'
+        },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+
+      if (response.ok) {
+        const data = await response.json();
+        const pricingMap = await getPricingMap();
+        const models = (data.data || []).map(m => {
+          const parts = m.id.split('-');
+          const displayName = parts.map(p => p.charAt(0).toUpperCase() + p.slice(1)).join(' ');
+          const pricing = pricingMap[`openai/${m.id}`] || pricingMap[m.id] || null;
+          return { id: m.id, displayName, pricing };
+        });
+        if (models.length > 0) {
+          return res.json({ models, source: 'dynamic' });
+        }
+      }
+    } catch {}
+
+    res.json({ models: [], source: 'api_error' });
+  } catch (err) {
+    serverError(res, err);
+  }
+});
+
+/**
+ * GET /api/openai-models
+ * Dynamically fetches the list of available OpenAI models using the user's OPENAI_API_KEY.
+ */
+router.get('/api/openai-models', requireAuth, async (req, res) => {
+  try {
+    let apiKey = process.env.OPENAI_API_KEY;
+    if (!apiKey) {
+      try {
+        const secretsPath = path.join(AGENT_DIR, 'secrets.enc');
+        if (fs.existsSync(secretsPath)) {
+          const secrets = JSON.parse(fs.readFileSync(secretsPath, 'utf8')) || {};
+          apiKey = secrets.openai_api_key;
+        }
+      } catch {}
+    }
+
+
+
+    if (!apiKey) return res.json({ models: [], source: 'missing_key' });
+
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 5000);
+      const response = await fetch('https://api.openai.com/v1/models', {
+        headers: {
+          'Authorization': `Bearer ${apiKey}`
+        },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+
+      if (response.ok) {
+        const data = await response.json();
+        const pricingMap = await getPricingMap();
+        const models = (data.data || [])
+          .filter(m => m.id.startsWith('gpt-') || m.id.startsWith('o1') || m.id.startsWith('o3') || m.id.startsWith('o4') || m.id.startsWith('chatgpt-'))
+          .map(m => {
+            const pricing = pricingMap[`openai/${m.id}`] || pricingMap[m.id] || null;
+            return { id: m.id, displayName: m.id, pricing };
           });
+          
         if (models.length > 0) {
+          models.sort((a, b) => a.id.localeCompare(b.id));
           return res.json({ models, source: 'dynamic' });
         }
       }
     } catch {}
 
-    res.json({ models: fallbackModels, source: 'fallback_error' });
+    res.json({ models: [], source: 'api_error' });
   } catch (err) {
     serverError(res, err);
   }

package/src/server/route-manifest.json

@@ -23,6 +23,10 @@
     "method": "POST",
     "path": "/api/capture/:source"
   },
+  {
+    "method": "GET",
+    "path": "/api/claude-models"
+  },
   {
     "method": "GET",
     "path": "/api/config"
@@ -183,6 +187,14 @@
     "method": "GET",
     "path": "/api/memory/stats"
   },
+  {
+    "method": "GET",
+    "path": "/api/openai-models"
+  },
+  {
+    "method": "GET",
+    "path": "/api/openrouter-models"
+  },
   {
     "method": "GET",
     "path": "/api/research"

package/src/server/routes/_shared.mjs

@@ -40,7 +40,7 @@ export const MODEL_CATALOG_DIR = path.join(ROOT, 'models', 'catalog', 'total-rec
  * @returns {string} Absolute path to the memory-vault directory
  */
 export function resolveVaultFromQuery(req) {
-  const brainId = req.query?.brain || req.body?.brainId;
+  const brainId = req.query?.brain || req.body?.brainId || req.headers?.['x-total-recall-brain'];
 
   // No brain specified or explicitly global → default vault
   if (!brainId || brainId === 'global') {