@oevortex/ddg_search 1.1.3 → 1.1.4

package/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [1.1.3] - 2025-11-30
+### Changed
+- Replaced Felo AI tool with IAsk AI tool for advanced AI-powered search
+- Added `src/utils/search_iask.js` implementing IAsk API client
+- Added `src/tools/iaskTool.js` tool definition and handler
+- Updated `src/index.ts` to use IAsk tool instead of Felo
+- Updated `package.json` description, keywords, and dependencies (`turndown`, `ws`)
+- Updated `README.md` to reference IAsk AI and document new tool parameters
+- Removed old Felo tool files (`feloTool.js`, `search_felo.js`)
+
+## [1.1.2] - 2025-11-29
+### Added
+- Initial release with DuckDuckGo and Felo AI search tools
+- MCP server implementation
+- Caching, rotating user agents, and web scraping features

package/README.md

@@ -2,8 +2,8 @@
   <img src="https://img.shields.io/npm/v/@oevortex/ddg_search.svg" alt="npm version" />
   <img src="https://img.shields.io/badge/License-Apache%202.0-blue.svg" alt="License: Apache 2.0" />
   <img src="https://img.shields.io/badge/YouTube-%40OEvortex-red.svg" alt="YouTube Channel" />
-  <h1>DuckDuckGo & Felo AI Search MCP 🔍🧠</h1>
-  <p>A blazing-fast, privacy-friendly Model Context Protocol (MCP) server for web search and AI-powered responses using DuckDuckGo and Felo AI.</p>
+  <h1>DuckDuckGo & IAsk AI Search MCP 🔍🧠</h1>
+  <p>A blazing-fast, privacy-friendly Model Context Protocol (MCP) server for web search and AI-powered responses using DuckDuckGo and IAsk AI.</p>
   <a href="https://glama.ai/mcp/servers/@OEvortex/ddg_search">
     <img width="380" height="200" src="https://glama.ai/mcp/servers/@OEvortex/ddg_search/badge" alt="DuckDuckGo Search MCP server" />
   </a>
@@ -20,9 +20,7 @@
 ## ✨ Features
 
 <div style="display: flex; flex-wrap: wrap; gap: 1.5em; margin-bottom: 1.5em;">  <div><b>🌐 Web search</b> using DuckDuckGo HTML</div>
-  <div><b>🧠 AI search</b> using Felo AI</div>
-  <div><b>📄 URL content extraction</b> with smart filtering</div>
-  <div><b>📊 URL metadata extraction</b> (title, description, images)</div>
+  <div><b>🧠 AI search</b> using IAsk AI</div>
   <div><b>⚡ Performance optimized</b> with caching</div>
   <div><b>🛡️ Security features</b> including rate limiting and rotating user agents</div>
   <div><b>🔌 MCP-compliant</b> server implementation</div>
@@ -52,7 +50,7 @@ npx -y @oevortex/ddg_search@latest
 ## 🛠️ Installation Options
 
 <details>
-<summary><b>Global Installation</b></summary>
+<summary><b>Global Installation (npm)</b></summary>
 
 ```bash
 npm install -g @oevortex/ddg_search
@@ -66,6 +64,36 @@ ddg-search-mcp
 
 </details>
 
+<details>
+<summary><b>Global Installation (Yarn)</b></summary>
+
+```bash
+yarn global add @oevortex/ddg_search
+```
+
+Run globally:
+
+```bash
+ddg-search-mcp
+```
+
+</details>
+
+<details>
+<summary><b>Global Installation (pnpm)</b></summary>
+
+```bash
+pnpm add -g @oevortex/ddg_search
+```
+
+Run globally:
+
+```bash
+ddg-search-mcp
+```
+
+</details>
+
 <details>
 <summary><b>Local Installation (Development)</b></summary>
 
@@ -76,6 +104,20 @@ npm install
 npm start
 ```
 
+Or with Yarn:
+
+```bash
+yarn install
+yarn start
+```
+
+Or with pnpm:
+
+```bash
+pnpm install
+pnpm start
+```
+
 </details>
 
 ---
@@ -140,34 +182,15 @@ Or if installed globally:
     <i>Example: Search the web for "climate change solutions"</i>
   </div>
   <div style="margin-bottom: 1.5em;">
-    <b>🧠 Felo AI Search Tool</b><br/>
-    <code>felo-search</code><br/>
+    <b>🧠 IAsk AI Search Tool</b><br/>
+    <code>iask-search</code><br/>
     <ul>
-      <li><b>query</b> (string, required): The search query or prompt</li>
+      <li><b>query</b> (string, required): The search query or question</li>
+      <li><b>mode</b> (string, optional, default: "question"): Search mode - "question", "academic", "forums", "wiki", or "thinking"</li>
+      <li><b>detailLevel</b> (string, optional): Response detail level - "concise", "detailed", or "comprehensive"</li>
       <li><b>stream</b> (boolean, optional, default: false): Whether to stream the response</li>
     </ul>
