polydev-ai 1.10.1 → 1.10.2

package/mcp/manifest.json

@@ -1,6 +1,6 @@
 {
   "name": "polydev-perspectives",
-  "version": "1.10.0",
+  "version": "1.10.1",
   "description": "Multi-model AI perspectives - query GPT 5.2, Claude Opus 4.5, Gemini 3, and Grok 4.1 simultaneously. Get diverse perspectives when stuck or need enhanced reasoning. Achieved 74.6% on SWE-bench Verified.",
   "author": "Polydev AI",
   "license": "MIT",

package/mcp/server.js

@@ -1803,7 +1803,7 @@ class MCPServer {
       );
     }
 
-    const serverUrl = 'https://www.polydev.ai/api/x-search';
+    const serverUrl = 'https://polydev.ai/api/x-search';
 
     try {
       const response = await fetch(serverUrl, {
@@ -1863,7 +1863,7 @@ class MCPServer {
       );
     }
 
-    const serverUrl = 'https://www.polydev.ai/api/generate-image';
+    const serverUrl = 'https://polydev.ai/api/generate-image';
 
     try {
       const response = await fetch(serverUrl, {

package/mcp/stdio-wrapper.js

@@ -507,6 +507,10 @@ Token will be saved automatically after login.`
           // Handle CLI tools locally (support both prefixed and unprefixed names)
           if (this.isCliTool(toolName)) {
             return await this.handleLocalCliTool(request);
+          } else if (toolName === 'search_x' || toolName === 'polydev.search_x') {
+            return await this.handleSearchX(params, id);
+          } else if (toolName === 'generate_image' || toolName === 'polydev.generate_image') {
+            return await this.handleGenerateImage(params, id);
           } else {
             // Forward non-CLI tools to remote server
             const result = await this.forwardToRemoteServer(request);
@@ -1730,6 +1734,156 @@ To re-login: /polydev:login`
     }
   }
 
+  /**
+   * Handle X search tool locally — calls polydev.ai API
+   */
+  async handleSearchX(params, id) {
+    const args = params.arguments || {};
+    console.error('[Stdio Wrapper] Handling search_x locally');
+
+    if (!args.query || typeof args.query !== 'string') {
+      return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: 'Error: query is required and must be a string' }], isError: true } };
+    }
+
+    const userToken = args.user_token || this.userToken;
+    if (!userToken) {
+      return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: 'Authentication required for X search.\nUse the "login" tool first, or pass user_token parameter.' }], isError: true } };
+    }
+
+    try {
+      const response = await fetch('https://polydev.ai/api/x-search', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${userToken}`,
+          'User-Agent': 'polydev-stdio-wrapper/1.0.0'
+        },
+        body: JSON.stringify({
+          query: args.query,
+          user_token: userToken,
+          model: args.model || 'grok-4-1-fast-reasoning'
+        })
+      });
+
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        if (response.status === 429) {
+          return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: 'Free X search limit reached (50 searches).\n\nTo continue:\n1. Get an xAI API key at https://console.x.ai\n2. Add it at https://polydev.ai/dashboard/models (select "X-AI" provider)\n\nWith your own key, you get unlimited X searches.' }], isError: true } };
+        }
+        throw new Error(errorData.error || `X search failed: HTTP ${response.status}`);
+      }
+
+      const result = await response.json();
+
+      // Format response
+      let formatted = '# X Search Results\n\n';
+      if (result.answer) {
+        formatted += `## Summary\n${result.answer}\n\n`;
+      }
+      if (result.search_results && result.search_results.length > 0) {
+        formatted += '## Posts Found\n\n';
+        result.search_results.forEach((post, i) => {
+          formatted += `### ${i + 1}. ${post.author || 'Unknown'}\n`;
+          if (post.snippet) formatted += `${post.snippet}\n`;
+          if (post.url) formatted += `[View post](${post.url})\n`;
+          if (post.date) formatted += `*${post.date}*\n`;
+          formatted += '\n';
+        });
+      }
+      if (result.using_free_tier) {
+        formatted += `---\n*Free tier: ${result.free_searches_remaining} searches remaining of 50*\n`;
+      }
+      if (result.model) {
+        formatted += `\n*Model: ${result.model} | Latency: ${result.latency_ms}ms*\n`;
+      }
+
+      return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: formatted }] } };
+    } catch (error) {
+      console.error('[Stdio Wrapper] X search error:', error.message);
+      return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: `X search failed: ${error.message}` }], isError: true } };
+    }
+  }
+
+  /**
+   * Handle image generation tool locally — calls polydev.ai API
+   */
+  async handleGenerateImage(params, id) {
+    const args = params.arguments || {};
+    console.error('[Stdio Wrapper] Handling generate_image locally');
+
+    if (!args.prompt || typeof args.prompt !== 'string') {
+      return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: 'Error: prompt is required and must be a string' }], isError: true } };
+    }
+
+    const userToken = args.user_token || this.userToken;
+    if (!userToken) {
+      return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: 'Authentication required for image generation.\nUse the "login" tool first, or pass user_token parameter.' }], isError: true } };
+    }
+
+    try {
+      const response = await fetch('https://polydev.ai/api/generate-image', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${userToken}`,
+          'User-Agent': 'polydev-stdio-wrapper/1.0.0'
+        },
+        body: JSON.stringify({
+          prompt: args.prompt,
+          user_token: userToken,
+          provider: args.provider || 'openai',
+          model: args.model,
+          size: args.size || '1024x1024',
+          quality: args.quality || 'auto'
+        })
+      });
+
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        if (response.status === 400 && errorData.setup_url) {
+          return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: `No ${errorData.provider || 'API'} key found for image generation.\n\nImage generation requires your own API key:\n1. Get an API key from OpenAI (https://platform.openai.com) or Google AI (https://aistudio.google.com)\n2. Add it at https://polydev.ai/dashboard/models\n\nSupported providers: OpenAI (gpt-image-1.5) and Google Gemini` }], isError: true } };
+        }
+        throw new Error(errorData.error || `Image generation failed: HTTP ${response.status}`);
+      }
+
+      const result = await response.json();
+
+      // Save image to file if we have base64 data
+      if (result.image_base64) {
+        try {
+          const timestamp = Date.now();
+          const filename = `polydev-image-${timestamp}.png`;
+          const outputDir = path.join(os.homedir(), '.polydev', 'images');
+          if (!fs.existsSync(outputDir)) {
+            fs.mkdirSync(outputDir, { recursive: true });
+          }
+          const outputPath = path.join(outputDir, filename);
+          fs.writeFileSync(outputPath, Buffer.from(result.image_base64, 'base64'));
+          result.saved_to = outputPath;
+          console.error(`[Stdio Wrapper] Image saved to: ${outputPath}`);
+        } catch (saveError) {
+          console.error('[Stdio Wrapper] Failed to save image:', saveError.message);
+        }
+      }
+
+      // Format response
+      let formatted = '# Image Generated\n\n';
+      formatted += `**Provider**: ${result.provider || 'openai'}\n`;
+      formatted += `**Model**: ${result.model || 'gpt-image-1.5'}\n`;
+      if (result.size) formatted += `**Size**: ${result.size}\n`;
+      if (result.revised_prompt) formatted += `**Revised prompt**: ${result.revised_prompt}\n`;
+      if (result.text_response) formatted += `**Description**: ${result.text_response}\n`;
+      if (result.saved_to) formatted += `\n**Saved to**: \`${result.saved_to}\`\n`;
+      if (result.image_base64) formatted += `\nImage data: ${(result.image_base64.length / 1024).toFixed(0)}KB base64 PNG\n`;
+      if (result.latency_ms) formatted += `\n*Latency: ${result.latency_ms}ms*\n`;
+
+      return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: formatted }] } };
+    } catch (error) {
+      console.error('[Stdio Wrapper] Image generation error:', error.message);
+      return { jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: `Image generation failed: ${error.message}` }], isError: true } };
+    }
+  }
+
   /**
    * Check if a tool is a CLI tool that should be handled locally
    */

package/package.json

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