search-mcp-rotator 1.1.1 → 1.1.2

package/dist/index.js

@@ -36,21 +36,14 @@ async function main() {
         if (args.setup) {
             const { runSetup } = await import('./setup.js');
             await runSetup(args.config);
-            // Auto-warmup cache after setup so first MCP start is instant
-            try {
-                const config = await loadConfig(configPath);
-                process.stdout.write('\nWarming tools cache for faster MCP startup...\n');
-                const { warmupCache } = await import('./proxy.js');
-                await warmupCache(config.providers);
-                process.stdout.write('Cache ready.\n');
-            }
-            catch { }
             return;
         }
-        // ── Warmup ─────────────────────────────────────────────────────────────
+        // ── Warmup ─ probe all providers in parallel & report tool counts ──────
+        // No disk cache is written; this exists purely to verify connectivity and
+        // surface schema info to the user during onboarding/troubleshooting.
         if (args.warmup) {
             const config = await loadConfig(configPath);
-            process.stdout.write('Warming tools cache...\n');
+            process.stdout.write('Probing all configured providers...\n');
             const { warmupCache } = await import('./proxy.js');
             await warmupCache(config.providers);
             process.stdout.write('Done.\n');

package/dist/multi-proxy.js

@@ -3,30 +3,10 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
 import { KeyPool } from './key-pool.js';
 import { ExhaustionDetector, extractCooldown } from './detector.js';
 import { AuthInjector } from './auth-injector.js';
 import { logger } from './logger.js';
-const CACHE_DIR = path.join(os.homedir(), '.config', 'search-mcp-rotator');
-const CACHE_FILE = path.join(CACHE_DIR, 'tools-cache.json');
-function loadToolsCache() {
-    try {
-        if (fs.existsSync(CACHE_FILE))
-            return JSON.parse(fs.readFileSync(CACHE_FILE, 'utf-8'));
-    }
-    catch { }
-    return {};
-}
-function saveToolsCache(cache) {
-    try {
-        fs.mkdirSync(CACHE_DIR, { recursive: true });
-        fs.writeFileSync(CACHE_FILE, JSON.stringify(cache, null, 2));
-    }
-    catch { }
-}
 // ── Tool name helpers ─────────────────────────────────────────────────────────
 // Prefix: "{provider}__{toolname}" — double underscore as separator
 // All provider IDs are single words without underscores, making parsing unambiguous.
@@ -65,14 +45,6 @@ export class MultiProxy {
         }
     }
     async start() {
-        // Load cached tools for all providers — instant, no network
-        const cache = loadToolsCache();
-        for (const [name, state] of this.providers) {
-            if (cache[name]?.length) {
-                state.tools = cache[name];
-                logger.info(`Loaded ${state.tools.length} cached tools for ${name}`);
-            }
-        }
         this.registerHandlers();
         const transport = new StdioServerTransport();
         await this.server.connect(transport);
@@ -94,12 +66,11 @@ export class MultiProxy {
                 state.transport = new StreamableHTTPClientTransport(new URL(url), { requestInit: { headers } });
                 await state.client.connect(state.transport);
                 state.connected = true;
-                // Refresh tools from upstream and update cache
+                // Always fetch fresh tools from upstream — no disk cache. Providers can
+                // change/add/remove tools at any time; a stale cache would expose
+                // wrong schemas and missing tools to the LLM client.
                 const { tools } = await state.client.listTools();
                 state.tools = tools;
-                const cache = loadToolsCache();
-                cache[state.name] = tools;
-                saveToolsCache(cache);
                 logger.info(`Connected to upstream for ${state.name}`, {
                     toolCount: tools.length,
                     currentKey: state.currentKey.slice(0, 8) + '...',
@@ -142,19 +113,24 @@ export class MultiProxy {
     }
     // ── Register MCP handlers ────────────────────────────────────────────────
     registerHandlers() {
-        // tools/list — serve all providers' tools from cache instantly
+        // tools/list — fetch fresh from all providers in parallel.
+        // Tools are kept in memory for the lifetime of this process (per-call
+        // refresh would be wasteful), but NEVER persisted to disk so we always
+        // pick up upstream tool changes on next process start.
         this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+            // Connect all providers that haven't been connected yet — in parallel.
+            await Promise.allSettled([...this.providers.entries()]
+                .filter(([, state]) => state.tools.length === 0)
+                .map(async ([name, state]) => {
+                try {
+                    await this.ensureConnected(state);
+                }
+                catch (e) {
+                    logger.warn(`Could not fetch tools for ${name}: ${e.message}`);
+                }
+            }));
             const allTools = [];
             for (const [name, state] of this.providers) {
-                // If no cache yet, connect upstream now (first-ever run)
-                if (state.tools.length === 0) {
-                    try {
-                        await this.ensureConnected(state);
-                    }
-                    catch (e) {
-                        logger.warn(`Could not fetch tools for ${name}: ${e.message}`);
-                    }
-                }
                 for (const tool of state.tools) {
                     allTools.push({
                         ...tool,

package/dist/proxy.js

@@ -3,33 +3,15 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
 import { KeyPool } from './key-pool.js';
 import { extractCooldown } from './detector.js';
 import { AuthInjector } from './auth-injector.js';
 import { logger } from './logger.js';
-const CACHE_DIR = path.join(os.homedir(), '.config', 'search-mcp-rotator');
-const CACHE_FILE = path.join(CACHE_DIR, 'tools-cache.json');
-function loadToolsCache() {
-    try {
-        if (fs.existsSync(CACHE_FILE)) {
-            return JSON.parse(fs.readFileSync(CACHE_FILE, 'utf-8'));
-        }
-    }
-    catch { }
-    return {};
-}
-function saveToolsCache(cache) {
-    try {
-        fs.mkdirSync(CACHE_DIR, { recursive: true });
-        fs.writeFileSync(CACHE_FILE, JSON.stringify(cache, null, 2));
-    }
-    catch { }
-}
+// Probe upstream providers in parallel and report tool counts.
+// No disk caching — providers may change tools at any time, so we always
+// fetch fresh on each process start. This is a no-op for runtime behavior,
+// only used by the `--warmup` CLI flag for diagnostic reporting.
 export async function warmupCache(providers) {
-    const cache = loadToolsCache();
     const results = await Promise.allSettled(Object.entries(providers)
         .filter(([, cfg]) => cfg.enabled)
         .map(async ([name, cfg]) => {
@@ -41,14 +23,12 @@ export async function warmupCache(providers) {
         const client = new Client({ name: `${name}-warmup`, version: '1.0.0' }, { capabilities: {} });
         await client.connect(transport);
         const { tools } = await client.listTools();
-        cache[name] = tools;
         await client.close();
         process.stdout.write(`  ✓ ${name} — ${tools.length} tools\n`);
     }));
-    saveToolsCache(cache);
     const failed = results.filter(r => r.status === 'rejected');
     if (failed.length) {
-        failed.forEach((r, i) => process.stdout.write(`  ✗ failed: ${r.reason}\n`));
+        failed.forEach(r => process.stdout.write(`  ✗ failed: ${r.reason}\n`));
     }
 }
 export class MCPProxy {
@@ -72,13 +52,7 @@ export class MCPProxy {
         this.upstreamClient = new Client({ name: `${providerName}-rotator-client`, version: '1.0.0' }, { capabilities: {} });
     }
     async start() {
-        // Load cached tools so tools/list responds instantly without upstream call
-        const cache = loadToolsCache();
-        if (cache[this.providerName]?.length) {
-            this.tools = cache[this.providerName];
-            logger.info(`Loaded ${this.tools.length} cached tools for ${this.providerName}`);
-        }
-        // Register handlers — upstream connects lazily on first actual tool call
+        // Register handlers — upstream connects lazily on first tools/list or tools/call
         this.registerHandlers();
         const transport = new StdioServerTransport();
         await this.server.connect(transport);
@@ -107,21 +81,17 @@ export class MCPProxy {
             return;
         this.currentKey = this.keyPool.next();
         await this.connectUpstream(this.currentKey);
-        // Refresh tools from upstream and update cache
-        const fresh = await this.discoverTools();
-        this.tools = fresh;
-        const cache = loadToolsCache();
-        cache[this.providerName] = fresh;
-        saveToolsCache(cache);
+        // Always fetch fresh tools from upstream — no disk cache. Providers can
+        // change/add/remove tools at any time.
+        this.tools = await this.discoverTools();
         logger.info(`Connected to upstream for ${this.providerName}`, {
             toolCount: this.tools.length,
             currentKey: this.maskKey(this.currentKey)
         });
     }
     registerHandlers() {
-        // tools/list — serve from cache instantly, connect upstream lazily on tool call
+        // tools/list — fetch fresh from upstream. In-memory only, not persisted.
         this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            // If no tools yet (first ever run), do a full upstream connect now
             if (this.tools.length === 0) {
                 await this.ensureConnected();
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "search-mcp-rotator",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "Transparent API key rotation proxy for MCP search providers — Exa, Firecrawl, Tavily, Linkup, Bright Data, Olostep, Dappier, Parallel",
   "type": "module",
   "bin": {