-    <i>Example: Search Felo AI for "Explain quantum computing in simple terms"</i>
-  </div>
-  <div style="margin-bottom: 1.5em;">
-    <b>📄 Fetch URL Tool</b><br/>
-    <code>fetch-url</code><br/>
-    <ul>
-      <li><b>url</b> (string, required): The URL to fetch</li>
-      <li><b>maxLength</b> (integer, optional, default: 10000): Max content length</li>
-      <li><b>extractMainContent</b> (boolean, optional, default: true): Extract main content</li>
-      <li><b>includeLinks</b> (boolean, optional, default: true): Include link text</li>
-      <li><b>includeImages</b> (boolean, optional, default: true): Include image alt text</li>
-      <li><b>excludeTags</b> (array, optional): Tags to exclude</li>
-    </ul>
-    <i>Example: Fetch the content from "https://example.com"</i>
-  </div>
-  <div style="margin-bottom: 1.5em;">
-    <b>📊 URL Metadata Tool</b><br/>
-    <code>url-metadata</code><br/>
-    <ul>
-      <li><b>url</b> (string, required): The URL to extract metadata from</li>
-    </ul>
-    <i>Example: Get metadata for "https://example.com"</i>
+    <i>Example: Search IAsk AI for "Explain quantum computing in simple terms"</i>
   </div>
 </div>
 
@@ -182,12 +205,10 @@ src/
   index.js        # Main entry point
   tools/          # Tool definitions and handlers
     searchTool.js
-    fetchUrlTool.js
-    metadataTool.js
-    feloTool.js
+    iaskTool.js
   utils/
     search.js     # Search and URL utilities
