@oevortex/ddg_search 1.1.5 → 1.1.7

package/CHANGELOG.md

@@ -2,9 +2,12 @@
 
 All notable changes to this project will be documented in this file.
 
-## [1.1.3] - 2025-11-30
+## [1.1.7] - 2025-11-30
 ### Changed
 - Replaced Felo AI tool with IAsk AI tool for advanced AI-powered search
+- Added new dependencies: `turndown` for HTML to Markdown conversion, `ws` for WebSocket support
+- Updated README to reflect changes and new tool usage
+- Added new modes: 'short', 'detailed' in web search tool
 - 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

package/README.md

@@ -1,12 +1,22 @@
 <div align="center">
-  <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 & 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://www.npmjs.com/package/@oevortex/ddg_search">
+    <img src="https://img.shields.io/npm/v/@oevortex/ddg_search.svg" alt="npm version" />
+  </a>
+  <a href="https://github.com/OEvortex/ddg_search/blob/main/LICENSE">
+    <img src="https://img.shields.io/badge/License-Apache%202.0-blue.svg" alt="License: Apache 2.0" />
+  </a>
+  <a href="https://youtube.com/@OEvortex">
+    <img src="https://img.shields.io/badge/YouTube-%40OEvortex-red.svg" alt="YouTube Channel" />
+  </a>
+  <h1>DuckDuckGo & IAsk AI Search MCP <span style="font-size:2.2rem;">🔍🧠</span></h1>
+  <p style="font-size:1.15rem; max-width:600px; margin:0 auto;">
+    <strong>Lightning-fast, privacy-first Model Context Protocol (MCP) server for web search and AI-powered answers.<br>
+    Powered by DuckDuckGo and IAsk AI.</strong>
+  </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>
+  <br>
   <a href="https://youtube.com/@OEvortex"><strong>Subscribe for updates & tutorials</strong></a>
 </div>
 
@@ -27,6 +37,7 @@
   <div><b>🆓 No API keys required</b> - works out of the box</div>
 </div>
 
+
 > [!IMPORTANT]
 > Unlike many search tools, this package performs actual web scraping rather than using limited APIs, giving you more comprehensive results.
 
