cd apps/backend
npm install openai

OPENAI_API_KEY=sk-your-api-key-here
OPENAI_MODEL=gpt-4o-mini  # or gpt-4o, gpt-3.5-turbo

import OpenAI from 'openai';
import { MessageDTO } from '@ayw/shared';

export class OpenAIService {
  private client: OpenAI;
  private model: string;

  constructor() {
    this.client = new OpenAI({
      apiKey: process.env.OPENAI_API_KEY
    });
    this.model = process.env.OPENAI_MODEL || 'gpt-4o-mini';
  }

  async generateResponse(options: {
    botId: string;
    botName: string;
    systemPrompt: string;
    conversationHistory: MessageDTO[];
    userMessage: string;
    temperature?: number;
  }): Promise<{
    response: string;
    tokensUsed: number;
    confidence: number;
  }> {
    try {
      // Build messages array from conversation history
      const messages: OpenAI.Chat.ChatCompletionMessageParam[] = [
        { role: 'system', content: options.systemPrompt },
        ...this.convertHistoryToMessages(options.conversationHistory),
        { role: 'user', content: options.userMessage }
      ];

      const completion = await this.client.chat.completions.create({
        model: this.model,
        messages,
        temperature: options.temperature || 0.7,
        max_tokens: 500,
        top_p: 1,
        frequency_penalty: 0,
        presence_penalty: 0
      });

      const response = completion.choices[0]?.message?.content || 'I apologize, I couldn\'t generate a response.';
      const tokensUsed = completion.usage?.total_tokens || 0;

      // Calculate a simple confidence score
      const confidence = completion.choices[0]?.finish_reason === 'stop' 
        ? 0.9 
        : 0.5;

      return {
        response,
        tokensUsed,
        confidence
      };
    } catch (error: any) {
      console.error('OpenAI API error:', error);

      // Handle rate limits
      if (error?.status === 429) {
        throw new Error('RATE_LIMITED: OpenAI API rate limit exceeded. Please try again later.');
      }

      // Handle authentication errors
      if (error?.status === 401) {
        throw new Error('AUTH_ERROR: Invalid OpenAI API key.');
      }

      throw new Error(`OpenAI API error: ${error.message}`);
    }
  }

  private convertHistoryToMessages(history: MessageDTO[]): OpenAI.Chat.ChatCompletionMessageParam[] {
    return history.map(msg => ({
      role: msg.sender === 'user' ? 'user' as const : 'assistant' as const,
      content: msg.content
    }));
  }

  async generateQuickReplies(options: {
    botId: string;
    context: string;
    count?: number;
  }): Promise<string[]> {
    try {
      const completion = await this.client.chat.completions.create({
        model: this.model,
        messages: [
          {
            role: 'system',
            content: `You are a helpful assistant that generates concise quick reply options for a chatbot. Generate ${options.count || 3} short, actionable quick reply labels based on the context provided.`
          },
          {
            role: 'user',
            content: `Context: ${options.context}\n\nGenerate quick reply options as a JSON array of strings.`
          }
        ],
        temperature: 0.7,
        max_tokens: 150,
        response_format: { type: 'json_object' }
      });

      const content = completion.choices[0]?.message?.content || '[]';
      const parsed = JSON.parse(content);
      return Array.isArray(parsed) ? parsed : parsed.replies || [];
    } catch (error) {
      console.error('Error generating quick replies:', error);
      return ['Tell me more', 'Get started', 'Contact us']; // Fallback
    }
  }
}

import { OpenAIService } from './openaiService';

export class ChatbotService {
  private openai: OpenAIService;

  constructor() {
    this.openai = new OpenAIService();
  }

  async processMessage(
    conversationId: string,
    userId: string | null,
    message: string,
    context: any
  ): Promise<ChatbotProcessResponse> {
    const { botId, conversationHistory, userPreferences } = context;

    // Get bot config for system prompt
    const botConfig = await prisma.botConfig.findUnique({
      where: { botId }
    });

    if (!botConfig || !botConfig.isActive) {
      return this.getFallbackResponse();
    }

    // Use OpenAI for supported bots
    const aiPoweredBots = ['support', 'sales', 'knowledge'];

    if (aiPoweredBots.includes(botId)) {
      return this.processWithAI(botId, botConfig, conversationHistory, message);
    }

    // Keep Welcome Bot logic rule-based
    if (botId === 'welcome') {
      return this.processWelcomeBot(message);
    }

    // Default fallback
    return this.getPlaceholderResponse(botId);
  }