-    search_felo.js # Felo AI search utilities
+    search_iask.js # IAsk AI search utilities
 package.json
 README.md
 ```

package/bin/cli.js

@@ -12,9 +12,9 @@ async function startServer() {
   try {
     // Dynamically import the modules
     const { searchToolDefinition, searchToolHandler } = await import(`${modulePath}/tools/searchTool.js`);
-    const { fetchUrlToolDefinition, fetchUrlToolHandler } = await import(`${modulePath}/tools/fetchUrlTool.js`);
-    const { metadataToolDefinition, metadataToolHandler } = await import(`${modulePath}/tools/metadataTool.js`);
-    const { feloToolDefinition, feloToolHandler } = await import(`${modulePath}/tools/feloTool.js`);    // Create the MCP server
+    const { feloToolDefinition, feloToolHandler } = await import(`${modulePath}/tools/feloTool.js`);
+
+    // Create the MCP server
     const server = new Server({
       id: 'ddg-search-mcp',
       name: 'DuckDuckGo & Felo AI Search MCP',
@@ -31,8 +31,6 @@ async function startServer() {
     // Global variable to track available tools
     let availableTools = [
       searchToolDefinition,
-      fetchUrlToolDefinition,
-      metadataToolDefinition,
       feloToolDefinition
     ];
 
@@ -56,7 +54,7 @@ async function startServer() {
         const { name, arguments: args } = request.params;
         
         // Validate tool name
-        const validTools = ['web-search', 'fetch-url', 'url-metadata', 'felo-search'];
+        const validTools = ['web-search', 'felo-search'];
         if (!validTools.includes(name)) {
           throw new Error(`Unknown tool: ${name}`);
         }
@@ -66,12 +64,6 @@ async function startServer() {
           case 'web-search':
             return await searchToolHandler(args);
 
-          case 'fetch-url':
-            return await fetchUrlToolHandler(args);
-
-          case 'url-metadata':
-            return await metadataToolHandler(args);
-          
           case 'felo-search':
             return await feloToolHandler(args);
 
@@ -129,8 +121,6 @@ Options:
 
 This MCP server provides the following tools:
   - web-search: Search the web using DuckDuckGo
-  - fetch-url: Fetch and extract content from a URL
-  - url-metadata: Extract metadata from a URL
   - felo-search: Search using Felo AI for AI-generated responses
 
 Created by @OEvortex

package/package.json

@@ -1 +1 @@
-{"name":"@oevortex/ddg_search","version":"1.1.3","description":"A Model Context Protocol server for web search using DuckDuckGo and Felo AI","main":"src/index.js","module":"src/index.ts","exports":{".":{"import":"./src/index.js","default":"./src/index.js"}},"bin":{"ddg-search-mcp":"bin/cli.js","oevortex-ddg-search":"bin/cli.js"},"scripts":{"test":"echo \"Error: no test specified\" && exit 1","start":"node bin/cli.js","prepublishOnly":"npm run lint","lint":"echo \"No linting configured\"","build":"npx @smithery/cli build","dev":"npx @smithery/cli dev"},"publishConfig":{"access":"public"},"keywords":["mcp","model-context-protocol","duckduckgo","felo","search","web-search","ai-search","claude","ai","llm"],"author":"OEvortex","license":"Apache-2.0","type":"module","dependencies":{"@modelcontextprotocol/sdk":"^1.17.4","axios":"^1.8.4","cheerio":"^1.0.0","jsdom":"^26.1.0","smithery":"^0.5.2","uuid":"^9.0.1"},"devDependencies":{"@types/node":"^24.3.0","tsx":"^4.20.4","typescript":"^5.9.2"}}
+{"name":"@oevortex/ddg_search","version":"1.1.4","description":"A Model Context Protocol server for web search using DuckDuckGo and IAsk AI","main":"src/index.js","module":"src/index.ts","exports":{".":{"import":"./src/index.js","default":"./src/index.js"}},"bin":{"ddg-search-mcp":"bin/cli.js","oevortex-ddg-search":"bin/cli.js"},"scripts":{"test":"echo \"Error: no test specified\" && exit 1","start":"node bin/cli.js","prepublishOnly":"npm run lint","lint":"echo \"No linting configured\"","build":"npx @smithery/cli build","dev":"npx @smithery/cli dev"},"publishConfig":{"access":"public"},"keywords":["mcp","model-context-protocol","duckduckgo","iask","search","web-search","ai-search","claude","ai","llm"],"author":"OEvortex","license":"Apache-2.0","type":"module","dependencies":{"@modelcontextprotocol/sdk":"^1.17.4","axios":"^1.8.4","cheerio":"^1.0.0","jsdom":"^26.1.0","smithery":"^0.5.2","turndown":"^7.2.2","uuid":"^9.0.1","ws":"^8.18.3"},"devDependencies":{"@types/node":"^24.3.0","tsx":"^4.20.4","typescript":"^5.9.2"}}

package/src/index.js

@@ -3,19 +3,15 @@ import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprot
 
 // Import tool definitions and handlers
 import { searchToolDefinition, searchToolHandler } from './tools/searchTool.js';
-import { fetchUrlToolDefinition, fetchUrlToolHandler } from './tools/fetchUrlTool.js';
-import { metadataToolDefinition, metadataToolHandler } from './tools/metadataTool.js';
 import { feloToolDefinition, feloToolHandler } from './tools/feloTool.js';
 
 // Required: Export default createServer function for Smithery
 export default function createServer({ config } = {}) {
   console.log('Creating MCP server with latest SDK...');
-  
+
   // Global variable to track available tools
   const availableTools = [
     searchToolDefinition,
-    fetchUrlToolDefinition,
-    metadataToolDefinition,
     feloToolDefinition
   ];
   
@@ -51,16 +47,10 @@ export default function createServer({ config } = {}) {
       switch (name) {
         case 'web-search':
           return await searchToolHandler(args);
-        
-        case 'fetch-url':
-          return await fetchUrlToolHandler(args);
-        
-        case 'url-metadata':
-          return await metadataToolHandler(args);
-        
+
         case 'felo-search':
           return await feloToolHandler(args);
-        
+
         default:
           throw new Error(`Tool not found: ${name}`);
       }

package/src/index.ts

@@ -3,20 +3,16 @@ import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprot
 
 // Import tool definitions and handlers
 import { searchToolDefinition, searchToolHandler } from './tools/searchTool.js';
-import { fetchUrlToolDefinition, fetchUrlToolHandler } from './tools/fetchUrlTool.js';
-import { metadataToolDefinition, metadataToolHandler } from './tools/metadataTool.js';
-import { feloToolDefinition, feloToolHandler } from './tools/feloTool.js';
+import { iaskToolDefinition, iaskToolHandler } from './tools/iaskTool.js';
 
 // Required: Export default createServer function for Smithery
 export default function createServer({ config }: { config?: any } = {}) {
   console.log('Creating MCP server with latest SDK...');
-  
+
   // Global variable to track available tools
   const availableTools = [
     searchToolDefinition,
-    fetchUrlToolDefinition,
-    metadataToolDefinition,
-    feloToolDefinition
+    iaskToolDefinition
   ];
   
   console.log('Available tools:', availableTools.map(t => t.name));
@@ -51,16 +47,10 @@ export default function createServer({ config }: { config?: any } = {}) {
       switch (name) {
         case 'web-search':
           return await searchToolHandler(args);
-        
-        case 'fetch-url':
-          return await fetchUrlToolHandler(args);
-        
-        case 'url-metadata':
-          return await metadataToolHandler(args);
-        
-        case 'felo-search':
-          return await feloToolHandler(args);
-        
+
+        case 'iask-search':
+          return await iaskToolHandler(args);
+
         default:
           throw new Error(`Tool not found: ${name}`);
       }

package/src/tools/iaskTool.js

@@ -0,0 +1,101 @@
+import { searchIAsk, VALID_MODES, VALID_DETAIL_LEVELS } from '../utils/search_iask.js';
+
+/**
+ * IAsk AI search tool definition
+ */
+export const iaskToolDefinition = {
+  name: 'iask-search',
+  title: 'IAsk AI Search',
+  description: 'AI-powered search using IAsk.ai. Retrieves comprehensive, AI-generated responses based on web content. Supports different search modes (question, academic, forums, wiki, thinking) and detail levels (concise, detailed, comprehensive). Ideal for getting well-researched answers to complex questions.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      query: {
+        type: 'string',
+        description: 'The search query or question to ask. Supports natural language questions for comprehensive AI-generated responses.'
+      },
+      mode: {
+        type: 'string',
+        description: 'Search mode to use. Options: "question" (general questions), "academic" (scholarly/research), "forums" (community discussions), "wiki" (encyclopedia-style), "thinking" (deep analysis). Default is "question".',
+        enum: VALID_MODES,
+        default: 'question'
+      },
+      detailLevel: {
+        type: 'string',
+        description: 'Level of detail in the response. Options: "concise" (brief), "detailed" (moderate), "comprehensive" (extensive). Default is null (standard response).',
+        enum: VALID_DETAIL_LEVELS
+      },
+      stream: {
+        type: 'boolean',
+        description: 'Enable streaming mode to receive incremental results. Default is false.',
+        default: false
+      }
+    },
+    required: ['query']
+  },
+  annotations: {
+    readOnlyHint: true,
+    openWorldHint: false
+  }
+};
+
+/**
+ * IAsk AI search tool handler
+ * @param {Object} params - The tool parameters
+ * @returns {Promise<Object>} - The tool result
+ */
+export async function iaskToolHandler(params) {
+  const { 
+    query, 
+    mode = 'question', 
+    detailLevel = null, 
+    stream = false 
+  } = params;
+  
+  console.log(`Searching IAsk AI for: "${query}" (mode: ${mode}, detailLevel: ${detailLevel || 'default'}, stream: ${stream})`);
+  
+  try {
+    if (stream) {
+      // For streaming responses, collect them and return
+      let fullResponse = '';
+      const chunks = [];
+      
+      for await (const chunk of await searchIAsk(query, true, false, mode, detailLevel)) {
+        chunks.push(chunk);
+        fullResponse += chunk;
+      }
+      
+      return {
+        content: [
+          {
+            type: 'text',
+            text: fullResponse || 'No results found.'
+          }
+        ]
+      };
+    } else {
+      // For non-streaming responses
+      const response = await searchIAsk(query, false, false, mode, detailLevel);
+      
+      return {
+        content: [
+          {
+            type: 'text',
+            text: response || 'No results found.'
+          }
+        ]
+      };
+    }
+  } catch (error) {
+    console.error(`Error in IAsk search: ${error.message}`);
+    return {
+      isError: true,
+      content: [
+        {
+          type: 'text',
+          text: `Error searching IAsk: ${error.message}`
+        }
+      ]
+    };
+  }
+}

package/src/utils/search_iask.js

@@ -0,0 +1,381 @@
+import axios from 'axios';
+import * as cheerio from 'cheerio';
+import TurndownService from 'turndown';
+
+// Rotating User Agents
+const USER_AGENTS = [
+  'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+  'Mozilla/5.0 (Windows NT 10.0; Win64; x64) Edge/120.0.0.0',
+  'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2.1 Safari/605.1.15',
+  'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:122.0) Gecko/20100101 Firefox/122.0',
+  'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
+];
+
+// Cache results to avoid repeated requests
+const resultsCache = new Map();
+const CACHE_DURATION = 5 * 60 * 1000; // 5 minutes
+
+// Valid modes and detail levels
+const VALID_MODES = ['question', 'academic', 'forums', 'wiki', 'thinking'];
+const VALID_DETAIL_LEVELS = ['concise', 'detailed', 'comprehensive'];
+
+/**
+ * Response class for IAsk API responses
+ */
+class Response {
+  /**
+   * Create a new Response
+   * @param {string} text - The text content of the response
+   */
+  constructor(text) {
+    this.text = text;
+  }
+
+  /**
+   * String representation of the response
+   * @returns {string} The text content
+   */
+  toString() {
+    return this.text;
+  }
+}
+
+/**
+ * Get a random user agent from the list
+ * @returns {string} A random user agent string
+ */
+function getRandomUserAgent() {
+  return USER_AGENTS[Math.floor(Math.random() * USER_AGENTS.length)];
+}
+
+/**
+ * Generate a cache key for a search query
+ * @param {string} query - The search query
+ * @param {string} mode - The search mode
+ * @param {string|null} detailLevel - The detail level
+ * @returns {string} The cache key
+ */
+function getCacheKey(query, mode, detailLevel) {
+  return `iask-${mode}-${detailLevel || 'default'}-${query}`;
+}
+
+/**
+ * Clear old entries from the cache
+ */
+function clearOldCache() {
+  const now = Date.now();
+  for (const [key, value] of resultsCache.entries()) {
+    if (now - value.timestamp > CACHE_DURATION) {
+      resultsCache.delete(key);
+    }
+  }
+}
+
+/**
+ * Find HTML content in a nested structure
+ * @param {Object|Array} diff - The nested structure to search
+ * @returns {string|null} The found HTML content or null
+ */
+function cacheFind(diff) {
+  const values = Array.isArray(diff) ? diff : Object.values(diff);
+  const turndown = new TurndownService();
+  
+  for (const value of values) {
+    if (typeof value === 'object' && value !== null) {
+      const cache = cacheFind(value);
+      if (cache) return cache;
+    }
+    if (typeof value === 'string' && /<p>.+?<\/p>/.test(value)) {
+      return turndown.turndown(value).trim();
+    }
+  }
+  return null;
+}
+
+/**
+ * Format HTML content into readable markdown text
+ * @param {string} htmlContent - The HTML content to format
+ * @returns {string} Formatted text
+ */
+function formatHtml(htmlContent) {
+  const $ = cheerio.load(htmlContent);
+  const outputLines = [];
+
+  $('h1, h2, h3, p, ol, ul, div').each((_, element) => {
+    const tagName = element.tagName.toLowerCase();
+    const $el = $(element);
+
+    if (['h1', 'h2', 'h3'].includes(tagName)) {
+      outputLines.push(`\n**${$el.text().trim()}**\n`);
+    } else if (tagName === 'p') {
+      let text = $el.text().trim();
+      // Remove IAsk attribution
+      text = text.replace(/^According to Ask AI & Question AI www\.iAsk\.ai:\s*/i, '').trim();
+      // Remove footnote markers
+      text = text.replace(/\[\d+\]\(#fn:\d+ 'see footnote'\)/g, '');
+      if (text) outputLines.push(text + '\n');
+    } else if (['ol', 'ul'].includes(tagName)) {
+      $el.find('li').each((_, li) => {
+        outputLines.push('- ' + $(li).text().trim() + '\n');
+      });
+    } else if (tagName === 'div' && $el.hasClass('footnotes')) {
+      outputLines.push('\n**Authoritative Sources**\n');
+      $el.find('li').each((_, li) => {
+        const link = $(li).find('a');
+        if (link.length) {
+          outputLines.push(`- ${link.text().trim()} (${link.attr('href')})\n`);
+        }
+      });
+    }
+  });
+
+  return outputLines.join('');
+}
+
+/**
+ * Create an axios session with proper headers
+ * @returns {Object} Axios instance
+ */
+function createSession() {
+  return axios.create({
+    timeout: 30000,
+    headers: {
+      'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8',
+      'accept-encoding': 'gzip, deflate, br',
+      'accept-language': 'en-US,en;q=0.9',
+      'cache-control': 'no-cache',
+      'dnt': '1',
+      'pragma': 'no-cache',
+      'sec-ch-ua': '"Not)A;Brand";v="99", "Microsoft Edge";v="127", "Chromium";v="127"',
+      'sec-ch-ua-mobile': '?0',
+      'sec-ch-ua-platform': '"Windows"',
+      'sec-fetch-dest': 'document',
+      'sec-fetch-mode': 'navigate',
+      'sec-fetch-site': 'none',
+      'sec-fetch-user': '?1',
+      'upgrade-insecure-requests': '1',
+      'user-agent': getRandomUserAgent()
+    }
+  });
+}
+
+/**
+ * Search using the IAsk AI API
+ * @param {string} prompt - The search query or prompt
+ * @param {boolean} stream - If true, yields response chunks as they arrive
+ * @param {boolean} raw - If true, returns raw response dictionaries
+ * @param {string} mode - Search mode: 'question', 'academic', 'forums', 'wiki', 'thinking'
+ * @param {string|null} detailLevel - Detail level: 'concise', 'detailed', 'comprehensive'
+ * @returns {Promise<string|AsyncGenerator<string>>} The search results
+ */
+async function searchIAsk(prompt, stream = false, raw = false, mode = 'question', detailLevel = null) {
+  // Validate mode
+  if (!VALID_MODES.includes(mode)) {
+    throw new Error(`Invalid mode: ${mode}. Valid modes are: ${VALID_MODES.join(', ')}`);
+  }
+
+  // Validate detail level
+  if (detailLevel && !VALID_DETAIL_LEVELS.includes(detailLevel)) {
+    throw new Error(`Invalid detail level: ${detailLevel}. Valid levels are: ${VALID_DETAIL_LEVELS.join(', ')}`);
+  }
+
+  // Clear old cache entries
+  clearOldCache();
+
+  // Check cache first if not streaming
+  if (!stream) {
+    const cacheKey = getCacheKey(prompt, mode, detailLevel);
+    const cachedResults = resultsCache.get(cacheKey);
+
+    if (cachedResults && Date.now() - cachedResults.timestamp < CACHE_DURATION) {
+      return cachedResults.results;
+    }
+  }
+
+  const session = createSession();
+  const apiEndpoint = 'https://iask.ai/';
+
+  // Build URL with parameters
+  const params = new URLSearchParams({
+    mode: mode,
+    q: prompt
+  });
+  if (detailLevel) {
+    params.append('options[detail_level]', detailLevel);
+  }
+
+  // Define the streaming function
+  async function* streamFunction() {
+    try {
+      // First, get the initial page to extract tokens
+      const initialUrl = `${apiEndpoint}?${params.toString()}`;
+      const initialResponse = await session.get(initialUrl);
+
+      if (initialResponse.status !== 200) {
+        throw new Error(`Failed to get initial page - (${initialResponse.status}, ${initialResponse.statusText})`);
+      }
+
+      const $ = cheerio.load(initialResponse.data);
+      
+      // Extract Phoenix LiveView tokens
+      const phxNode = $('[id^="phx-"]').last();
+      const phxId = phxNode.attr('id');
+      const phxSession = phxNode.attr('data-phx-session');
+      const csrfToken = $('meta[name="csrf-token"]').attr('content');
+
+      if (!phxId || !csrfToken) {
+        throw new Error('Failed to extract required tokens from IAsk page');
+      }
+
+      // Connect to WebSocket
+      const WebSocket = (await import('ws')).default;
+      const wsUrl = `wss://iask.ai/live/websocket?_csrf_token=${encodeURIComponent(csrfToken)}&vsn=2.0.0`;
+      
+      const ws = new WebSocket(wsUrl, {
+        headers: {
+          'Origin': 'https://iask.ai',
+          'User-Agent': getRandomUserAgent()
+        }
+      });
+
+      let streamingText = '';
+      let resolveWs;
+      let rejectWs;
+      const wsPromise = new Promise((resolve, reject) => {
+        resolveWs = resolve;
+        rejectWs = reject;
+      });
+
+      const chunks = [];
+      let isComplete = false;
+
+      ws.on('open', () => {
+        // Send join message
+        const joinMessage = [
+          null,
+          null,
+          `lv:${phxId}`,
+          'phx_join',
+          {
+            params: { _csrf_token: csrfToken },
+            url: initialUrl,
+            session: phxSession
+          }
+        ];
+        ws.send(JSON.stringify(joinMessage));
+      });
+
+      ws.on('message', (data) => {
+        try {
+          const jsonData = JSON.parse(data.toString());
+          if (!jsonData || !jsonData[4]) return;
+
+          const diff = jsonData[4];
+          
+          try {
+            // Try to extract streaming data
+            if (diff.e && diff.e[0] && diff.e[0][1] && diff.e[0][1].data) {
+              let chunk = diff.e[0][1].data;
+              // Check if chunk contains HTML
+              if (/<[^>]+>/.test(chunk)) {
+                chunk = formatHtml(chunk);
+              } else {
+                chunk = chunk.replace(/<br\/>/g, '\n');
+              }
+              chunks.push(chunk);
+            }
+          } catch {
+            // Try cache find for final response
+            const cache = cacheFind(diff);
+            if (cache) {
+              if (diff.response !== undefined) {
+                // Format if it contains HTML
+                let formattedCache = cache;
+                if (/<[^>]+>/.test(cache)) {
+                  formattedCache = formatHtml(cache);
+                }
+                chunks.push(formattedCache);
+                isComplete = true;
+                ws.close();
+              }
+            }
+          }
+        } catch (error) {
+          console.debug('WebSocket message parse error:', error.message);
+        }
+      });
+
+      ws.on('close', () => {
+        resolveWs();
+      });
+
+      ws.on('error', (error) => {
+        rejectWs(error);
+      });
+
+      // Set timeout
+      const timeout = setTimeout(() => {
+        ws.close();
+        rejectWs(new Error('WebSocket connection timed out'));
+      }, 30000);
+
+      // Wait for WebSocket to complete
+      await wsPromise;
+      clearTimeout(timeout);
+
+      // Yield all collected chunks
+      for (const chunk of chunks) {
+        streamingText += chunk;
+        if (raw) {
+          yield { text: chunk };
+        } else {
+          yield new Response(chunk).toString();
+        }
+      }
+
+      // Cache the complete response
+      if (streamingText) {
+        resultsCache.set(getCacheKey(prompt, mode, detailLevel), {
+          results: streamingText,
+          timestamp: Date.now()
+        });
+      }
+
+    } catch (error) {
+      console.error('Error searching IAsk:', error.message);
+      
+      if (error.response) {
+        const status = error.response.status;
+        const statusText = error.response.statusText;
+        throw new Error(`IAsk API error: ${status} ${statusText}`);
+      }
+      
+      throw new Error(`Failed to search IAsk: ${error.message}`);
+    }
+  }
+
+  // If streaming is requested, return the generator
+  if (stream) {
+    return streamFunction();
+  }
+  
+  // For non-streaming, collect all chunks and return as a single string
+  let fullResponse = '';
+  
+  try {
+    for await (const chunk of streamFunction()) {
+      if (raw) {
+        fullResponse += chunk.text;
+      } else {
+        fullResponse += chunk;
+      }
+    }
+    
+    return fullResponse;
+  } catch (error) {
+    console.error('Error in non-streaming IAsk search:', error.message);
+    throw error;
+  }
+}
+
+export { searchIAsk, VALID_MODES, VALID_DETAIL_LEVELS };

