export default async function handler(req: VercelRequest, res: VercelResponse) {
  if (req.method !== 'POST') {
    return res.status(405).json({ error: 'Method not allowed' }); // Method check
  }

  try {
    const rawBody = await parseBody(req); // Parse body
    const body = JSON.parse(rawBody); // Convert to JSON

    if (!validateRequest(req, rawBody)) {
      return res.status(401).json({ error: 'Invalid signature' }); // Validate request
    }

    if (isPingInteraction(body)) {
      return res.json(handlePing()); // Handle ping
    }

    if (isCommand(body)) {
      const options = extractCommandOptions(body); // Extract options
      sendDeferredResponse(res, options); // Send deferred response
      const response = await processCommand(options); // Process command
      updateResponse(body, response); // Update response
    } else {
      return res.json(handleUnknownCommand()); // Unknown command
    }
  } catch (error) {
    return handleError(res, error); // Error handling
  }
}

import { createGoogleGenerativeAI } from '@ai-sdk/google';
import { groq } from '@ai-sdk/groq';
import { generateText } from 'ai';
import { log } from '../utils/log';

const systemPrompt = "..";

export interface AIResponse {
  success: boolean;
  response?: string;
  error?: string;
}

if (!process.env.GOOGLE_API_KEY) {
  throw new Error('GOOGLE_API_KEY is not set');
}

export async function generateResponse(prompt: string): Promise<AIResponse> {
  try {
    log('Generate event called');

[the code only returunt till the generate event called log]
    
    const { text } = await generateText({
      model: groq('llama-3.3-70b-versatile'),
      system: systemPrompt,
      maxTokens: 1620,
      prompt
    });

[I think error is here]

    log('Response generated: ' + text);
    
    return {
      success: true,
      response: text
    };
  } catch (error) {
    console.error('AI Service Error:', error);
    return {
      success: false,
      error: error instanceof Error ? error.message : 'Unknown error occurred'
    };
  }
}

...
export default async function handler(req: VercelRequest, res: VercelResponse) {
  if (req.method !== 'POST') {
    return res.status(405).json({ error: 'Method not allowed' });
  }

  try {
    log('Request created')
    
    const rawBody = await getRawBody(req);
    const body: DiscordInteraction = JSON.parse(rawBody.toString());

    log('Body: ' + JSON.stringify(body));

    const isValidRequest = await verifyDiscordRequest(req, rawBody.toString());
    if (!isValidRequest) {
      log('Invalid Request')
      return res.status(401).json({ error: 'Invalid request signature' });
    }

    // Handle ping
    if (body.type === InteractionType.PING) {
      log('Ping interaction received');
      return res.json({ type: InteractionResponseType.PONG });
    }...
      const { name, options = [] } = body.data || {};

      if (name === 'chat') {
        log('Command interaction created for command /chat');
...
        log('Prompt: ' + prompt);

        // Send deferred response first
        const deferredResponse: InteractionResponse = {
          type: InteractionResponseType.DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE,
          data: {
            flags: ephemeral ? 64 : 0
          }
        };

        // Send the deferred response
        await res.json(deferredResponse);
        
        log('Deferred response sent');

        try {
          log('"generateResponse" function called (external)');
          
          // Generate AI response
          const aiResponse = await generateResponse(prompt);
          
          log('Response received: ' + aiResponse);

          // Update message with AI response

          const webhookUrl = `https://discord.com/api/v10/webhooks/${process.env.DISCORD_APP_ID}/${body.token}/messages/@original`;
          
          // Add error handling and retry logic for the webhook call
          let retries = 3;
          while (retries > 0) {
            try {
              const result = await fetch(webhookUrl, {
                method: 'PATCH',
                headers: {
                  'Content-Type': 'application/json',
                  'Authorization': `Bot ${process.env.DISCORD_TOKEN}` // Add bot token for authentication
                },
                body: JSON.stringify({
                  content: aiResponse.response ?? `Error: ${aiResponse.error ?? 'Failed to generate response'}`,
                  flags: ephemeral ? 64 : 0
                }),
              });

              log(`Webhook response status: ${result.status}`);
              
              if (result.ok) {
                log('Successfully edited @original message');
                break;
              } else {
                const errorText = await result.text();
                log(`Failed to update message: ${errorText}`);
                throw new Error(`Discord API error: ${errorText}`);
              }
            } catch (error) {
              log(`Webhook attempt failed: ${error.message}`);
              retries--;
              if (retries === 0) throw error;
              await new Promise(resolve => setTimeout(resolve, 1000)); // Wait 1s between retries
            }
          }
  ...