@@ -42,6 +53,7 @@ npx -y @oevortex/ddg_search@latest
 ```
 </div>
 
+
 > [!TIP]
 > This will download and run the latest version of the MCP server directly without installation – perfect for quick use with AI assistants.
 

package/package.json

@@ -1 +1,58 @@
-{"name":"@oevortex/ddg_search","version":"1.1.5","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"}}
+{
+  "name": "@oevortex/ddg_search",
+  "version": "1.1.7",
+  "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",
+    "axios-cookiejar-support": "^6.0.5",
+    "cheerio": "^1.0.0",
+    "smithery": "^0.5.2",
+    "tough-cookie": "^6.0.0",
+    "turndown": "^7.2.2",
+    "ws": "^8.18.3"
+  },
+  "devDependencies": {
+    "@types/node": "^24.3.0",
+    "tsx": "^4.20.4",
+    "typescript": "^5.9.2"
+  }
+}

package/src/index.js

@@ -3,7 +3,7 @@ import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprot
 
 // Import tool definitions and handlers
 import { searchToolDefinition, searchToolHandler } from './tools/searchTool.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 } = {}) {
@@ -12,7 +12,7 @@ export default function createServer({ config } = {}) {
   // Global variable to track available tools
   const availableTools = [
     searchToolDefinition,
-    feloToolDefinition
+    iaskToolDefinition
   ];
   
   console.log('Available tools:', availableTools.map(t => t.name));
@@ -48,8 +48,8 @@ export default function createServer({ config } = {}) {
         case 'web-search':
           return await searchToolHandler(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/searchTool.js

@@ -6,26 +6,26 @@ import { searchDuckDuckGo } from '../utils/search.js';
 export const searchToolDefinition = {
   name: 'web-search',
   title: 'Web Search',
-  description: 'Search the web using DuckDuckGo and return comprehensive results with titles, URLs, and snippets',
+  description: 'Perform a web search using DuckDuckGo and receive detailed results including titles, URLs, and summaries.',
   inputSchema: {
     type: 'object',
     properties: {
       query: {
         type: 'string',
-        description: 'The search query to find relevant web pages'
-      },
-      page: {
-        type: 'integer',
-        description: 'Page number for pagination (default: 1)',
-        default: 1,
-        minimum: 1
+        description: 'Enter your search query to find the most relevant web pages.'
       },
       numResults: {
         type: 'integer',
-        description: 'Number of results to return per page (default: 10, max: 20)',
-        default: 10,
+        description: 'Specify how many results to display (default: 3, maximum: 20).',
+        default: 3,
         minimum: 1,
         maximum: 20
+      },
+      mode: {
+        type: 'string',
+        description: "Choose 'short' for basic results (no Description) or 'detailed' for full results (includes Description).",
+        enum: ['short', 'detailed'],
+        default: 'short'
       }
     },
     required: ['query']
@@ -38,22 +38,17 @@ export const searchToolDefinition = {
  * @returns {Promise<Object>} - The tool result
  */
 export async function searchToolHandler(params) {
-  const { query, page = 1, numResults = 10 } = params;
-  console.log(`Searching for: ${query} (page ${page}, ${numResults} results)`);
-  
-  const results = await searchDuckDuckGo(query, page, numResults);
+  const { query, numResults = 3, mode = 'short' } = params;
+  console.log(`Searching for: ${query} (${numResults} results, mode: ${mode})`);
+
+  const results = await searchDuckDuckGo(query, numResults, mode);
   console.log(`Found ${results.length} results`);
-  
-  // Format the results for display
-  const formattedResults = results.map((result, index) => 
-    `${index + 1}. [${result.title}](${result.url})\n   ${result.snippet}`
-  ).join('\n\n');
-  
+
   return {
     content: [
       {
         type: 'text',
-        text: formattedResults || 'No results found.'
+        text: JSON.stringify(results)
       }
     ]
   };

package/src/utils/search.js

@@ -3,7 +3,6 @@ import * as cheerio from 'cheerio';
 import https from 'https';
 
 // Constants
-const RESULTS_PER_PAGE = 10;
 const MAX_CACHE_PAGES = 5;
 
 // Rotating User Agents
@@ -37,13 +36,12 @@ function getRandomUserAgent() {
 }
 
 /**
- * Generate a cache key for a search query and page
+ * Generate a cache key for a search query
  * @param {string} query - The search query
- * @param {number} page - The page number
  * @returns {string} The cache key
  */
-function getCacheKey(query, page) {
-  return `${query}-${page}`;
+function getCacheKey(query) {
+  return `${query}`;
 }
 
 /**
@@ -125,23 +123,20 @@ function getFaviconUrl(url) {
   }
 }
 
+
 /**
  * Scrapes search results from DuckDuckGo HTML
  * @param {string} query - The search query
- * @param {number} page - The page number (default: 1)
  * @param {number} numResults - Number of results to return (default: 10)
  * @returns {Promise<Array>} - Array of search results
  */
-async function searchDuckDuckGo(query, page = 1, numResults = 10) {
+async function searchDuckDuckGo(query, numResults = 10, mode = 'short') {
   try {
     // Clear old cache entries
     clearOldCache();
 
-    // Calculate start index for pagination
-    const startIndex = (page - 1) * RESULTS_PER_PAGE;
-
     // Check cache first
-    const cacheKey = getCacheKey(query, page);
+    const cacheKey = getCacheKey(query);
     const cachedResults = resultsCache.get(cacheKey);
 
     if (cachedResults && Date.now() - cachedResults.timestamp < CACHE_DURATION) {
@@ -153,7 +148,7 @@ async function searchDuckDuckGo(query, page = 1, numResults = 10) {
 
     // Fetch results
     const response = await axios.get(
-      `https://duckduckgo.com/html/?q=${encodeURIComponent(query)}&s=${startIndex}`,
+      `https://duckduckgo.com/html/?q=${encodeURIComponent(query)}`,
       {
         headers: {
           'User-Agent': userAgent
@@ -172,6 +167,7 @@ async function searchDuckDuckGo(query, page = 1, numResults = 10) {
     const $ = cheerio.load(html);
 
     const results = [];
+    const jinaFetchPromises = [];
     $('.result').each((i, result) => {
       const $result = $(result);
       const titleEl = $result.find('.result__title a');
@@ -185,24 +181,69 @@ async function searchDuckDuckGo(query, page = 1, numResults = 10) {
 
       const directLink = extractDirectUrl(rawLink || '');
       const favicon = getFaviconUrl(directLink);
+      const jinaUrl = getJinaAiUrl(directLink);
 
       if (title && directLink) {
-        results.push({
-          title,
-          url: directLink,
-          snippet: description || '',
-          favicon: favicon,
-          displayUrl: displayUrl || ''
-        });
+        if (mode === 'detailed') {
+          jinaFetchPromises.push(
+            axios.get(jinaUrl, {
+              headers: {
+                'User-Agent': getRandomUserAgent()
+              },
+              httpsAgent: httpsAgent,
+              timeout: 10000
+            })
+            .then(jinaRes => {
+              let jinaContent = '';
+              if (jinaRes.status === 200 && typeof jinaRes.data === 'string') {
+                const $jina = cheerio.load(jinaRes.data);
+                jinaContent = $jina('body').text()
+              }
+              return {
+                title,
+                url: directLink,
+                snippet: description || '',
+                favicon: favicon,
+                displayUrl: displayUrl || '',
+                Description: jinaContent
+              };
+            })
+            .catch(() => {
+              return {
+                title,
+                url: directLink,
+                snippet: description || '',
+                favicon: favicon,
+                displayUrl: displayUrl || '',
+                Description: ''
+              };
+            })
+          );
+        } else {
+          // short mode: omit Description
+          jinaFetchPromises.push(
+            Promise.resolve({
+              title,
+              url: directLink,
+              snippet: description || '',
+              favicon: favicon,
+              displayUrl: displayUrl || ''
+            })
+          );
+        }
       }
     });
 
-    // Get paginated results
-    const paginatedResults = results.slice(0, numResults);
+    // Wait for all Jina AI fetches to complete
+    const jinaResults = await Promise.all(jinaFetchPromises);
+    results.push(...jinaResults);
+
+    // Get limited results
+    const limitedResults = results.slice(0, numResults);
 
     // Cache the results
     resultsCache.set(cacheKey, {
-      results: paginatedResults,
+      results: limitedResults,
       timestamp: Date.now()
     });
 
@@ -212,190 +253,32 @@ async function searchDuckDuckGo(query, page = 1, numResults = 10) {
       resultsCache.delete(oldestKey);
     }
 
-    return paginatedResults;
+    return limitedResults;
   } catch (error) {
     console.error('Error searching DuckDuckGo:', error.message);
     throw error;
   }
 }
 
-/**
- * Fetches the content of a URL and returns it as text
- * @param {string} url - The URL to fetch
- * @param {Object} options - Options for content extraction
- * @param {boolean} options.extractMainContent - Whether to attempt to extract main content (default: true)
- * @param {boolean} options.includeLinks - Whether to include link text (default: true)
- * @param {boolean} options.includeImages - Whether to include image alt text (default: true)
- * @param {string[]} options.excludeTags - Tags to exclude from extraction
- * @returns {Promise<string>} - The content of the URL
- */
-async function fetchUrlContent(url, options = {}) {
-  try {
-    // Default options
-    const {
-      extractMainContent = true,
-      includeLinks = true,
-      includeImages = true,
-      excludeTags = ['script', 'style', 'noscript', 'iframe', 'svg', 'nav', 'footer', 'header', 'aside']
-    } = options;
-
-    // Get a random user agent
-    const userAgent = getRandomUserAgent();
-
-    const response = await axios.get(url, {
-      headers: {
-        'User-Agent': userAgent
-      },
-      timeout: 10000, // 10 second timeout
-      httpsAgent: httpsAgent
-    });
-
-    if (response.status !== 200) {
-      throw new Error(`Failed to fetch URL: ${url}`);
-    }
-
-    // If the content is HTML, extract the text content
-    const contentType = response.headers['content-type'] || '';
-    if (contentType.includes('text/html')) {
-      const $ = cheerio.load(response.data);
-
-      // Remove unwanted elements
-      excludeTags.forEach(tag => {
-        $(tag).remove();
-      });
-
-      // Remove ads and other common unwanted elements
-      const unwantedSelectors = [
-        '[id*="ad"]', '[class*="ad"]', '[id*="banner"]', '[class*="banner"]',
-        '[id*="popup"]', '[class*="popup"]', '[class*="cookie"]',
-        '[id*="cookie"]', '[class*="newsletter"]', '[id*="newsletter"]',
-        '[class*="social"]', '[id*="social"]', '[class*="share"]', '[id*="share"]'
-      ];
-
-      unwantedSelectors.forEach(selector => {
-        try {
-          $(selector).remove();
-        } catch (e) {
-          // Ignore invalid selectors
-        }
-      });
-
-      // Handle links and images
-      if (!includeLinks) {
-        $('a').each((i, link) => {
-          $(link).replaceWith($(link).text());
-        });
-      }
-
-      if (!includeImages) {
-        $('img').remove();
-      } else {
-        // Replace images with their alt text
-        $('img').each((i, img) => {
-          const alt = $(img).attr('alt');
-          if (alt) {
-            $(img).replaceWith(`[Image: ${alt}]`);
-          } else {
-            $(img).remove();
-          }
-        });
-      }
-
-      // Try to extract main content if requested
-      if (extractMainContent) {
-        // Common content selectors in order of priority
-        const contentSelectors = [
-          'article', 'main', '[role="main"]', '.post-content', '.article-content',
-          '.content', '#content', '.post', '.article', '.entry-content',
-          '.page-content', '.post-body', '.post-text', '.story-body'
-        ];
-
-        for (const selector of contentSelectors) {
-          const mainContent = $(selector).first();
-          if (mainContent.length > 0) {
-            // Clean up the content
-            return cleanText(mainContent.text());
-          }
-        }
-      }
-
-      // If no main content found or not requested, use the body
-      return cleanText($('body').text());
-    }
-
-    // For non-HTML content, return as is
-    return response.data.toString();
-  } catch (error) {
-    console.error('Error fetching URL content:', error.message);
-    throw error;
-  }
-}
 
-/**
- * Cleans up text by removing excessive whitespace and normalizing line breaks
- * @param {string} text - The text to clean
- * @returns {string} - The cleaned text
- */
-function cleanText(text) {
-  return text
-    .replace(/\s+/g, ' ')  // Replace multiple whitespace with single space
-    .replace(/\n\s*\n/g, '\n\n')  // Normalize multiple line breaks
-    .replace(/^\s+|\s+$/g, '')  // Trim start and end
-    .trim();
-}
+export {
+  searchDuckDuckGo,
+  extractDirectUrl,
+  getFaviconUrl
+};
 
 /**
- * Extracts metadata from a URL (title, description, etc.)
- * @param {string} url - The URL to extract metadata from
- * @returns {Promise<Object>} - The metadata
+ * Generate a Jina AI URL for a given website URL
+ * @param {string} url - The website URL
+ * @returns {string} The Jina AI URL
  */
-async function extractUrlMetadata(url) {
+function getJinaAiUrl(url) {
   try {
-    // Get a random user agent
-    const userAgent = getRandomUserAgent();
-
-    const response = await axios.get(url, {
-      headers: {
-        'User-Agent': userAgent
-      },
-      httpsAgent: httpsAgent
-    });
-
-    if (response.status !== 200) {
-      throw new Error(`Failed to fetch URL: ${url}`);
-    }
-
-    const $ = cheerio.load(response.data);
-
-    // Extract metadata
-    const title = $('title').text() || '';
-    const description = $('meta[name="description"]').attr('content') ||
-                       $('meta[property="og:description"]').attr('content') || '';
-    const ogImage = $('meta[property="og:image"]').attr('content') || '';
-    const favicon = $('link[rel="icon"]').attr('href') ||
-                  $('link[rel="shortcut icon"]').attr('href') || '';
-
-    // Resolve relative URLs
-    const resolvedFavicon = favicon ? new URL(favicon, url).href : getFaviconUrl(url);
-    const resolvedOgImage = ogImage ? new URL(ogImage, url).href : '';
-
-    return {
-      title,
-      description,
-      ogImage: resolvedOgImage,
-      favicon: resolvedFavicon,
-      url
-    };
-  } catch (error) {
-    console.error('Error extracting URL metadata:', error.message);
-    throw error;
+    const urlObj = new URL(url);
+    return `https://r.jina.ai/${urlObj.href}`;
+  } catch {
+    return '';
   }
 }
 
-export {
-  searchDuckDuckGo,
-  fetchUrlContent,
-  extractUrlMetadata,
-  extractDirectUrl,
-  getFaviconUrl
-};
+export { getJinaAiUrl };

package/src/utils/search_iask.js

@@ -1,52 +1,22 @@
 import axios from 'axios';
+import WebSocket from 'ws';
 import * as cheerio from 'cheerio';
 import TurndownService from 'turndown';
+import * as tough from 'tough-cookie';
+import { wrapper } from 'axios-cookiejar-support';
 
-// 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
+const { CookieJar } = tough;
 
 // 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;
-  }
-}
+// Cache results to avoid repeated requests
+const resultsCache = new Map();
+const CACHE_DURATION = 5 * 60 * 1000; // 5 minutes
 
-/**
- * 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)];
-}
+const DEFAULT_TIMEOUT = 30000;
+const API_ENDPOINT = 'https://iask.ai/';
 
 /**
  * Generate a cache key for a search query
@@ -72,23 +42,25 @@ function clearOldCache() {
 }
 
 /**
- * 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
+ * Recursively search for cached HTML content in diff object
+ * @param {any} diff - The diff object to search
+ * @returns {string|null} The found 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) {
+    if (Array.isArray(value) || (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();
+      const turndownService = new TurndownService();
+      return turndownService.turndown(value).trim();
     }
   }
+  
   return null;
 }
 
@@ -98,6 +70,8 @@ function cacheFind(diff) {
  * @returns {string} Formatted text
  */
 function formatHtml(htmlContent) {
+  if (!htmlContent) return '';
+  
   const $ = cheerio.load(htmlContent);
   const outputLines = [];
 
@@ -133,37 +107,10 @@ function formatHtml(htmlContent) {
 }
 
 /**
- * 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
+ * Search using IAsk AI via WebSocket (Phoenix LiveView)
  * @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 {boolean} stream - If true, returns async generator for streaming
+ * @param {boolean} raw - If true, returns raw response (not used currently)
  * @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
@@ -182,200 +129,173 @@ async function searchIAsk(prompt, stream = false, raw = false, mode = 'question'
   // Clear old cache entries
   clearOldCache();
 
-  // Check cache first if not streaming
-  if (!stream) {
-    const cacheKey = getCacheKey(prompt, mode, detailLevel);
-    const cachedResults = resultsCache.get(cacheKey);
+  const cacheKey = getCacheKey(prompt, mode, detailLevel);
+  const cachedResults = resultsCache.get(cacheKey);
 
-    if (cachedResults && Date.now() - cachedResults.timestamp < CACHE_DURATION) {
-      return cachedResults.results;
+  if (cachedResults && Date.now() - cachedResults.timestamp < CACHE_DURATION) {
+    const result = cachedResults.results;
+    if (stream) {
+      return (async function*() { yield result; })();
     }
+    return result;
   }
 
-  const session = createSession();
-  const apiEndpoint = 'https://iask.ai/';
-
-  // Build URL with parameters
-  const params = new URLSearchParams({
-    mode: mode,
-    q: prompt
-  });
+  // Build URL parameters
+  const params = new URLSearchParams({ 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);
+  // Create a cookie jar for session management
+  const jar = new CookieJar();
+  const client = wrapper(axios.create({ jar }));
 
-      if (initialResponse.status !== 200) {
-        throw new Error(`Failed to get initial page - (${initialResponse.status}, ${initialResponse.statusText})`);
-      }
+  // Get initial page and extract tokens
+  const response = await client.get(API_ENDPOINT, {
+    params: Object.fromEntries(params),
+    timeout: DEFAULT_TIMEOUT,
+    headers: {
+      'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
+    }
+  });
 
-      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');
-      }
+  const $ = cheerio.load(response.data);
+  
+  const phxNode = $('[id^="phx-"]').first();
+  const csrfToken = $('[name="csrf-token"]').attr('content');
+  const phxId = phxNode.attr('id');
+  const phxSession = phxNode.attr('data-phx-session');
 
-      // 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()
+  if (!phxId || !csrfToken) {
+    throw new Error('Failed to extract required tokens from page');
+  }
+
+  // Get the actual response URL (after any redirects)
+  const responseUrl = response.request.res?.responseUrl || response.config.url;
+  
+  // Get cookies from the jar for WebSocket connection
+  const cookies = await jar.getCookies(API_ENDPOINT);
+  const cookieString = cookies.map(c => `${c.key}=${c.value}`).join('; ');
+  
+  // Build WebSocket URL
+  const wsParams = new URLSearchParams({
+    '_csrf_token': csrfToken,
+    'vsn': '2.0.0'
+  });
+  const wsUrl = `wss://iask.ai/live/websocket?${wsParams.toString()}`;
+
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(wsUrl, {
+      headers: {
+        'Cookie': cookieString,
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+        'Origin': 'https://iask.ai'
+      }
+    });
+    
+    let buffer = '';
+    const chunks = [];
+    let timeoutId;
+
+    ws.on('open', () => {
+      // Send phx_join message
+      ws.send(JSON.stringify([
+        null,
+        null,
+        `lv:${phxId}`,
+        'phx_join',
+        {
+          params: { _csrf_token: csrfToken },
+          url: responseUrl,
+          session: phxSession
         }
-      });
+      ]));
+    });
 
-      let streamingText = '';
-      let resolveWs;
-      let rejectWs;
-      const wsPromise = new Promise((resolve, reject) => {
-        resolveWs = resolve;
-        rejectWs = reject;
-      });
+    ws.on('message', (data) => {
+      try {
+        const msg = JSON.parse(data.toString());
+        if (!msg) return;
 
-      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));
-      });
+        const diff = msg[4];
+        if (!diff) return;
+
+        let chunk = null;
 
-      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
+          // Try to get chunk from diff.e[0][1].data
+          // Use non-optional chaining to trigger exception if path doesn't exist
+          if (diff.e) {
+            chunk = diff.e[0][1].data;
+            
+            if (chunk) {
+              let formatted;
               if (/<[^>]+>/.test(chunk)) {
-                chunk = formatHtml(chunk);
+                formatted = formatHtml(chunk);
               } else {
-                chunk = chunk.replace(/<br\/>/g, '\n');
+                formatted = chunk.replace(/<br\/>/g, '\n');
               }
-              chunks.push(chunk);
+              
+              buffer += formatted;
+              chunks.push(formatted);
             }
-          } 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();
-              }
+          } else {
+            throw new Error('No diff.e');
+          }
+        } catch {
+          // Fallback to cacheFind
+          const cache = cacheFind(diff);
+          if (cache) {
+            let formatted;
+            if (/<[^>]+>/.test(cache)) {
+              formatted = formatHtml(cache);
+            } else {
+              formatted = cache;
             }
+            buffer += formatted;
+            chunks.push(formatted);
+            // Close after cache find
+            ws.close();
+            return;
           }
-        } 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(() => {
+      } catch (err) {
+        reject(new Error(`IAsk API error: ${err.message}`));
         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,
+    ws.on('close', () => {
+      clearTimeout(timeoutId);
+      
+      // Cache the result
+      if (buffer) {
+        resultsCache.set(cacheKey, {
+          results: buffer,
           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;
+      if (stream) {
+        resolve((async function*() {
+          for (const chunk of chunks) {
+            yield chunk;
+          }
+        })());
       } else {
-        fullResponse += chunk;
+        resolve(buffer || 'No results found.');
       }
-    }
-    
-    return fullResponse;
-  } catch (error) {
-    console.error('Error in non-streaming IAsk search:', error.message);
-    throw error;
-  }
+    });
+
+    ws.on('error', (err) => {
+      clearTimeout(timeoutId);
+      reject(new Error(`WebSocket error: ${err.message}`));
+    });
+
+    timeoutId = setTimeout(() => {
+      ws.close();
+    }, DEFAULT_TIMEOUT);
+  });
 }
 
 export { searchIAsk, VALID_MODES, VALID_DETAIL_LEVELS };