package/src/tools/feloTool.js

@@ -1,85 +0,0 @@
-import { searchFelo } from '../utils/search_felo.js';
-
-/**
- * Felo AI search tool definition
- */
-export const feloToolDefinition = {
-  name: 'felo-search',
-  title: 'Felo AI Advanced Search',
-  description: 'Advanced AI-powered web search for technical intelligence. Retrieves up-to-date information including software releases, security advisories, migration guides, benchmarks, developer documentation, and community insights. Supports both standard and streaming responses.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      query: {
-        type: 'string',
-        description: 'A detailed search query or prompt describing the technical information needed. Supports natural language and keyword-based queries for precise results.'
-      },
-      stream: {
-        type: 'boolean',
-        description: 'Enable streaming mode to receive incremental, real-time search results as they are discovered. Useful for monitoring live updates or large result sets. Default is false (returns full result at once).',
-        default: false
-      }
-    },
-    required: ['query']
-  },
-  annotations: {
-    readOnlyHint: true,
-    openWorldHint: false
-  }
-};
-
-/**
- * Felo AI search tool handler
- * @param {Object} params - The tool parameters
- * @returns {Promise<Object>} - The tool result
- */
-export async function feloToolHandler(params) {
-  const { query, stream = false } = params;
-  console.log(`Searching Felo AI for: "${query}" (stream: ${stream})`);
-  
-  try {
-    if (stream) {
-      // For streaming responses, we need to collect them and then return
-      let fullResponse = '';
-      const chunks = [];
-      
-      for await (const chunk of await searchFelo(query, true)) {
-        chunks.push(chunk);
-        fullResponse += chunk;
-      }
-      
-      // Format the response
-      return {
-        content: [
-          {
-            type: 'text',
-            text: fullResponse || 'No results found.'
-          }
-        ]
-      };
-    } else {
-      // For non-streaming responses
-      const response = await searchFelo(query, false);
-      
-      return {
-        content: [
-          {
-            type: 'text',
-            text: response || 'No results found.'
-          }
-        ]
-      };
-    }
-  } catch (error) {
-    console.error(`Error in Felo search: ${error.message}`);
-    return {
-      isError: true,
-      content: [
-        {
-          type: 'text',
-          text: `Error searching Felo: ${error.message}`
-        }
-      ]
-    };
-  }
-}

