kekbot.js/utils/ai.js

// ai.js - NanoGPT API wrapper for kekbot with fallback and web search tools
// Copyright (C) 2025  Luis Bauza

import axios from 'axios';

const DEFAULT_MODEL = 'GLM-4.5-Air-Derestricted';
const FALLBACK_MODEL = 'GLM-4.7-Flash';
const FALLBACK_API_URL = 'https://api.z.ai/api/coding/paas/v4/chat/completions';

// Brave Search API
const BRAVE_API_URL = 'https://api.search.brave.com/res/v1/web/search';

async function performBraveSearch(query, count = 10) {
  const response = await axios.get(BRAVE_API_URL, {
    params: {
      q: query,
      count: count,
      extra_snippets: true
    },
    headers: {
      'X-Subscription-Token': process.env.BRAVE_API_KEY,
      'Accept': 'application/json'
    },
    timeout: 15000
  });
  
  const results = response.data.web?.results || [];
  
  if (results.length === 0) {
    return 'No search results found.';
  }
  
  let formatted = 'Search results:\n\n';
  results.slice(0, 8).forEach((result, i) => {
    formatted += `${i + 1}. ${result.title}\n`;
    formatted += `   ${result.url}\n`;
    if (result.description) {
      formatted += `   ${result.description.substring(0, 200)}${result.description.length > 200 ? '...' : ''}\n`;
    }
    if (result.extra_snippets && result.extra_snippets.length > 0) {
      formatted += `   ${result.extra_snippets[0].substring(0, 150)}...\n`;
    }
    formatted += '\n';
  });
  
  return formatted;
}

// Tool definitions for function calling
const WEB_SEARCH_TOOL = {
  type: 'function',
  function: {
    name: 'web_search',
    description: 'Search the web for current information. Use this when you need up-to-date facts, news, or information that may have changed recently.',
    parameters: {
      type: 'object',
      properties: {
        query: {
          type: 'string',
          description: 'The search query to find relevant web results.'
        }
      },
      required: ['query']
    }
  }
};

const SASSY_SYSTEM_PROMPT = `You are kekbot, a sassy Discord chatter with a big personality.

CURRENT DATE: March 9, 2026

CORE PERSONALITY:
- Witty, sarcastic, and genuinely funny
- Speaks in all lowercase with casual slang like "lol", "lmao", "af", "kek", "nah", "frfr"
- Mix up your sentences - don't repeat the same pattern
- Gets excited about things you like, roasted about things you hate
- You're not a pushover - you clap back, but it's all in good fun
- NO EMOJI. Ever. Not one. Don't do it.

OPINIONS:
- You're a true gamer with strong opinions about games
- You hate League of Legends and Riot Games with a passion - but only bring it up when asked
- When asked about other games, respond normally without mentioning LoL
- You have views on politics and aren't afraid to share them from a Democrat/Libertarian perspective

STYLE:
- Curse naturally when it fits ("fuck", "shit", "damn", etc)
- Be conversational - like you're chilling in a Discord VC, not writing an essay
- Don't be preachy or explain jokes
- Keep responses short to medium - Discord isn't a thesis paper
- Roast people gently when they deserve it, praise them when they earn it

RESPONSE RULES:
- When mentioned, respond directly to the person
- If someone asks something stupid, make them feel silly but still answer
- Don't use markdown formatting excessively - plain text with personality
- You can disagree with the user, you're not a yes-man
- Stay in character always
- Use the web_search tool when you need current information

CONTEXT: You're chatting in a Discord server. Multiple people might be talking. Pay attention to who you're responding to.`;

// Store recent conversation history per channel (to keep context)
const conversationHistory = new Map();
const MAX_HISTORY_PER_CHANNEL = 10;

function buildMessages(history, prompt, mentionedUsername, systemPrompt) {
  const messages = [
    { role: 'system', content: systemPrompt },
    ...history,
    {
      role: 'user',
      content: mentionedUsername
        ? `${mentionedUsername}: ${prompt}`
        : prompt
    }
  ];
  return messages;
}

// Primary: Brave Search
async function webSearchWithBrave(query) {
  console.log('Using Brave Search for:', query);
  return await performBraveSearch(query);
}

// Fallback: NanoGPT web search
async function webSearchWithNanoGPT(query) {
  console.log('Using NanoGPT web search for:', query);
  const response = await axios.post(
    'https://nano-gpt.com/api/web',
    {
      query: query,
      provider: 'linkup',
      depth: 'standard',
      outputType: 'sourcedAnswer'
    },
    {
      headers: {
        Authorization: `Bearer ${process.env.NANOGPT_API_KEY}`,
        'Content-Type': 'application/json',
      },
      timeout: 60000,
    }
  );
  
  const data = response.data.data;
  
  if (typeof data === 'string') {
    return data;
  } else if (data.answer) {
    let result = data.answer;
    if (data.sources && data.sources.length > 0) {
      result += '\n\nSources:\n';
      data.sources.forEach((source, i) => {
        result += `${i + 1}. ${source.name || source.url}\n`;
      });
    }
    return result;
  } else if (data.results) {
    let result = 'Search results:\n';
    data.results.slice(0, 8).forEach((r, i) => {
      result += `${i + 1}. ${r.title || r.name}\n`;
      if (r.url) result += `   ${r.url}\n`;
      if (r.content) result += `   ${r.content.substring(0, 200)}...\n`;
    });
    return result;
  }
  
  return 'Could not parse search results.';
}

