total-recall-brain 3.26.0 → 3.28.0

package/src/core/runtime.mjs

@@ -2,7 +2,7 @@ import fs from 'fs';
 import path from 'path';
 import yaml from 'yaml';
 import os from 'os';
-import { spawnSync } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
 import { logger } from './logger.mjs';
 import { agentDir, brainDir, googleApiKey, tavilyApiKey, braveApiKey, exaApiKey, serperApiKey, githubToken, embedModel } from './config.mjs';
 import { checkBudgetSafety } from './usage-tracker.mjs';
@@ -57,10 +57,10 @@ export function findBinaryInPath(binaryName) {
 //            fails with HTTP 400 at exit code 0.
 const DEFAULT_AGENTS = [
   { name: 'agy',         binary: 'agy',         flags: '--output-format json -p', priority: 1, enabled: true, exec: 'flag' },
+  { name: 'antigravity', binary: 'agy',         flags: '--output-format json -p', priority: 1, enabled: true, exec: 'flag' },
   { name: 'claude',      binary: 'claude',      flags: '--output-format json --permission-mode bypassPermissions --setting-sources local --tools "" -p', priority: 2, enabled: true, exec: 'flag' },
   { name: 'codex',       binary: 'codex',       flags: '-m gpt-5.5 --sandbox workspace-write --json --skip-git-repo-check', priority: 3, enabled: true, exec: 'subcommand' },
-  { name: 'antigravity', binary: 'antigravity', flags: '--sandbox=false --yolo -o json', priority: 8, enabled: false, exec: 'flag' },
-  { name: 'gemini',      binary: 'gemini',      flags: '--sandbox=false --yolo -o json', priority: 9, enabled: false, exec: 'flag' },
+  { name: 'gemini',      binary: 'agy',         flags: '--output-format json -p', priority: 9, enabled: false, exec: 'flag' },
   { name: 'grok',        binary: 'grok',        flags: '--output-format plain --always-approve --permission-mode bypassPermissions', priority: 10, enabled: false, exec: 'flag' },
 ];
 
@@ -251,7 +251,10 @@ function resolveAgent(config) {
 
   for (const agent of agents.sort((a, b) => a.priority - b.priority)) {
     if (!agent.enabled) continue;
-    const binaryPath = findBinaryInPath(agent.binary);
+    let binaryPath = findBinaryInPath(agent.binary);
+    if (!binaryPath && (agent.name === 'antigravity' || agent.name === 'gemini' || agent.binary === 'antigravity')) {
+      binaryPath = findBinaryInPath('agy');
+    }
     if (binaryPath) {
       return {
         ...agent,
@@ -364,11 +367,24 @@ export async function callLocalRuntime(prompt, system, config) {
           .map(tok => tok.replace(/^(['"])(.*)\1$/, '$2')),
       );
     }
+    // If -p or --print is in args, remove it so options like --model can precede it,
+    // and we will push -p immediately before fullPrompt.
+    const hadPrintFlag = args.includes('-p') || args.includes('--print');
+    if (hadPrintFlag) {
+      const pIdx = args.indexOf('-p');
+      if (pIdx !== -1) args.splice(pIdx, 1);
+      const printIdx = args.indexOf('--print');
+      if (printIdx !== -1) args.splice(printIdx, 1);
+    }
     if (agent.model) {
-      args.push('-m', agent.model);
+      if (agent.binary === 'agy' || agent.name === 'agy' || (agent.binaryPath && agent.binaryPath.endsWith('/agy'))) {
+        args.push('--model', agent.model);
+      } else {
+        args.push('-m', agent.model);
+      }
     }
-    // `exec: flag` agents need an explicit `-p` only if their flags omit it.
-    if (agent.exec !== 'subcommand' && !args.includes('-p') && !args.includes('--print')) {
+    // `exec: flag` agents need an explicit `-p` right before fullPrompt
+    if (agent.exec !== 'subcommand' || hadPrintFlag) {
       args.push('-p');
     }
     args.push(fullPrompt);
@@ -415,14 +431,50 @@ export async function callLocalRuntime(prompt, system, config) {
     };
 
     logger.info('api', 'SPAWN_ENV GOOGLE_API_KEY length: ' + (spawnEnv.GOOGLE_API_KEY ? spawnEnv.GOOGLE_API_KEY.length : 0));
-    const result = spawnSync(agent.binaryPath, args, {
-      encoding: 'utf8',
-      timeout,
-      maxBuffer: 10 * 1024 * 1024,
-      env: spawnEnv,
-      cwd: process.cwd(),
+    const runAsync = () => new Promise((resolve) => {
+      let child;
+      try {
+        child = spawn(agent.binaryPath, args, {
+          env: spawnEnv,
+          cwd: process.cwd(),
+        });
+      } catch (err) {
+        return resolve({ status: 1, stdout: '', stderr: err.message });
+      }
+
+      let stdout = '';
+      let stderr = '';
+      let timer = null;
+      if (timeout) {
+        timer = setTimeout(() => {
+          try { child.kill('SIGTERM'); } catch {}
+        }, timeout);
+      }
+
+      child.on('error', (err) => {
+        if (timer) clearTimeout(timer);
+        resolve({ status: 1, stdout, stderr: err.message });
+      });
+
+      if (child.stdout) {
+        child.stdout.on('data', (d) => {
+          if (stdout.length < 10 * 1024 * 1024) stdout += d.toString();
+        });
+      }
+      if (child.stderr) {
+        child.stderr.on('data', (d) => {
+          if (stderr.length < 10 * 1024 * 1024) stderr += d.toString();
+        });
+      }
+
+      child.on('close', (code) => {
+        if (timer) clearTimeout(timer);
+        resolve({ status: code ?? 0, stdout, stderr });
+      });
     });
 
+    const result = await runAsync();
+
     const softFailure = detectAgentFailure(result.stdout || '');
 
     if (result.status === 0 && !softFailure) {

package/src/core/surface.mjs

@@ -10,6 +10,7 @@ import {
   buildMemoryLayerIndex,
   inferMemoryLayer,
 } from './memory-layers.mjs';
+import { assemblePluginContexts } from './plugin-context.mjs';
 
 /**
  * Extract [[slug]] wikilink references and relative Markdown link targets from body text.
@@ -306,7 +307,7 @@ async function compactNode(node, derivedDir, force = false) {
   return compacted;
 }
 
-export async function buildRulesBlock(skillsDir, nodes = [], { consumer = 'ide', derivedDir, force = false } = {}) {
+export async function buildRulesBlock(skillsDir, nodes = [], { consumer = 'ide', derivedDir, force = false, vaultDir, projectRoot } = {}) {
   // 1. Filter expired rules. Compilation must remain a pure projection step;
   // archival is handled by explicit memory operations.
   const now = new Date();
@@ -481,6 +482,21 @@ export async function buildRulesBlock(skillsDir, nodes = [], { consumer = 'ide',
     }
   }
 
+  // 5. Inject Evolving Plugin Context
+  try {
+    const pluginContext = await assemblePluginContexts({
+      projectRoot: projectRoot || (skillsDir ? path.dirname(path.dirname(skillsDir)) : process.cwd()),
+      vaultDir,
+      nodes,
+      derivedDir
+    });
+    if (pluginContext) {
+      combined += pluginContext;
+    }
+  } catch (err) {
+    console.error('Error injecting plugin context:', err);
+  }
+
   return combined.trim();
 }
 
@@ -546,15 +562,21 @@ async function writeShim(shimPath, skillsDir, nodes = [], { vaultDir, derivedDir
  * Map of client names → shim file paths they require.
  */
 const CLIENT_SHIMS = {
-  cursor:        ['.cursorrules'],
-  claude:        ['CLAUDE.md'],
-  'claude-code': ['CLAUDE.md'],
-  cline:         ['.clinerules/total-recall.md'],
-  antigravity:   ['AGENTS.md', '.agents/rules/AGENTS.md'],
-  gemini:        ['GEMINI.md', '.agents/rules/GEMINI.md'],
-  codex:         ['AGENTS.md'],
-  vscode:        ['.github/copilot-instructions.md', '.vscode/copilot-instructions.md'],
-  githubCopilot: ['.github/copilot-instructions.md']
+  cursor:             ['.cursorrules'],
+  claude:             ['CLAUDE.md'],
+  'claude-code':      ['CLAUDE.md'],
+  cline:              ['.clinerules/total-recall.md'],
+  antigravity:        ['AGENTS.md', '.agents/rules/AGENTS.md'],
+  gemini:             ['GEMINI.md', '.agents/rules/GEMINI.md'],
+  codex:              ['AGENTS.md'],
+  vscode:             ['.github/copilot-instructions.md', '.vscode/copilot-instructions.md'],
+  githubCopilot:      ['.github/copilot-instructions.md'],
+  pi:                 ['AGENTS.md'],
+  hermes:             ['.hermes/memories/MEMORY.md'],
+  'hermes-agent':     ['.hermes/memories/MEMORY.md'],
+  dsh:                ['AGENTS.md'],
+  'deepseek-harness': ['AGENTS.md'],
+  openclaw:           ['MEMORY.md', 'AGENTS.md']
 };
 
 /**

package/src/server/api.mjs

@@ -384,11 +384,17 @@ apiRouter.post('/v1/chat/completions', requireScope('chat:write'), async (req, r
       if (targetAgentName.includes(':')) {
         const parts = targetAgentName.split(':');
         targetAgentName = parts[0];
-        subModel = parts[1];
+        subModel = parts.slice(1).join(':');
       } else if (targetAgentName.includes('/')) {
         const parts = targetAgentName.split('/');
         targetAgentName = parts[0];
-        subModel = parts[1];
+        subModel = parts.slice(1).join('/');
+      }
+
+      // If user selected 'antigravity' or 'gemini', check if 'agy' is available
+      if (targetAgentName === 'antigravity' || targetAgentName === 'gemini') {
+        const hasAgy = activeConfig.agents.some(a => a.name === 'agy');
+        if (hasAgy) targetAgentName = 'agy';
       }
 
       const idx = activeConfig.agents.findIndex(a => a.name === targetAgentName);
@@ -396,6 +402,7 @@ apiRouter.post('/v1/chat/completions', requireScope('chat:write'), async (req, r
         // Deep copy the agents list so we don't mutate the cached config
         activeConfig.agents = activeConfig.agents.map(a => ({ ...a }));
         activeConfig.agents[idx].priority = 0;
+        activeConfig.agents[idx].enabled = true;
         if (subModel) {
           activeConfig.agents[idx].model = subModel;
         }
@@ -432,6 +439,14 @@ CODE / MEMORY:
 - 'execute_code': Run Node.js to call APIs, process data, or perform calculations.
 - 'update_design': Write markdown to DESIGN.md when asked to create a UI or document.
 
+MESH NETWORK TOOLS (WireGuard / Headscale mesh management):
+- 'mesh_list_nodes': List all nodes on the mesh network (hostname, IP, online status, role, OS, SSH login account).
+- 'mesh_status': Check mesh control plane (Headscale) availability, network status, and self node info.
+- 'mesh_exec': Execute a shell command remotely on any peer node via SSH (e.g. 'uptime', 'docker ps', 'git status').
+- 'mesh_set_access': Record or update SSH login account (user, port, key, host override) on a node entity.
+- 'mesh_ping': Test reachability and measure round-trip latency to a mesh node.
+- 'mesh_mint_preauthkey': Mint a pre-auth enrollment key to connect a new machine to the mesh.
+
 MANDATORY TOOL USE AND CITATION RULES:
 1. FORCE SEARCH: If the user asks you to "search", "lookup", "find", or asks about current/recent events or anything you do not explicitly have in your memory vault, you MUST output a tool call to 'search_web' immediately. Do not write a conversational introduction first.
 2. CITATION MANDATE: When answering using results from 'search_web' or 'browser_navigate', you MUST explicitly cite your sources by embedding clickable markdown links (e.g., [Source Title](URL)) directly in your response. Never summarize web facts without providing their corresponding URLs.
@@ -447,6 +462,7 @@ Example:
 }
 </tool_call>
 Do not add any other conversational text when outputting the fallback tool call. Output it immediately as your entire response.
+5. MESH OPERATIONS: When asked about nodes on the mesh, running commands across the network, checking mesh connectivity, or configuring node login access, you MUST use the appropriate 'mesh_*' tool.
 
 You have a REAL browser AND full desktop control. Use them. Navigate, click, type, scrape — do not just describe what you would do. For web tasks prefer browser tools. For native apps or desktop workflows use computer_screenshot first to orient yourself.`;
 

package/src/server/index.mjs

@@ -236,8 +236,14 @@ app.get('/health', requireAuthOrLocal, async (req, res) => {
   // CLI agent availability
   const { findBinaryInPath } = await import('../core/runtime.mjs');
   const cliAgents = [];
-  for (const bin of ['antigravity', 'grok', 'gemini', 'claude', 'codex']) {
-    if (findBinaryInPath(bin)) cliAgents.push(bin);
+  for (const bin of ['agy', 'antigravity', 'claude', 'codex', 'grok', 'gemini']) {
+    if (findBinaryInPath(bin)) {
+      if (bin === 'agy') {
+        if (!cliAgents.includes('antigravity')) cliAgents.push('antigravity');
+      } else if (!cliAgents.includes(bin)) {
+        cliAgents.push(bin);
+      }
+    }
   }
 
   const agentDir = configAgentDir;

package/src/server/rest.mjs

@@ -123,6 +123,8 @@ import ttsRouter          from './routes/tts.mjs';
 import updateRouter       from './routes/update.mjs';
 import { rulesRouter }    from './routes/rules.mjs';
 import notificationsRouter from './routes/notifications.mjs';
+import meshPresenceRouter from './routes/mesh-presence.mjs';
+import pluginsRouter      from './routes/plugins.mjs';
 // ollamaUrl removed — CLI agents replace Ollama
 import {
   AGENT_DIR,
@@ -239,6 +241,8 @@ router.use(updateRouter);
 router.use(ssssRouter);
 router.use(rulesRouter);
 router.use(notificationsRouter);
+router.use(meshPresenceRouter);
+router.use(pluginsRouter);
 
 export { router as restRouter };
 export default router;

package/src/server/routes/integrations.mjs

@@ -88,6 +88,9 @@ router.get('/api/integrations/active', requireAuth, (req, res) => {
         'gemini':      [path.join(HOME, '.gemini')],
         'pi':          [path.join(HOME, '.pi', 'agent')],
         'hermes':      [path.join(HOME, '.hermes')],
+        'hermes-agent':[path.join(HOME, '.hermes')],
+        'dsh':         [path.join(HOME, '.dsh')],
+        'deepseek-harness': [path.join(HOME, '.dsh')],
         'openclaw':    [path.join(HOME, '.openclaw')],
       };
 
@@ -116,7 +119,8 @@ router.post('/api/integrations/connect', requireAuth, (req, res) => {
     if (!client) return badRequest(res, 'client is required');
 
     const validClients = [
-      'vscode', 'pi', 'hermes', 'openclaw', 'cursor', 'cline', 'claude-code',
+      'vscode', 'pi', 'hermes', 'hermes-agent', 'dsh', 'deepseek-harness',
+      'openclaw', 'cursor', 'cline', 'claude-code',
       'codex', 'gemini', 'aider', 'http-api', 'obsidian',
       'generic', 'antigravity'
     ];

package/src/server/routes/mesh-presence.mjs

@@ -0,0 +1,143 @@
+import { Router } from 'express';
+import { requireAuth, requireScope, requireAuthOrLocal } from '../auth.mjs';
+import { getLocalPresence, resolveActiveDevice } from '../../core/mesh-activity.mjs';
+import { getMeshPeers, execMeshCommand } from '../../core/mesh.mjs';
+import { throttledFetch } from '../../core/throttled-fetch.mjs';
+import { serverError, badRequest } from './_shared.mjs';
+
+const router = Router();
+
+function meshServerPort() {
+  const value = Number(process.env.TR_SERVER_PORT || process.env.PORT || 3000);
+  return Number.isInteger(value) && value > 0 && value <= 65535 ? value : 3000;
+}
+
+/**
+ * GET /api/mesh/presence
+ * Reports the presence state across the mesh, highlighting the user's active device.
+ */
+router.get('/api/mesh/presence', requireAuth, requireScope('config:read'), async (req, res) => {
+  try {
+    const local = getLocalPresence();
+    const includePeers = req.query?.peers !== 'false';
+    const peers = [];
+
+    if (includePeers) {
+      const meshPeers = getMeshPeers({ includeSelf: false }) || [];
+      const port = meshServerPort();
+
+      const peerPromises = meshPeers
+        .filter((p) => p && p.online && p.ip)
+        .map(async (p) => {
+          try {
+            const peerRes = await throttledFetch(
+              `http://${p.ip}:${port}/api/mesh/presence/local`,
+              {},
+              1500
+            );
+            if (peerRes && (peerRes.ok || peerRes.status === 200)) {
+              return await peerRes.json();
+            }
+          } catch {
+            // Peer unreachable or offline
+          }
+          return {
+            node_id: p.hostname,
+            mesh_ip: p.ip,
+            user_active: false,
+            idle_seconds: 999999,
+            active_surface: 'offline',
+            timestamp: new Date().toISOString()
+          };
+        });
+
+      const resolved = await Promise.all(peerPromises);
+      peers.push(...resolved.filter(Boolean));
+    }
+
+    const allRecords = [local, ...peers];
+    const activeDevice = resolveActiveDevice(allRecords);
+
+    res.json({
+      success: true,
+      local,
+      peers,
+      active_device: activeDevice,
+      active_surface: local.active_surface,
+      timestamp: new Date().toISOString()
+    });
+  } catch (err) {
+    serverError(res, err);
+  }
+});
+
+/**
+ * GET /api/mesh/presence/local
+ * Lightweight unauthenticated/mesh-only endpoint for peer heartbeat polling.
+ */
+router.get('/api/mesh/presence/local', requireAuthOrLocal, (_req, res) => {
+  try {
+    const local = getLocalPresence();
+    res.json(local);
+  } catch (err) {
+    serverError(res, err);
+  }
+});
+
+/**
+ * POST /api/mesh/presence/resolve
+ * Evaluates arbitrary presence records to determine the user's currently active device.
+ * Body: { presence_records: [...] }
+ */
+router.post('/api/mesh/presence/resolve', requireAuth, requireScope('config:read'), (req, res) => {
+  try {
+    const records = Array.isArray(req.body?.presence_records) ? req.body.presence_records : [];
+    const active = resolveActiveDevice(records);
+    res.json({
+      success: true,
+      active_device: active,
+      timestamp: new Date().toISOString()
+    });
+  } catch (err) {
+    serverError(res, err);
+  }
+});
+
+/**
+ * POST /api/mesh/dispatch
+ * Follow the User dynamic dispatch: routes notifications or commands to the most active node.
+ * Body: { notification?: string, command?: string, target?: string, payload?: any }
+ */
+router.post('/api/mesh/dispatch', requireAuth, requireScope('config:write'), async (req, res) => {
+  try {
+    const local = getLocalPresence();
+    let targetNode = req.body?.target;
+
+    if (!targetNode) {
+      const active = resolveActiveDevice([local]);
+      targetNode = active.node_id;
+    }
+
+    const isLocal = targetNode === local.node_id || targetNode === 'local';
+    let executionResult = null;
+
+    if (!isLocal && req.body?.command) {
+      executionResult = await execMeshCommand(targetNode, req.body.command);
+    }
+
+    res.json({
+      success: true,
+      dispatched: true,
+      target_node: targetNode,
+      is_local: isLocal,
+      command_result: executionResult,
+      notification: req.body?.notification || null,
+      payload: req.body?.payload || null,
+      timestamp: new Date().toISOString()
+    });
+  } catch (err) {
+    serverError(res, err);
+  }
+});
+
+export default router;

package/src/server/routes/models.mjs

@@ -151,43 +151,48 @@ router.get('/v1/models', requireAuthOrLocal, async (req, res) => {
   }
 });
 
+let cachedAgyModels = null;
+let lastAgyModelsFetch = 0;
+
 /**
  * GET /api/gemini-models
  * Dynamically fetches available Gemini models.
  * Strategy: CLI discovery → Google API → static fallback list.
  */
-router.get('/api/gemini-models', requireAuth, async (req, res) => {
+router.get('/api/gemini-models', requireAuthOrLocal, async (req, res) => {
   try {
-    // 1. Try antigravity CLI
+    // 1. Try Google Antigravity (agy) CLI first (cached 5 minutes)
+    if (cachedAgyModels && Date.now() - lastAgyModelsFetch < 1000 * 60 * 5) {
+      return res.json({ models: cachedAgyModels, source: 'cli' });
+    }
+
     try {
       const { findBinaryInPath } = await import('../../core/runtime.mjs');
-      const antigravityPath = findBinaryInPath('antigravity');
-      if (antigravityPath) {
-        const result = spawnSync(antigravityPath, ['--help'], { encoding: 'utf8', timeout: 3000 });
+      const agyPath = findBinaryInPath('agy');
+      if (agyPath) {
+        const result = spawnSync(agyPath, ['models'], { encoding: 'utf8', timeout: 8000, input: '' });
         if (result.status === 0 && result.stdout) {
-          const output = result.stdout;
+          const lines = result.stdout.split('\n');
           const discovered = [];
-
-          const modelRegex = /gemini-\d+\.\d+(?:-\w+)?/g;
-          const matches = output.match(modelRegex) || [];
-          for (const m of matches) {
-            discovered.push(m);
+          for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('Fetching')) continue;
+            const parts = trimmed.split('\t');
+            if (parts.length >= 2) {
+              discovered.push({ id: parts[0].trim(), displayName: parts[1].trim() });
+            } else if (parts.length === 1 && parts[0].includes('gemini')) {
+              discovered.push({ id: parts[0].trim(), displayName: parts[0].trim() });
+            }
           }
-
-          const versionRegex = /\b(\d+\.\d+-\w+)\b/g;
-          const versionMatches = output.match(versionRegex) || [];
-          for (const vm of versionMatches) {
-            discovered.push(`gemini-${vm}`);
-          }
-
-          const uniqueModels = [...new Set(discovered)];
-          if (uniqueModels.length > 0) {
+          if (discovered.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, pricing: pricingMap[modelId] || pricingMap[`google/${modelId}`] };
-            });
+            const cliModels = discovered.map(m => ({
+              id: m.id,
+              displayName: m.displayName,
+              pricing: pricingMap[m.id] || pricingMap[`google/${m.id}`] || null,
+            }));
+            cachedAgyModels = cliModels;
+            lastAgyModelsFetch = Date.now();
             return res.json({ models: cliModels, source: 'cli' });
           }
         }
@@ -196,7 +201,7 @@ router.get('/api/gemini-models', requireAuth, async (req, res) => {
       // Fail silently and fall back
     }
 
-    // 2. Try Google API key
+    // 3. Try Google API key
     let apiKey = process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY;
     if (!apiKey) {
       try {
@@ -207,10 +212,17 @@ router.get('/api/gemini-models', requireAuth, async (req, res) => {
     }
 
     const fallbackModels = [
+      { id: 'gemini-3.8-flash-high', displayName: 'Gemini 3.8 Flash (High)', pricing: null },
+      { id: 'gemini-3.8-flash-medium', displayName: 'Gemini 3.8 Flash (Medium)', pricing: null },
+      { id: 'gemini-3.8-flash-low', displayName: 'Gemini 3.8 Flash (Low)', pricing: null },
+      { id: 'gemini-3.7-flash-high', displayName: 'Gemini 3.7 Flash (High)', pricing: null },
+      { id: 'gemini-3.7-flash-medium', displayName: 'Gemini 3.7 Flash (Medium)', pricing: null },
+      { id: 'gemini-3.6-flash-high', displayName: 'Gemini 3.6 Flash (High)', pricing: null },
+      { id: 'gemini-3.1-pro-high', displayName: 'Gemini 3.1 Pro (High)', pricing: null },
       { id: 'gemini-3.5-flash', displayName: 'Gemini 3.5 Flash', pricing: null },
       { id: 'gemini-3.5-pro', displayName: 'Gemini 3.5 Pro', pricing: null },
+      { id: 'gemini-2.5-flash', displayName: 'Gemini 2.5 Flash', pricing: null },
       { id: 'gemini-2.5-pro', displayName: 'Gemini 2.5 Pro', pricing: null },
-      { id: 'gemini-2.5-flash', displayName: 'Gemini 2.5 Flash', pricing: null }
     ];
 
     if (!apiKey) return res.json({ models: fallbackModels, source: 'missing_key' });
@@ -251,7 +263,7 @@ router.get('/api/gemini-models', requireAuth, async (req, res) => {
  * GET /api/claude-models
  * Dynamically fetches available Anthropic models using ANTHROPIC_API_KEY.
  */
-router.get('/api/claude-models', requireAuth, async (req, res) => {
+router.get('/api/claude-models', requireAuthOrLocal, async (req, res) => {
   try {
     let apiKey = process.env.ANTHROPIC_API_KEY;
     if (!apiKey) {
@@ -301,7 +313,7 @@ router.get('/api/claude-models', requireAuth, async (req, res) => {
  * GET /api/openai-models
  * Dynamically fetches available OpenAI models using OPENAI_API_KEY.
  */
-router.get('/api/openai-models', requireAuth, async (req, res) => {
+router.get('/api/openai-models', requireAuthOrLocal, async (req, res) => {
   try {
     let apiKey = process.env.OPENAI_API_KEY;
     if (!apiKey) {
@@ -352,7 +364,7 @@ router.get('/api/openai-models', requireAuth, async (req, res) => {
  * GET /api/openrouter-models
  * Dynamically fetches the list of available OpenRouter models.
  */
-router.get('/api/openrouter-models', requireAuth, async (req, res) => {
+router.get('/api/openrouter-models', requireAuthOrLocal, async (req, res) => {
   try {
     const response = await throttledFetch('https://openrouter.ai/api/v1/models');
     if (response.ok) {