package/src/tools/fetchUrlTool.js

@@ -1,114 +0,0 @@
-import { fetchUrlContent } from '../utils/search.js';
-
-/**
- * Fetch URL tool definition
- */
-export const fetchUrlToolDefinition = {
-  name: 'fetch-url',
-  title: 'Fetch URL Content',
-  description: 'Fetch and extract the main content from any URL, with customizable extraction options for text, links, and images',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      url: {
-        type: 'string',
-        description: 'The URL to fetch content from (must be a valid HTTP/HTTPS URL)'
-      },
-      maxLength: {
-        type: 'integer',
-        description: 'Maximum length of content to return in characters (default: 10000)',
-        default: 10000,
-        minimum: 1000,
-        maximum: 50000
-      },
-      extractMainContent: {
-        type: 'boolean',
-        description: 'Whether to attempt to extract main content only, filtering out navigation and ads (default: true)',
-        default: true
-      },
-      includeLinks: {
-        type: 'boolean',
-        description: 'Whether to include link text in the extracted content (default: true)',
-        default: true
-      },
-      includeImages: {
-        type: 'boolean',
-        description: 'Whether to include image alt text in the extracted content (default: true)',
-        default: true
-      },
-      excludeTags: {
-        type: 'array',
-        description: 'HTML tags to exclude from extraction (default: script, style, etc.)',
-        items: {
-          type: 'string'
-        }
-      }
-    },
-    required: ['url']
-  }
-};
-
-/**
- * Fetch URL tool handler
- * @param {Object} params - The tool parameters
- * @returns {Promise<Object>} - The tool result
- */
-export async function fetchUrlToolHandler(params) {
-  const {
-    url,
-    maxLength = 10000,
-    extractMainContent = true,
-    includeLinks = true,
-    includeImages = true,
-    excludeTags = ['script', 'style', 'noscript', 'iframe', 'svg', 'nav', 'footer', 'header', 'aside']
-  } = params;
-
-  console.log(`Fetching content from URL: ${url} (maxLength: ${maxLength})`);
-
-  try {
-    // Fetch content with specified options
-    const content = await fetchUrlContent(url, {
-      extractMainContent,
-      includeLinks,
-      includeImages,
-      excludeTags
-    });
-
-    // Truncate content if it's too long
-    const truncatedContent = content.length > maxLength
-      ? content.substring(0, maxLength) + '... [Content truncated due to length]'
-      : content;
-
-    // Add metadata about the extraction
-    const metadata = `
----
-Extraction settings:
-- URL: ${url}
-- Main content extraction: ${extractMainContent ? 'Enabled' : 'Disabled'}
-- Links included: ${includeLinks ? 'Yes' : 'No'}
-- Images included: ${includeImages ? 'Yes (as alt text)' : 'No'}
-- Content length: ${content.length} characters${content.length > maxLength ? ` (truncated to ${maxLength})` : ''}
----
-`;
-
-    return {
-      content: [
-        {
-          type: 'text',
-          text: truncatedContent + metadata
-        }
-      ]
-    };
-  } catch (error) {
-    console.error(`Error fetching URL ${url}:`, error);
-    return {
-      isError: true,
-      content: [
-        {
-          type: 'text',
-          text: `Error fetching URL: ${error.message}`
-        }
-      ]
-    };
-  }
-}

