search-mcp-rotator 1.1.0 → 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.
@@ -59,18 +39,12 @@ export class MultiProxy {
                 currentKey: '',
                 tools: [],
                 connected: false,
+                connectionPromise: null,
+                callLock: Promise.resolve(),
             });
         }
     }
     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);
@@ -78,33 +52,45 @@ export class MultiProxy {
             providers: [...this.providers.keys()],
         });
     }
-    // ── Lazy upstream connection per provider ────────────────────────────────
+    // ── Lazy upstream connection per provider (race-safe) ────────────────────
     async ensureConnected(state) {
         if (state.connected)
             return;
-        state.currentKey = state.keyPool.next();
-        const { url, headers } = state.authInjector.inject(state.currentKey, state.config.url);
-        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
-        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) + '...',
-        });
+        // Concurrent callers share the same connection attempt
+        if (state.connectionPromise)
+            return state.connectionPromise;
+        state.connectionPromise = (async () => {
+            try {
+                state.currentKey = state.keyPool.next();
+                const { url, headers } = state.authInjector.inject(state.currentKey, state.config.url);
+                state.transport = new StreamableHTTPClientTransport(new URL(url), { requestInit: { headers } });
+                await state.client.connect(state.transport);
+                state.connected = true;
+                // 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;
+                logger.info(`Connected to upstream for ${state.name}`, {
+                    toolCount: tools.length,
+                    currentKey: state.currentKey.slice(0, 8) + '...',
+                });
+            }
+            finally {
+                state.connectionPromise = null;
+            }
+        })();
+        return state.connectionPromise;
     }
     // ── Reconnect with a different key ───────────────────────────────────────
+    // NOTE: MCP SDK Client cannot be reused after close() — create a fresh instance.
     async reconnect(state, key) {
         try {
             await state.client.close();
         }
         catch { }
         state.connected = false;
+        state.client = new Client({ name: `${state.name}-client`, version: '1.0.0' }, { capabilities: {} });
         const { url, headers } = state.authInjector.inject(key, state.config.url);
         state.transport = new StreamableHTTPClientTransport(new URL(url), { requestInit: { headers } });
         await state.client.connect(state.transport);
@@ -127,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,
@@ -159,7 +150,17 @@ export class MultiProxy {
             const state = this.providers.get(parsed.provider);
             if (!state)
                 throw new Error(`Unknown provider: ${parsed.provider}`);
-            return this.handleToolCall(state, parsed.toolName, request);
+            // Serialize calls to the same provider (Client is not concurrent-safe)
+            const previousLock = state.callLock;
+            let releaseLock;
+            state.callLock = new Promise(r => { releaseLock = r; });
+            await previousLock;
+            try {
+                return await this.handleToolCall(state, parsed.toolName, request);
+            }
+            finally {
+                releaseLock();
+            }
         });
     }
     // ── Tool call with key rotation ──────────────────────────────────────────
@@ -180,18 +181,18 @@ export class MultiProxy {
         let lastError = null;
         for (let attempt = 0; attempt < maxAttempts; attempt++) {
             try {
+                // First attempt: use existing connection.
+                // Retry: rotate to next healthy key.
                 if (attempt > 0) {
                     const nextKey = state.keyPool.next(strategyOverride);
                     if (!nextKey || nextKey === state.currentKey)
                         break;
                     await this.reconnect(state, nextKey);
                 }
-                else {
-                    const key = state.keyPool.next(strategyOverride);
-                    if (key !== state.currentKey)
-                        await this.reconnect(state, key);
-                }
-                const result = await state.client.callTool(cleanRequest.params);
+                // Long timeout (5 min) — heavy ops like research, page fetch, agent jobs
+                // need more than the SDK's 60s default. The MCP client wrapping us can
+                // still apply its own shorter timeout if desired.
+                const result = await state.client.callTool(cleanRequest.params, undefined, { timeout: 300000 });
                 const mcpError = this.extractMcpError(state.name, result);
                 if (mcpError && state.detector.isExhausted(mcpError)) {
                     const cooldown = extractCooldown(mcpError, state.name, state.config.cooldownMs);

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();
             }
@@ -182,7 +152,7 @@ export class MCPProxy {
                         await this.connectUpstream(key);
                     }
                 }
-                const result = await this.upstreamClient.callTool(cleanRequest.params);
+                const result = await this.upstreamClient.callTool(cleanRequest.params, undefined, { timeout: 300000 });
                 // CHECK: Does the result look like an exhaustion error hidden inside HTTP 200?
                 const mcpError = this.extractMcpLevelError(result);
                 if (mcpError && this.detector.isExhausted(mcpError)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "search-mcp-rotator",
-  "version": "1.1.0",
+  "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": {