// Unified web search function (Brave first, NanoGPT fallback)
async function performWebSearch(query) {
  // Try Brave first if API key is available
  if (process.env.BRAVE_API_KEY) {
    try {
      return await webSearchWithBrave(query);
    } catch (error) {
      console.error('Brave Search failed:', error.message);
    }
  }
  
  // Fallback to NanoGPT
  if (process.env.NANOGPT_API_KEY) {
    try {
      return await webSearchWithNanoGPT(query);
    } catch (error) {
      console.error('NanoGPT search failed:', error.message);
    }
  }
  
  throw new Error('No web search provider available');
}

async function callNanoGPTWithTools(messages, model, maxRetries = 2) {
  let lastError;
  
  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      const response = await axios.post(
        'https://nano-gpt.com/api/v1/chat/completions',
        {
          model: model,
          messages: messages,
          tools: [WEB_SEARCH_TOOL],
          temperature: 0.8,
          max_tokens: 800,
        },
        {
          headers: {
            Authorization: `Bearer ${process.env.NANOGPT_API_KEY}`,
            'Content-Type': 'application/json',
          },
          timeout: 90000,
        }
      );
      
      const choice = response.data.choices[0];
      const message = choice.message;
      
      // Check if AI wants to call a tool
      if (message.tool_calls && message.tool_calls.length > 0) {
        for (const toolCall of message.tool_calls) {
          if (toolCall.function.name === 'web_search') {
            const args = JSON.parse(toolCall.function.arguments);
            console.log('AI requested web search for:', args.query);
            
            // Perform the search (Brave primary, NanoGPT fallback)
            const searchResult = await performWebSearch(args.query);
            
            // Add tool result to messages and continue
            messages.push(message);
            messages.push({
              role: 'tool',
              tool_call_id: toolCall.id,
              content: searchResult
            });
            
            // Get final response with search results
            const finalResponse = await axios.post(
              'https://nano-gpt.com/api/v1/chat/completions',
              {
                model: model,
                messages: messages,
                temperature: 0.8,
                max_tokens: 800,
              },
              {
                headers: {
                  Authorization: `Bearer ${process.env.NANOGPT_API_KEY}`,
                  'Content-Type': 'application/json',
                },
                timeout: 90000,
              }
            );
            
            return finalResponse.data.choices[0].message.content;
          }
        }
      }
      
      // No tool calls, return direct response
      return message.content;
      
    } catch (error) {
      lastError = error;
      console.error(`NanoGPT attempt ${attempt + 1} failed:`, error.message);
      
      if (attempt < maxRetries) {
        await new Promise(resolve => setTimeout(resolve, 1000 * (attempt + 1)));
      }
    }
  }
  throw lastError;
}

async function callFallbackAPI(messages) {
  const response = await axios.post(
    FALLBACK_API_URL,
    {
      model: FALLBACK_MODEL,
      messages: messages,
      temperature: 0.8,
      max_tokens: 500,
    },
    {
      headers: {
        Authorization: `Bearer ${process.env.ZAI_API_KEY}`,
        'Content-Type': 'application/json',
      },
      timeout: 60000,
    }
  );
  return response.data.choices[0].message.content;
}

export async function getAIResponse(prompt, channelId, mentionedUsername) {
  const history = conversationHistory.get(channelId) || [];
  const messages = buildMessages(history, prompt, mentionedUsername, SASSY_SYSTEM_PROMPT);
  const model = process.env.NANO_MODEL || DEFAULT_MODEL;

  // Try NanoGPT first (with tool calling)
  if (process.env.NANOGPT_API_KEY) {
    try {
      console.log('Attempting NanoGPT with tool calling...');
      const aiResponse = await callNanoGPTWithTools(messages, model);
      
      // Update history on success
      const newHistory = [
        ...history,
        { role: 'user', content: prompt },
        { role: 'assistant', content: aiResponse }
      ];

      if (newHistory.length > MAX_HISTORY_PER_CHANNEL) {
        newHistory.splice(0, newHistory.length - MAX_HISTORY_PER_CHANNEL);
      }
      conversationHistory.set(channelId, newHistory);

      return aiResponse;
    } catch (error) {
      console.error('NanoGPT failed:', error.response?.data || error.message);
    }
  }

  // Fallback to z.ai if NanoGPT failed or not configured
  if (process.env.ZAI_API_KEY) {
    try {
      console.log('Attempting fallback (z.ai)...');
      const aiResponse = await callFallbackAPI(messages);
      
      // Update history on success
      const newHistory = [
        ...history,
        { role: 'user', content: prompt },
        { role: 'assistant', content: aiResponse }
      ];

      if (newHistory.length > MAX_HISTORY_PER_CHANNEL) {
        newHistory.splice(0, newHistory.length - MAX_HISTORY_PER_CHANNEL);
      }
      conversationHistory.set(channelId, newHistory);

      return aiResponse;
    } catch (fallbackError) {
      console.error('Fallback API also failed:', fallbackError.response?.data || fallbackError.message);
      throw new Error('All AI providers failed');
    }
  }

  throw new Error('No AI provider configured');
}

export function clearHistory(channelId) {
  conversationHistory.delete(channelId);
}

export function isAIEnabled() {
  return !!process.env.NANOGPT_API_KEY || !!process.env.ZAI_API_KEY;
}