polydev-ai 1.9.0 → 1.9.2

package/mcp/server.js

@@ -1,5 +1,49 @@
 #!/usr/bin/env node
 
+// Ensure fetch is available (polyfill for environments where native fetch is missing)
+if (typeof globalThis.fetch === 'undefined') {
+  const https = require('https');
+  const http = require('http');
+  const { URL } = require('url');
+
+  globalThis.fetch = function fetchPolyfill(url, options = {}) {
+    return new Promise((resolve, reject) => {
+      const parsed = new URL(url);
+      const mod = parsed.protocol === 'https:' ? https : http;
+      const reqOptions = {
+        hostname: parsed.hostname,
+        port: parsed.port,
+        path: parsed.pathname + parsed.search,
+        method: options.method || 'GET',
+        headers: options.headers || {}
+      };
+
+      const req = mod.request(reqOptions, (res) => {
+        const chunks = [];
+        res.on('data', (chunk) => chunks.push(chunk));
+        res.on('end', () => {
+          const body = Buffer.concat(chunks).toString('utf8');
+          resolve({
+            ok: res.statusCode >= 200 && res.statusCode < 300,
+            status: res.statusCode,
+            statusText: res.statusMessage,
+            headers: { get: (name) => res.headers[name.toLowerCase()] },
+            json: () => Promise.resolve(JSON.parse(body)),
+            text: () => Promise.resolve(body)
+          });
+        });
+      });
+
+      req.on('error', reject);
+      req.setTimeout(30000, () => { req.destroy(); reject(new Error('Request timed out')); });
+      if (options.body) req.write(options.body);
+      req.end();
+    });
+  };
+
+  console.error('[Polydev MCP] fetch polyfill loaded (native fetch unavailable)');
+}
+
 // Register ts-node for TypeScript support
 try {
   require('ts-node/register');

package/mcp/stdio-wrapper.js

@@ -1,5 +1,49 @@
 #!/usr/bin/env node
 
+// Ensure fetch is available (polyfill for environments where native fetch is missing)
+if (typeof globalThis.fetch === 'undefined') {
+  const https = require('https');
+  const http = require('http');
+  const { URL } = require('url');
+
+  globalThis.fetch = function fetchPolyfill(url, options = {}) {
+    return new Promise((resolve, reject) => {
+      const parsed = new URL(url);
+      const mod = parsed.protocol === 'https:' ? https : http;
+      const reqOptions = {
+        hostname: parsed.hostname,
+        port: parsed.port,
+        path: parsed.pathname + parsed.search,
+        method: options.method || 'GET',
+        headers: options.headers || {}
+      };
+
+      const req = mod.request(reqOptions, (res) => {
+        const chunks = [];
+        res.on('data', (chunk) => chunks.push(chunk));
+        res.on('end', () => {
+          const body = Buffer.concat(chunks).toString('utf8');
+          resolve({
+            ok: res.statusCode >= 200 && res.statusCode < 300,
+            status: res.statusCode,
+            statusText: res.statusMessage,
+            headers: { get: (name) => res.headers[name.toLowerCase()] },
+            json: () => Promise.resolve(JSON.parse(body)),
+            text: () => Promise.resolve(body)
+          });
+        });
+      });
+
+      req.on('error', reject);
+      req.setTimeout(30000, () => { req.destroy(); reject(new Error('Request timed out')); });
+      if (options.body) req.write(options.body);
+      req.end();
+    });
+  };
+
+  console.error('[Polydev MCP] fetch polyfill loaded (native fetch unavailable)');
+}
+
 // Lightweight stdio wrapper with local CLI functionality and remote Polydev MCP server fallback
 const fs = require('fs');
 const path = require('path');
@@ -1406,93 +1450,129 @@ Error: ${error.message}`
         const result = await this.cliManager.sendCliPrompt(provider_id, prompt, mode, gracefulTimeout, model);
         localResults = [{ provider_id, ...result }];
       } else {
-        // No specific provider - use allProviders from dashboard in order
-        // For each provider: try CLI first if available, otherwise use API
-        console.error(`[Stdio Wrapper] Using allProviders from dashboard (max: ${maxPerspectives})`);
+        // No specific provider - SMART ROUTING: CLIs first (free), then API/credits
+        // Priority order: Available CLIs > User's API keys > Credits tier models
+        // If a configured API/credits model can be accessed through an available CLI, use CLI
+        console.error(`[Stdio Wrapper] Smart routing: CLIs first, then API/credits (max: ${maxPerspectives})`);
         
         // Get available CLIs for checking
         const { available: availableClis } = await this.getAllAvailableProviders();
         console.error(`[Stdio Wrapper] Available CLIs: ${availableClis.join(', ') || 'none'}`);
         
-        // Use allProviders from API (full list including API-only providers)
-        // Falls back to CLI-only providers if allProviders not available
+        // Use allProviders from API (user's configured providers from dashboard)
         const allProviders = this.allProviders || [];
         
-        if (allProviders.length === 0) {
-          // Fallback: use legacy CLI-only flow
-          console.error(`[Stdio Wrapper] No allProviders, using legacy CLI-only flow`);
-          // NOTE: Use length check because empty array [] is truthy in JS
-          const userOrder = (this.userProviderOrder && this.userProviderOrder.length > 0) 
-            ? this.userProviderOrder 
-            : ['claude_code', 'codex_cli', 'gemini_cli'];
-          const cliProviders = userOrder.slice(0, maxPerspectives).filter(p => availableClis.includes(p));
+        // CLI to provider name mapping
+        const cliToProviderMap = {
+          'claude_code': 'anthropic',
+          'gemini_cli': 'google',
+          'codex_cli': 'openai'
+        };
+        
+        // Provider name normalization (matches model-preferences API)
+        const normalizeProvider = (provider) => {
+          const map = {
+            'gemini': 'google',
+            'google-ai': 'google',
+            'x-ai': 'xai',
+            'open-ai': 'openai',
+            'anthropic-ai': 'anthropic'
+          };
+          const lower = provider.toLowerCase();
+          return map[lower] || lower;
+        };
+        
+        // CLI priority order: Claude Code first, then Gemini, then Codex
+        const cliPriorityOrder = ['claude_code', 'gemini_cli', 'codex_cli'];
+        
+        // Build merged provider list: CLIs first, then API-only
+        const finalProviders = [];
+        const usedProviderNames = new Set();
+        
+        // STEP 1: Add ALL available CLIs first (in priority order) - they're FREE
+        for (const cliId of cliPriorityOrder) {
+          if (finalProviders.length >= maxPerspectives) break;
+          if (!availableClis.includes(cliId)) continue;
+          
+          const providerName = cliToProviderMap[cliId];
+          usedProviderNames.add(providerName);
+          
+          // Check if user has a configured model for this provider (from API keys or credits)
+          // If so, use that model through CLI instead of burning API credits
+          const configuredProvider = allProviders.find(p => {
+            const normalized = normalizeProvider(p.provider);
+            return normalized === providerName;
+          });
+          
+          finalProviders.push({
+            provider: providerName,
+            model: configuredProvider?.model || null,
+            cliId: cliId,
+            source: 'cli',
+            tier: configuredProvider?.tier || null
+          });
+          
+          console.error(`[Stdio Wrapper] [CLI-FIRST] Added CLI: ${cliId} (${providerName})${configuredProvider ? ` with configured model: ${configuredProvider.model}` : ' with CLI default'}`);
+        }
+        
+        // STEP 2: Fill remaining slots with API/credits providers (skip those already covered by CLI)
+        for (const p of allProviders) {
+          if (finalProviders.length >= maxPerspectives) break;
+          
+          const normalizedProvider = normalizeProvider(p.provider);
+          if (usedProviderNames.has(normalizedProvider)) {
+            console.error(`[Stdio Wrapper] [CLI-FIRST] Skipping ${normalizedProvider} (already covered by CLI)`);
+            continue;
+          }
           
-          const cliPromises = cliProviders.map(async (providerId) => {
+          usedProviderNames.add(normalizedProvider);
+          finalProviders.push({
+            ...p,
+            provider: normalizedProvider,
+            source: 'api'
+          });
+          
+          console.error(`[Stdio Wrapper] [CLI-FIRST] Added API/credits: ${normalizedProvider} (${p.model})${p.tier ? ` [${p.tier}]` : ''}`);
+        }
+        
+        console.error(`[Stdio Wrapper] Final provider list (${finalProviders.length}/${maxPerspectives}): ${finalProviders.map(p => `${p.provider}[${p.source}]`).join(', ')}`);
+        
+        // Separate into CLI entries (local execution) vs API entries (remote execution)
+        const cliProviderEntries = finalProviders.filter(p => p.source === 'cli');
+        const apiOnlyProviders = finalProviders.filter(p => p.source === 'api');
+        
+        console.error(`[Stdio Wrapper] Provider breakdown: CLI=${cliProviderEntries.map(p => p.cliId).join(', ') || 'none'}, API-only=${apiOnlyProviders.map(p => p.provider).join(', ') || 'none'}`);
+        
+        // Run all CLI prompts concurrently
+        if (cliProviderEntries.length > 0) {
+          const cliPromises = cliProviderEntries.map(async (providerEntry) => {
             try {
-              const model = modelPreferences[providerId] || null;
-              const result = await this.cliManager.sendCliPrompt(providerId, prompt, mode, gracefulTimeout, model);
+              const model = providerEntry.model || modelPreferences[providerEntry.cliId] || null;
+              if (model) {
+                console.error(`[Stdio Wrapper] Using model for ${providerEntry.cliId}: ${model}`);
+              }
+              const result = await this.cliManager.sendCliPrompt(providerEntry.cliId, prompt, mode, gracefulTimeout, model);
               return { 
-                provider_id: providerId, 
-                original_provider: providerId,
+                provider_id: providerEntry.cliId, 
+                original_provider: providerEntry.provider,
                 ...result 
               };
             } catch (error) {
-              return { provider_id: providerId, success: false, error: error.message };
+              console.error(`[Stdio Wrapper] CLI ${providerEntry.cliId} failed:`, error.message);
+              return {
+                provider_id: providerEntry.cliId,
+                original_provider: providerEntry.provider,
+                success: false,
+                error: error.message,
+                latency_ms: gracefulTimeout
+              };
             }
           });
           localResults = await Promise.all(cliPromises);
-        } else {
-          // NEW: Use allProviders list (includes CLI + API-only providers)
-          const providersToUse = allProviders.slice(0, maxPerspectives);
-          console.error(`[Stdio Wrapper] Using ${providersToUse.length} providers from dashboard`);
-          
-          // Separate into CLI providers vs API-only providers
-          const cliProviderEntries = [];
-          const apiOnlyProviders = [];
-          
-          for (const p of providersToUse) {
-            if (p.cliId && availableClis.includes(p.cliId)) {
-              // Has CLI and CLI is available
-              cliProviderEntries.push(p);
-            } else {
-              // No CLI or CLI unavailable - needs API
-              apiOnlyProviders.push(p);
-            }
-          }
-          
-          console.error(`[Stdio Wrapper] Provider breakdown: CLI=${cliProviderEntries.map(p => p.cliId).join(', ') || 'none'}, API-only=${apiOnlyProviders.map(p => p.provider).join(', ') || 'none'}`);
-          
-          // Run all CLI prompts concurrently
-          if (cliProviderEntries.length > 0) {
-            const cliPromises = cliProviderEntries.map(async (providerEntry) => {
-              try {
-                const model = providerEntry.model || modelPreferences[providerEntry.cliId] || null;
-                if (model) {
-                  console.error(`[Stdio Wrapper] Using model for ${providerEntry.cliId}: ${model}`);
-                }
-                const result = await this.cliManager.sendCliPrompt(providerEntry.cliId, prompt, mode, gracefulTimeout, model);
-                return { 
-                  provider_id: providerEntry.cliId, 
-                  original_provider: providerEntry.provider,
-                  ...result 
-                };
-              } catch (error) {
-                console.error(`[Stdio Wrapper] CLI ${providerEntry.cliId} failed:`, error.message);
-                return {
-                  provider_id: providerEntry.cliId,
-                  original_provider: providerEntry.provider,
-                  success: false,
-                  error: error.message,
-                  latency_ms: gracefulTimeout
-                };
-              }
-            });
-            localResults = await Promise.all(cliPromises);
-          }
-          
-          // Store API-only providers info for remote API call
-          this._apiOnlyProviders = apiOnlyProviders;
         }
+        
+        // Store API-only providers info for remote API call
+        this._apiOnlyProviders = apiOnlyProviders;
       }
 
       // Calculate how many successful local perspectives we got

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polydev-ai",
-  "version": "1.9.0",
+  "version": "1.9.2",
   "engines": {
     "node": ">=20.x <=22.x"
   },