package/src/tools/metadataTool.js

@@ -1,54 +0,0 @@
-import { extractUrlMetadata } from '../utils/search.js';
-
-/**
- * URL metadata tool definition
- */
-export const metadataToolDefinition = {
-  name: 'url-metadata',
-  title: 'URL Metadata Extractor',
-  description: 'Extract metadata from a URL including title, description, Open Graph data, and favicon information',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      url: {
-        type: 'string',
-        description: 'The URL to extract metadata from (must be a valid HTTP/HTTPS URL)'
-      }
-    },
-    required: ['url']
-  }
-};
-
-/**
- * URL metadata tool handler
- * @param {Object} params - The tool parameters
- * @returns {Promise<Object>} - The tool result
- */
-export async function metadataToolHandler(params) {
-  const { url } = params;
-  console.log(`Extracting metadata from URL: ${url}`);
-  
-  const metadata = await extractUrlMetadata(url);
-  
-  // Format the metadata for display
-  const formattedMetadata = `
-## URL Metadata for ${url}
-
-**Title:** ${metadata.title}
-
-**Description:** ${metadata.description}
-
-**Image:** ${metadata.ogImage || 'None'}
-
-**Favicon:** ${metadata.favicon || 'None'}
-  `.trim();
-  
-  return {
-    content: [
-      {
-        type: 'text',
-        text: formattedMetadata
-      }
-    ]
-  };
-}

