tuna/AIService.ts at ec8342b5e2a001616803633fe3d6dc0b13be4841

 import axios from 'axios';
 import { ChatbotService } from './ChatbotService.js';
 export interface ChatMessage {
   role: 'system' | 'user' | 'assistant';
   content: string;
 }
 export interface ChatRequest {
   model: string;
   messages: ChatMessage[];
   temperature: number;
 }
 export interface ChatChoice {
   message: ChatMessage;
 }
 export interface ChatResponse {
   choices: ChatChoice[];
 }
 export class AIService {
   private apiKey: string;
   private model: string;
   private baseUrl: string;
   private relPath: string;
   private temperature: number;
   private chatbotService: ChatbotService;
   // Predefined models from your C# code
   private static readonly PREDEFINED_MODELS: Record<string, string> = {
     'dobby': 'sentientagi/dobby-mini-unhinged-plus-llama-3.1-8b',
     'dolphin': 'cognitivecomputations/dolphin-mixtral-8x22b',
     'dolphin_free': 'cognitivecomputations/dolphin3.0-mistral-24b:free',
     'gemma': 'google/gemma-3-12b-it',
     'gpt-4o-mini': 'openai/gpt-4o-mini',
     'gpt-4.1-nano': 'openai/gpt-4.1-nano',
     'qwen': 'qwen/qwen3-30b-a3b',
     'unslop': 'thedrummer/unslopnemo-12b',
     'euryale': 'sao10k/l3.3-euryale-70b',
     'wizard': 'microsoft/wizardlm-2-8x22b',
     'deepseek': 'deepseek/deepseek-chat-v3-0324'
   };
   constructor() {
     this.apiKey = process.env.OPENROUTER_API_KEY || 'sk-or-REPLACE_ME';
     this.model = process.env.OPENROUTER_MODEL || 'gemma';
     this.baseUrl = process.env.OPENROUTER_BASE_URL || 'openrouter.ai';
     this.relPath = process.env.OPENROUTER_REL_PATH || '/api';
     this.temperature = parseFloat(process.env.OPENROUTER_TEMPERATURE || '0.7');
     this.chatbotService = new ChatbotService();
     // Map predefined model names to full model names
     if (AIService.PREDEFINED_MODELS[this.model]) {
       this.model = AIService.PREDEFINED_MODELS[this.model];
     }
     console.log(`[DEBUG] AIService initialized:`);
     console.log(`[DEBUG] - API Key: ${this.apiKey.substring(0, 10)}...`);
     console.log(`[DEBUG] - Model: ${this.model}`);
     console.log(`[DEBUG] - Base URL: ${this.baseUrl}`);
     console.log(`[DEBUG] - Rel Path: ${this.relPath}`);
     console.log(`[DEBUG] - Temperature: ${this.temperature}`);
     console.log(`[DEBUG] - Chatbot Service: ${this.chatbotService ? 'Enabled' : 'Disabled'}`);
   }
   async generateResponse(prompt: string, systemMessage?: string): Promise<string | null> {
     try {
       const messages: ChatMessage[] = [];
       if (systemMessage) {
         messages.push({ role: 'system', content: systemMessage });
       }
       messages.push({ role: 'user', content: prompt });
       const payload: ChatRequest = {
         model: this.model,
         messages: messages,
         temperature: this.temperature
       };
       const url = `https://${this.baseUrl}${this.relPath}/v1/chat/completions`;
       console.log(`[DEBUG] Sending to OpenRouter - Model: ${this.model}, URL: ${url}`);
       console.log(`[DEBUG] Prompt length: ${prompt.length} characters`);
       const response = await axios.post(url, payload, {
         headers: {
           'Authorization': `Bearer ${this.apiKey}`,
           'Content-Type': 'application/json'
         }
       });
       const data = response.data as ChatResponse;
       const aiResponse = data.choices?.[0]?.message?.content || null;
       console.log(`[DEBUG] OpenRouter Response: ${aiResponse}`);
       return aiResponse;
     } catch (error) {
       console.error('Error calling OpenRouter:', error);
       if (error.response) {
         console.error('Response status:', error.response.status);
         console.error('Response data:', error.response.data);
       }
       return null;
     }
   }
   async generateResponseWithHistory(
     userMessage: string,
     conversationHistory: any[],
     systemMessage?: string
   ): Promise<string | null> {
     try {
       const messages: ChatMessage[] = [];
       if (systemMessage) {
         messages.push({ role: 'system', content: systemMessage });
       }
       // Add conversation history
       conversationHistory.forEach(msg => {
         if (msg.sender === 'candidate' || msg.sender === 'user') {
           messages.push({ role: 'user', content: msg.message });
         } else if (msg.sender === 'ai' || msg.sender === 'assistant') {
           messages.push({ role: 'assistant', content: msg.message });
         }
       });
       // Add current user message
       messages.push({ role: 'user', content: userMessage });
       const payload: ChatRequest = {
         model: this.model,
         messages: messages,
         temperature: this.temperature
       };
       const url = `https://${this.baseUrl}${this.relPath}/v1/chat/completions`;
       console.log(`[DEBUG] Sending to OpenRouter with history - Model: ${this.model}`);
       console.log(`[DEBUG] Messages count: ${messages.length}`);
       const response = await axios.post(url, payload, {
         headers: {
           'Authorization': `Bearer ${this.apiKey}`,
           'Content-Type': 'application/json'
         }
       });
       const data = response.data as ChatResponse;
       const aiResponse = data.choices?.[0]?.message?.content || null;
       console.log(`[DEBUG] OpenRouter Response: ${aiResponse}`);
       return aiResponse;
     } catch (error) {
       console.error('Error calling OpenRouter with history:', error);
       if (error.response) {
         console.error('Response status:', error.response.status);
         console.error('Response data:', error.response.data);
       }
       return null;
     }
   }
   /**
    * Generate response using chatbot service with fallback to direct OpenRouter
    */
   async generateResponseWithChatbot(
     userMessage: string,
     conversationHistory: any[],
     systemMessage?: string,
     job?: any,
     candidateName?: string,
     linkId?: string
   ): Promise<string | null> {
     // Try chatbot service first
     try {
       const isHealthy = await this.chatbotService.isHealthy();
       if (isHealthy) {
         console.log(`[DEBUG] Using chatbot service for response generation`);
         const response = await this.chatbotService.sendMessage({
           message: userMessage,
           conversationHistory,
           systemMessage,
           job,
           candidateName,
           linkId
         });
         if (response) {
           return response;
         }
       }
     } catch (error) {
       console.error('[ERROR] Chatbot service failed, falling back to direct OpenRouter:', error);
     }
     // Fallback to direct OpenRouter
     if (this.chatbotService.shouldUseFallback()) {
       console.log(`[DEBUG] Falling back to direct OpenRouter`);
       return await this.generateResponseWithHistory(userMessage, conversationHistory, systemMessage);
     }
     return null;
   }
   /**
    * Initialize interview using chatbot service
    */
   async initializeInterviewWithChatbot(
     job: any,
     candidateName: string,
     linkId: string,
     conversationHistory: any[] = []
   ): Promise<string | null> {
     try {
       const isHealthy = await this.chatbotService.isHealthy();
       if (isHealthy) {
         console.log(`[DEBUG] Using chatbot service for interview initialization`);
         return await this.chatbotService.initializeInterview(job, candidateName, linkId, conversationHistory);
       }
     } catch (error) {
       console.error('[ERROR] Chatbot service failed for interview initialization:', error);
     }
     // Fallback to direct OpenRouter
     if (this.chatbotService.shouldUseFallback()) {
       console.log(`[DEBUG] Falling back to direct OpenRouter for interview initialization`);
       const systemMessage = this.buildInterviewSystemMessage(job, candidateName, conversationHistory);
       return await this.generateResponse(`The candidate's name is ${candidateName}. Please start the interview.`, systemMessage);
     }
     return null;
   }
   /**
    * End interview using chatbot service
    */
   async endInterviewWithChatbot(linkId: string): Promise<boolean> {
     try {
       const isHealthy = await this.chatbotService.isHealthy();
       if (isHealthy) {
         console.log(`[DEBUG] Using chatbot service for interview end`);
         return await this.chatbotService.endInterview(linkId);
       }
     } catch (error) {
       console.error('[ERROR] Chatbot service failed for interview end:', error);
     }
     return false;
   }
   /**
    * Build interview system message
    */
   private buildInterviewSystemMessage(job: any, candidateName: string, conversationHistory: any[] = []): string {
     const skills = job.skills_required ? job.skills_required.join(', ') : 'various technical skills';
     const experience = job.experience_level.replace('_', ' ');
     // Build context from conversation history (mandatory question answers)
     const conversationContext = conversationHistory
       .map(msg => `${msg.sender === 'candidate' ? 'Candidate' : 'Interviewer'}: ${msg.message}`)
       .join('\n');
     return `You are an AI interview agent conducting an interview for the position: ${job.title}
 Job Description: ${job.description}
 Requirements: ${job.requirements}
 Required Skills: ${skills}
 Experience Level: ${experience}
 Location: ${job.location || 'Remote'}
 ${conversationContext ? `Previous conversation (mandatory questions answered):
 ${conversationContext}
 Based on the candidate's answers to the mandatory questions above, you should now conduct a deeper interview.` : ''}
 Your task is to:
 . Greet the candidate warmly and professionally
 . Introduce yourself as their evaluation agent
 . ${conversationContext ? 'Acknowledge their previous answers and build upon them' : 'Explain that you\'ll be conducting a comprehensive interview'}
 . Ask them to tell you about themselves and their interest in this role
 . Keep your response conversational and engaging
 . Don't ask multiple questions at once - start with one open-ended question
 Respond in a friendly, professional tone. Keep it concise but welcoming.`;
   }
 }