  private async processWithAI(
    botId: string,
    botConfig: any,
    conversationHistory: MessageDTO[],
    userMessage: string
  ): Promise<ChatbotProcessResponse> {
    try {
      // Define system prompts per bot
      const systemPrompts: Record<string, string> = {
        support: `You are a customer support bot for As You Wish (AYW). 
                  Be helpful, empathetic, and concise. 
                  If you can't solve an issue, offer to escalate to a human.
                  Available capabilities: ${botConfig.capabilities.join(', ')}`,

        sales: `You are a sales bot for As You Wish (AYW) chatbot platform.
                Help potential customers understand our offerings.
                Be persuasive but not pushy. Highlight key benefits.
                Available capabilities: ${botConfig.capabilities.join(', ')}`,

        knowledge: `You are a knowledge base bot for AYW.
                    Provide accurate information from our documentation.
                    If you don't know something, say so and suggest contacting support.
                    Available capabilities: ${botConfig.capabilities.join(', ')}`
      };

      const result = await this.openai.generateResponse({
        botId,
        botName: botConfig.name,
        systemPrompt: systemPrompts[botId] || 'You are a helpful assistant.',
        conversationHistory,
        userMessage
      });

      // Generate dynamic quick replies
      const quickReplies = await this.openai.generateQuickReplies({
        botId,
        context: userMessage,
        count: 3
      });

      return {
        botId,
        response: result.response,
        suggestedActions: quickReplies.map(label => ({ label, value: label.toLowerCase().replace(/\s+/g, '_') })),
        escalate: result.confidence < 0.5,
        sentiment: 'neutral'
      };
    } catch (error: any) {
      console.error(`AI processing error for ${botId}:`, error);

      // Fallback to rule-based response
      if (botId === 'support') {
        return this.processSupportBot(userMessage);
      }

      return {
        botId,
        response: 'I apologize, but I\'m having trouble connecting to my AI service. Let me try a different approach.',
        suggestedActions: [
          { label: 'Try Again', value: 'retry' },
          { label: 'Talk to Human', value: 'escalate' }
        ],
        escalate: true,
        sentiment: 'negative'
      };
    }
  }
}

model TokenUsage {
  id             String   @id @default(uuid())
  conversationId String   @map("conversation_id")
  botId          String   @map("bot_id")
  tokensUsed     Int      @map("tokens_used")
  model          String
  createdAt      DateTime @default(now()) @map("created_at")

  @@map("token_usage")
}

cd apps/backend
npx prisma migrate dev --name add_token_usage

import { PrismaClient } from '@prisma/client';

const prisma = new PrismaClient();

// Inside generateResponse method, after getting completion:
await prisma.tokenUsage.create({
  data: {
    conversationId: options.conversationId, // You'll need to pass this
    botId: options.botId,
    tokensUsed: tokensUsed,
    model: this.model
  }
});

# Set your token
export ACCESS_TOKEN="your_access_token"

# Send a message to the Support Bot
curl -X POST http://localhost:4000/api/conversations \
  -H "Authorization: Bearer $ACCESS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "botId": "support",
    "initialMessage": "How do I reset my password?"
  }'

SELECT 
  bot_id,
  model,
  SUM(tokens_used) as total_tokens,
  COUNT(*) as request_count
FROM token_usage
GROUP BY bot_id, model
ORDER BY total_tokens DESC;

// Only use last 10 messages for context
const recentHistory = conversationHistory.slice(-10);

// In chatbotService.ts
private async processWithAI(...) {
  try {
    // ... OpenAI call
  } catch (error: any) {
    if (error.message.includes('RATE_LIMITED')) {
      // Wait and retry (exponential backoff)
      await new Promise(resolve => setTimeout(resolve, 2000));
      return this.processWithAI(botId, botConfig, conversationHistory, userMessage);
    }

    // Other errors fall back to rule-based
    return this.getFallbackResponse();
  }
}

class CircuitBreaker {
  private failures = 0;
  private lastFailureTime = 0;
  private state: 'closed' | 'open' | 'half-open' = 'closed';

  async call(fn: () => Promise<any>) {
    if (this.state === 'open') {
      if (Date.now() - this.lastFailureTime > 60000) {
        this.state = 'half-open';
      } else {
        throw new Error('Circuit breaker is open');
      }
    }

    try {
      const result = await fn();
      this.onSuccess();
      return result;
    } catch (error) {
      this.onFailure();
      throw error;
    }
  }

  private onSuccess() {
    this.failures = 0;
    this.state = 'closed';
  }

  private onFailure() {
    this.failures++;
    this.lastFailureTime = Date.now();
    if (this.failures >= 5) {
      this.state = 'open';
    }
  }
}