AI Tools Overview

import '@/ai/tools/web-search.ts';
import '@/ai/tools/twitter-search.ts';
import '@/ai/tools/web-scraper.ts';

export const webSearch = ai.defineTool(
  {
    name: 'webSearch',
    description: 'Searches the web for a given query and returns a list of search results, including organic results, news, and academic papers to get a comprehensive overview.',
    inputSchema: WebSearchInputSchema,
    outputSchema: WebSearchOutputSchema,
  },
  async (input) => {
    if (!process.env.SERPAPI_API_KEY || 
        process.env.SERPAPI_API_KEY === 'YOUR_API_KEY_HERE') {
      throw new Error(
        'SERPAPI_API_KEY is not configured. Please add it to your .env file.'
      );
    }

    console.log(`Performing real web search for: ${input.query}`);

    try {
      const response = await getJson({
        api_key: process.env.SERPAPI_API_KEY,
        q: input.query,
        engine: 'google',
        location: 'United States',
      });

      const organicResults = (response.organic_results || []).map(result => ({
        title: result.title,
        link: result.link,
        snippet: result.snippet,
      }));
      
      if (organicResults.length === 0) {
        throw new Error('No web search results found for the query.');
      }
      
      // Limit to top 5-7 results to keep context focused
      return organicResults.slice(0, 7);

    } catch (error: any) {
      console.error('Error performing web search with SerpApi:', error);
      throw new Error(`SerpApi search failed: ${error.message}`);
    }
  }
);

export const webScraper = ai.defineTool(
  {
    name: 'webScraper',
    description: 'Uses a headless browser via SerpApi to fetch the full HTML content of a given URL, then returns its main textual content. Use this to read the content of an article or webpage provided by the user, especially for modern, JS-heavy sites.',
    inputSchema: WebScraperInputSchema,
    outputSchema: WebScraperOutputSchema,
  },
  async (input) => {
    if (!process.env.SERPAPI_API_KEY || 
        process.env.SERPAPI_API_KEY === 'YOUR_API_KEY_HERE') {
      throw new Error(
        'SERPAPI_API_KEY is not configured for the web scraper.'
      );
    }

    console.log(`Scraping URL with SerpApi: ${input.url}`);
    
    try {
      const html = await getHtml({
        api_key: process.env.SERPAPI_API_KEY,
        url: input.url,
      });

      if (!html) {
        throw new Error('SerpApi returned no HTML content.');
      }

      const dom = new JSDOM(html);
      const doc = dom.window.document;

      // Remove non-content elements for cleaner text
      doc.querySelectorAll(
        'script, style, nav, footer, header, aside, form, button, ' +
        '[role="navigation"], [role="banner"], [role="contentinfo"]'
      ).forEach(el => el.remove());

      // Try to find the main content area
      const mainContent = doc.querySelector(
        'main, article, #content, #main, .post, .entry-content, .article-body'
      );
      const textSource = mainContent || doc.body;
      
      let text = textSource.textContent || "";
      
      // Clean up whitespace
      const cleanedText = text.replace(/\s\s+/g, ' ').trim();
      
      if (!cleanedText) {
        throw new Error('Could not extract meaningful content from the page.');
      }

      console.log(
        `SerpApi scraping successful, content length: ${cleanedText.length}`
      );
      
      // Return a reasonable amount of content to avoid oversized AI context
      return cleanedText.substring(0, 15000);

    } catch (error: any) {
      console.error('Error in webScraper tool with SerpApi:', error);
      throw new Error(`Web scraper failed: ${error.message}`);
    }
  }
);

export const twitterSearch = ai.defineTool(
  {
    name: 'twitterSearch',
    description: 'Searches X (formerly Twitter) for recent, relevant public tweets using a keyword query. Returns a list of tweets with author and metric details.',
    inputSchema: TwitterSearchInputSchema,
    outputSchema: TwitterSearchOutputSchema,
  },
  async (input) => {
    const bearerToken = process.env.TWITTER_BEARER_TOKEN;

    if (!bearerToken || bearerToken === 'YOUR_BEARER_TOKEN_HERE') {
      throw new Error(
        'TWITTER_BEARER_TOKEN is not configured. Please add it to your .env file.'
      );
    }

    console.log(`Performing direct X search for: ${input.query}`);

    // Search for English language, non-retweet posts, sorted by relevancy
    const searchParams = new URLSearchParams({
      'query': `${input.query} lang:en -is:retweet`,
      'tweet.fields': 'created_at,author_id,public_metrics',
      'expansions': 'author_id',
      'user.fields': 'profile_image_url,username,name',
      'max_results': '20',
      'sort_order': 'relevancy'
    });

    try {
      const response = await fetch(
        `https://api.twitter.com/2/tweets/search/recent?${searchParams}`,
        {
          method: 'GET',
          headers: {
            'Authorization': `Bearer ${bearerToken}`,
            'Content-Type': 'application/json',
          },
        }
      );

      if (!response.ok) {
        const errorBody = await response.json();
        console.error('Error from Twitter API:', errorBody);
        throw new Error(
          `Twitter API request failed with status ${response.status}`
        );
      }

      const body = await response.json();
      
      const tweetsData = body.data || [];
      const usersData = body.includes?.users || [];
      const usersById = new Map(usersData.map((user: any) => [user.id, user]));

      if (tweetsData.length === 0) {
        return [];
      }
      
      const hydratedTweets = tweetsData.map((tweet: any) => {
        const author = usersById.get(tweet.author_id);
        return {
          id: tweet.id,
          text: tweet.text,
          created_at: tweet.created_at,
          public_metrics: {
            retweet_count: tweet.public_metrics?.retweet_count || 0,
            reply_count: tweet.public_metrics?.reply_count || 0,
            like_count: tweet.public_metrics?.like_count || 0,
            impression_count: tweet.public_metrics?.impression_count || 0,
          },
          author: {
            name: author?.name || 'Unknown User',
            username: author?.username || 'unknown',
            profile_image_url: author?.profile_image_url || 
              'https://placehold.co/48x48',
          }
        };
      });

      return hydratedTweets;

    } catch (error: any) {
      console.error('Error performing Twitter search:', error);
      throw new Error(`Twitter search failed: ${error.message}`);
    }
  }
);