package/src/utils/search_felo.js

@@ -1,237 +0,0 @@
-import axios from 'axios';
-import { v4 as uuidv4 } from 'uuid';
-import https from 'https';
-
-// Rotating User Agents
-const USER_AGENTS = [
-  'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
-  'Mozilla/5.0 (Windows NT 10.0; Win64; x64) Edge/120.0.0.0',
-  'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2.1 Safari/605.1.15',
-  'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:122.0) Gecko/20100101 Firefox/122.0',
-  'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
-];
-
-// Cache results to avoid repeated requests
-const resultsCache = new Map();
-const CACHE_DURATION = 5 * 60 * 1000; // 5 minutes
-
-// HTTPS agent configuration to handle certificate chain issues
-const httpsAgent = new https.Agent({
-  rejectUnauthorized: true, // Keep security enabled
-  keepAlive: true,
-  timeout: 30000,
-  // Provide fallback for certificate issues while maintaining security
-  secureProtocol: 'TLSv1_2_method'
-});
-
-// Create a persistent axios instance to maintain session state
-const feloSession = axios.create({
-  timeout: 30000,
-  httpsAgent: httpsAgent,
-  headers: {
-    'accept': '*/*',
-    'accept-encoding': 'gzip, deflate, br, zstd',
-    'accept-language': 'en-US,en;q=0.9,en-IN;q=0.8',
-    'content-type': 'application/json',
-    'dnt': '1',
-    'origin': 'https://felo.ai',
-    'referer': 'https://felo.ai/',
-    'sec-ch-ua': '"Not)A;Brand";v="99", "Microsoft Edge";v="127", "Chromium";v="127"',
-    'sec-ch-ua-mobile': '?0',
-    'sec-ch-ua-platform': '"Windows"',
-    'sec-fetch-dest': 'empty',
-    'sec-fetch-mode': 'cors',
-    'sec-fetch-site': 'same-site',
-    'user-agent': getRandomUserAgent()
-  }
-});
-
-/**
- * Response class for Felo API responses
- */
-class Response {
-  /**
-   * Create a new Response
-   * @param {string} text - The text content of the response
-   */
-  constructor(text) {
-    this.text = text;
-  }
-
-  /**
-   * String representation of the response
-   * @returns {string} The text content
-   */
-  toString() {
-    return this.text;
-  }
-}
-
-/**
- * Get a random user agent from the list
- * @returns {string} A random user agent string
- */
-function getRandomUserAgent() {
-  return USER_AGENTS[Math.floor(Math.random() * USER_AGENTS.length)];
-}
-
-/**
- * Generate a cache key for a search query
- * @param {string} query - The search query
- * @returns {string} The cache key
- */
-function getCacheKey(query) {
-  return `felo-${query}`;
-}
-
-/**
- * Clear old entries from the cache
- */
-function clearOldCache() {
-  const now = Date.now();
-  for (const [key, value] of resultsCache.entries()) {
-    if (now - value.timestamp > CACHE_DURATION) {
-      resultsCache.delete(key);
-    }
-  }
-}
-
-/**
- * Search using the Felo AI API
- * @param {string} prompt - The search query or prompt
- * @param {boolean} stream - If true, yields response chunks as they arrive
- * @param {boolean} raw - If true, returns raw response dictionaries
- * @returns {Promise<string|AsyncGenerator<string>>} The search results
- */
-async function searchFelo(prompt, stream = false, raw = false) {
-  // Clear old cache entries
-  clearOldCache();
-
-  // Check cache first if not streaming
-  if (!stream) {
-    const cacheKey = getCacheKey(prompt);
-    const cachedResults = resultsCache.get(cacheKey);
-
-    if (cachedResults && Date.now() - cachedResults.timestamp < CACHE_DURATION) {
-      return cachedResults.results;
-    }
-  }
-
-  // Create payload for Felo API with proper structure from reference
-  const payload = {
-    query: prompt,
-    search_uuid: uuidv4().replace(/-/g, ''), // Remove dashes like in reference
-    lang: "",
-    agent_lang: "en",
-    search_options: {
-      langcode: "en-US",
-      search_image: true,
-      search_video: true
-    },
-    search_video: true,
-    model: "",
-    contexts_from: "google",
-    auto_routing: true
-  };
-
-  // Update user agent for this request
-  feloSession.defaults.headers['user-agent'] = getRandomUserAgent();
-
-  // Define the streaming function
-  async function* streamFunction() {
-    try {
-      const response = await feloSession.post('https://api.felo.ai/search/threads', payload, {
-        responseType: 'stream'
-      });
-
-      // Check for HTTP errors
-      if (response.status !== 200) {
-        throw new Error(`Failed to generate response - (${response.status}, ${response.statusText}) - ${response.data}`);
-      }
-
-      let streamingText = '';
-      let buffer = '';
-
-      // Process the stream as it comes in
-      for await (const chunk of response.data) {
-        buffer += chunk.toString();
-        
-        const lines = buffer.split('\n');
-        buffer = lines.pop() || ''; // Keep the last (potentially incomplete) line in the buffer
-        
-        for (const line of lines) {
-          if (line.startsWith('data:')) {
-            try {
-              const dataStr = line.substring(5).trim();
-              if (dataStr) {
-                const data = JSON.parse(dataStr);
-                if (data.type === 'answer' && 'text' in data.data) {
-                  const newText = data.data.text;
-                  if (newText.length > streamingText.length) {
-                    const delta = newText.substring(streamingText.length);
-                    streamingText = newText;
-                    
-                    if (raw) {
-                      yield { text: delta };
-                    } else {
-                      yield new Response(delta).toString();
-                    }
-                  }
-                }
-              }
-            } catch (error) {
-              // Ignore JSON parse errors and continue
-              console.debug('JSON parse error:', error.message);
-            }
-          }
-        }
-      }
-      
-      // Cache the complete response
-      if (streamingText) {
-        resultsCache.set(getCacheKey(prompt), {
-          results: streamingText,
-          timestamp: Date.now()
-        });
-      }
-      
-    } catch (error) {
-      console.error('Error searching Felo:', error.message);
-      
-      // Handle specific API errors
-      if (error.response) {
-        const status = error.response.status;
-        const statusText = error.response.statusText;
-        const data = error.response.data;
-        throw new Error(`Felo API error: ${status} ${statusText} - ${data}`);
-      }
-      
-      throw new Error(`Failed to search Felo: ${error.message}`);
-    }
-  }
-
-  // If streaming is requested, return the generator
-  if (stream) {
-    return streamFunction();
-  }
-  
-  // For non-streaming, collect all chunks and return as a single string
-  let fullResponse = '';
-  
-  try {
-    for await (const chunk of streamFunction()) {
-      if (raw) {
-        fullResponse += chunk.text;
-      } else {
-        fullResponse += chunk;
-      }
-    }
-    
-    return fullResponse;
-  } catch (error) {
-    console.error('Error in non-streaming Felo search:', error.message);
-    throw error;
-  }
-}
-
-export { searchFelo };