@loxia-labs/loxia-autopilot-one 1.0.1

package/src/services/aiService.js

@@ -0,0 +1,1232 @@
+/**
+ * AIService - Manages communication with Azure backend API, model routing, rate limiting
+ * 
+ * Purpose:
+ * - Backend API communication
+ * - Model selection and routing
+ * - Rate limiting enforcement
+ * - Conversation compactization
+ * - Token usage tracking
+ * - Request/response transformation
+ */
+
+import {
+  MODELS,
+  MODEL_PROVIDERS,
+  MODEL_ROUTING,
+  HTTP_STATUS,
+  ERROR_TYPES,
+  SYSTEM_DEFAULTS
+} from '../utilities/constants.js';
+
+class AIService {
+  constructor(config, logger, budgetService, errorHandler) {
+    this.config = config;
+    this.logger = logger;
+    this.budgetService = budgetService;
+    this.errorHandler = errorHandler;
+    
+    this.baseUrl = config.backend?.baseUrl || 'https://api.loxia.ai';
+    this.timeout = config.backend?.timeout || 60000;
+    this.retryAttempts = config.backend?.retryAttempts || 3;
+    
+    // Rate limiting
+    this.rateLimiters = new Map();
+    this.requestQueue = new Map();
+    
+    // Circuit breaker
+    this.circuitBreaker = {
+      failures: 0,
+      lastFailureTime: null,
+      isOpen: false,
+      threshold: 5,
+      timeout: 30000 // 30 seconds
+    };
+    
+    // Model specifications
+    this.modelSpecs = this._initializeModelSpecs();
+    
+    // Conversation managers for multi-model support
+    this.conversationManagers = new Map();
+    
+    // API Key Manager reference (will be set by LoxiaSystem)
+    this.apiKeyManager = null;
+    
+    // Agent Pool reference (will be set by LoxiaSystem)
+    this.agentPool = null;
+  }
+
+  /**
+   * Send message to backend API
+   * @param {string} model - Target model name
+   * @param {string|Array} messages - Message content or conversation history
+   * @param {Object} options - Additional options (agentId, systemPrompt, etc.)
+   * @returns {Promise<Object>} API response with content and metadata
+   */
+  async sendMessage(model, messages, options = {}) {
+    const requestId = `req-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    
+    try {
+      // Check circuit breaker
+      if (this._isCircuitBreakerOpen()) {
+        throw new Error('Service temporarily unavailable - circuit breaker is open');
+      }
+      
+      // Skip local model validation - let Azure backend handle it
+      
+      // Check rate limits
+      await this._checkRateLimit(model);
+      
+      // Format messages for specific model
+      const formattedMessages = this._formatMessagesForModel(messages, model, options);
+      
+      // Prepare request payload
+      const payload = {
+        model, // Use original model name - let Azure backend handle it
+        messages: formattedMessages,
+        options: {
+          max_tokens: this.modelSpecs[model]?.maxTokens || 4000,
+          temperature: options.temperature || 0.7,
+          stream: options.stream || false
+        },
+        metadata: {
+          requestId,
+          agentId: options.agentId,
+          timestamp: new Date().toISOString()
+        }
+      };
+      
+      // Add system prompt if provided
+      if (options.systemPrompt) {
+        payload.system = options.systemPrompt;
+      }
+      
+      this.logger.info(`Sending message to model: ${model}`, {
+        requestId,
+        agentId: options.agentId,
+        messageCount: Array.isArray(messages) ? messages.length : 1,
+        maxTokens: payload.max_tokens
+      });
+      
+      // Make API request
+      const response = await this._makeAPIRequest('/chat/completions', payload, requestId, {
+        ...options,
+        sessionId: options.sessionId, // Pass session ID for API key retrieval
+        platformProvided: options.platformProvided || false
+      });
+      
+      // Track usage
+      if (response.usage) {
+        await this.trackUsage(options.agentId, model, {
+          prompt_tokens: response.usage.prompt_tokens || 0,
+          completion_tokens: response.usage.completion_tokens || 0,
+          total_tokens: response.usage.total_tokens || 0
+        });
+      }
+      
+      // Reset circuit breaker on success
+      this._resetCircuitBreaker();
+      
+      return {
+        content: response.choices[0]?.message?.content || '',
+        model: response.model,
+        tokenUsage: response.usage,
+        requestId,
+        finishReason: response.choices[0]?.finish_reason
+      };
+      
+    } catch (error) {
+      // Handle circuit breaker
+      this._recordFailure();
+      
+      this.logger.error(`AI service request failed: ${error.message}`, {
+        requestId,
+        model,
+        agentId: options.agentId,
+        error: error.stack
+      });
+      
+      // Handle specific error types
+      await this.handleHttpError(error, { requestId, model, agentId: options.agentId });
+      
+      throw error;
+    }
+  }
+
+  /**
+   * Route model selection based on task and context
+   * @param {string} task - Task type (coding, analysis, quick-tasks, creative)
+   * @param {Object} context - Additional context for routing
+   * @returns {Promise<string>} Selected model name
+   */
+  async routeModel(task, context = {}) {
+    try {
+      // Get available models for task
+      const availableModels = MODEL_ROUTING[task.toUpperCase()] || MODEL_ROUTING.FALLBACK;
+      
+      // Check model availability and health
+      const healthyModels = [];
+      for (const model of availableModels) {
+        const isHealthy = await this._checkModelHealth(model);
+        if (isHealthy) {
+          healthyModels.push(model);
+        }
+      }
+      
+      if (healthyModels.length === 0) {
+        this.logger.warn(`No healthy models available for task: ${task}, using fallback`);
+        return MODEL_ROUTING.FALLBACK[0];
+      }
+      
+      // Select model based on context
+      let selectedModel = healthyModels[0]; // Default to first healthy model
+      
+      // Prefer model based on context
+      if (context.preferredModel && healthyModels.includes(context.preferredModel)) {
+        selectedModel = context.preferredModel;
+      } else if (context.complexity === 'high' && healthyModels.includes(MODELS.ANTHROPIC_OPUS)) {
+        selectedModel = MODELS.ANTHROPIC_OPUS;
+      } else if (context.speed === 'fast' && healthyModels.includes(MODELS.ANTHROPIC_HAIKU)) {
+        selectedModel = MODELS.ANTHROPIC_HAIKU;
+      }
+      
+      this.logger.info(`Model routed for task: ${task}`, {
+        selectedModel,
+        availableModels: healthyModels.length,
+        context
+      });
+      
+      return selectedModel;
+      
+    } catch (error) {
+      this.logger.error(`Model routing failed: ${error.message}`, { task, context });
+      return MODEL_ROUTING.FALLBACK[0];
+    }
+  }
+
+  /**
+   * Compactize conversation for specific model context window
+   * @param {Array} messages - Message history
+   * @param {string} targetModel - Target model name
+   * @returns {Promise<Array>} Compactized messages
+   */
+  async compactizeConversation(messages, targetModel) {
+    const modelSpec = this.modelSpecs[targetModel];
+    if (!modelSpec) {
+      throw new Error(`Unknown model: ${targetModel}`);
+    }
+    
+    const maxTokens = modelSpec.contextWindow * 0.8; // Use 80% of context window
+    let currentTokens = 0;
+    const compactizedMessages = [];
+    
+    // Estimate tokens for each message
+    const messagesWithTokens = await Promise.all(
+      messages.map(async (msg) => ({
+        ...msg,
+        estimatedTokens: await this._estimateTokens(msg.content, targetModel)
+      }))
+    );
+    
+    // Start from the most recent messages
+    const reversedMessages = [...messagesWithTokens].reverse();
+    
+    for (const message of reversedMessages) {
+      if (currentTokens + message.estimatedTokens > maxTokens) {
+        // If we've exceeded the limit, summarize older messages
+        if (compactizedMessages.length === 0) {
+          // If even the latest message is too long, truncate it
+          const truncatedContent = await this._truncateMessage(message.content, maxTokens);
+          compactizedMessages.unshift({
+            ...message,
+            content: truncatedContent,
+            estimatedTokens: maxTokens
+          });
+        }
+        break;
+      }
+      
+      compactizedMessages.unshift(message);
+      currentTokens += message.estimatedTokens;
+    }
+    
+    // If we have remaining older messages, create a summary
+    const remainingMessages = messagesWithTokens.slice(0, -compactizedMessages.length);
+    if (remainingMessages.length > 0) {
+      const summary = await this._summarizeMessages(remainingMessages, targetModel);
+      compactizedMessages.unshift({
+        role: 'system',
+        content: `Previous conversation summary: ${summary}`,
+        timestamp: remainingMessages[0].timestamp,
+        type: 'summary',
+        estimatedTokens: await this._estimateTokens(summary, targetModel)
+      });
+    }
+    
+    this.logger.info(`Conversation compactized for model: ${targetModel}`, {
+      originalMessages: messages.length,
+      compactizedMessages: compactizedMessages.length,
+      estimatedTokens: currentTokens,
+      maxTokens
+    });
+    
+    return compactizedMessages;
+  }
+
+  /**
+   * Track token usage and costs
+   * @param {number} tokens - Number of tokens used
+   * @param {number} cost - Cost in dollars
+   * @returns {Promise<void>}
+   */
+  async trackUsage(agentId, model, tokenUsage, cost) {
+    try {
+      if (this.budgetService) {
+        this.budgetService.trackUsage(agentId, model, tokenUsage);
+      }
+    } catch (error) {
+      this.logger.error(`Usage tracking failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Handle HTTP errors with comprehensive error handling
+   * @param {Error} error - Error object
+   * @param {Object} context - Request context
+   * @returns {Promise<void>}
+   */
+  async handleHttpError(error, context) {
+    const errorType = this.errorHandler?.classifyError?.(error, context);
+    
+    switch (error.status || error.code) {
+      case HTTP_STATUS.BAD_REQUEST:
+        this.logger.error('Bad request to AI service', { context, error: error.message });
+        throw new Error(`Invalid request: ${error.message}`);
+        
+      case HTTP_STATUS.UNAUTHORIZED:
+        this.logger.error('Authentication failed with AI service', { context });
+        throw new Error('Authentication failed - check API credentials');
+        
+      case HTTP_STATUS.FORBIDDEN:
+        this.logger.error('Access forbidden to AI service', { context });
+        throw new Error('Access forbidden - insufficient permissions');
+        
+      case HTTP_STATUS.NOT_FOUND:
+        this.logger.error('AI service endpoint not found', { context });
+        throw new Error('Service endpoint not found');
+        
+      case HTTP_STATUS.TOO_MANY_REQUESTS:
+        this.logger.warn('Rate limit exceeded', { context });
+        await this._handleRateLimit(context);
+        throw new Error('Rate limit exceeded - request queued for retry');
+        
+      case HTTP_STATUS.INTERNAL_SERVER_ERROR:
+      case HTTP_STATUS.BAD_GATEWAY:
+      case HTTP_STATUS.SERVICE_UNAVAILABLE:
+      case HTTP_STATUS.GATEWAY_TIMEOUT:
+        this.logger.error('AI service unavailable', { context, status: error.status });
+        await this._handleServiceUnavailable(context);
+        throw new Error('AI service temporarily unavailable');
+        
+      default:
+        this.logger.error('Unknown AI service error', { context, error: error.message });
+        throw new Error(`AI service error: ${error.message}`);
+    }
+  }
+
+  /**
+   * Set API key manager instance
+   * @param {ApiKeyManager} apiKeyManager - API key manager instance
+   */
+  setApiKeyManager(apiKeyManager) {
+    this.apiKeyManager = apiKeyManager;
+    
+    this.logger?.info('API key manager set for AI service', {
+      hasManager: !!apiKeyManager
+    });
+  }
+
+  /**
+   * Set agent pool reference
+   * @param {Object} agentPool - Agent pool instance
+   */
+  setAgentPool(agentPool) {
+    this.agentPool = agentPool;
+    
+    this.logger?.info('Agent pool set for AI service', {
+      hasAgentPool: !!agentPool
+    });
+  }
+
+  /**
+   * Generate image from text prompt using AI models
+   * @param {string} prompt - Text description of the image to generate
+   * @param {Object} options - Generation options
+   * @param {string} options.model - Model to use (e.g., 'flux-1.1-pro', 'dall-e-3')
+   * @param {string} options.size - Image size (e.g., '1024x1024', '512x512')
+   * @param {string} options.quality - Image quality ('standard' or 'hd')
+   * @param {string} options.responseFormat - Response format ('url' or 'b64_json')
+   * @param {string} options.sessionId - Session ID for API key retrieval
+   * @param {boolean} options.platformProvided - Whether to use platform model
+   * @returns {Promise<Object>} Generated image result with URL or base64 data
+   */
+  async generateImage(prompt, options = {}) {
+    const requestId = `img-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+
+    try {
+      // Check circuit breaker
+      if (this._isCircuitBreakerOpen()) {
+        throw new Error('Service temporarily unavailable - circuit breaker is open');
+      }
+
+      // Validate prompt
+      if (!prompt || typeof prompt !== 'string' || prompt.trim().length === 0) {
+        throw new Error('Image generation requires a non-empty text prompt');
+      }
+
+      // Default options
+      const model = options.model || 'flux-1.1-pro';
+      const size = options.size || '1024x1024';
+      const quality = options.quality || 'standard';
+      const responseFormat = options.responseFormat || 'url';
+
+      this.logger.info(`Generating image with model: ${model}`, {
+        requestId,
+        model,
+        size,
+        quality,
+        promptLength: prompt.length
+      });
+
+      // Prepare request payload
+      const payload = {
+        prompt,
+        model,
+        size,
+        quality,
+        response_format: responseFormat,
+        n: 1, // Generate 1 image
+        metadata: {
+          requestId,
+          timestamp: new Date().toISOString()
+        }
+      };
+
+      // Make API request to image generation endpoint
+      const response = await this._makeImageAPIRequest(payload, requestId, {
+        sessionId: options.sessionId,
+        platformProvided: options.platformProvided || false
+      });
+
+      // Reset circuit breaker on success
+      this._resetCircuitBreaker();
+
+      return {
+        url: response.data?.[0]?.url || null,
+        b64_json: response.data?.[0]?.b64_json || null,
+        model: response.model || model,
+        requestId,
+        revisedPrompt: response.data?.[0]?.revised_prompt || prompt
+      };
+
+    } catch (error) {
+      // Handle circuit breaker
+      this._recordFailure();
+
+      this.logger.error(`Image generation failed: ${error.message}`, {
+        requestId,
+        model: options.model,
+        error: error.stack
+      });
+
+      throw error;
+    }
+  }
+
+  /**
+   * Check service health for circuit breaker
+   * @returns {Promise<boolean>} Service health status
+   */
+  async checkServiceHealth() {
+    try {
+      const response = await this._makeAPIRequest('/health', {}, 'health-check');
+      return response.status === 'healthy';
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Switch agent to different model
+   * @param {string} agentId - Agent identifier
+   * @param {string} newModel - New model name
+   * @returns {Promise<Object>} Switch result
+   */
+  async switchAgentModel(agentId, newModel) {
+    try {
+      if (!this._isValidModel(newModel)) {
+        throw new Error(`Invalid model: ${newModel}`);
+      }
+      
+      // Get conversation manager for agent
+      let conversationManager = this.conversationManagers.get(agentId);
+      if (!conversationManager) {
+        // Create new conversation manager if it doesn't exist
+        conversationManager = new ConversationManager(agentId, this.logger);
+        this.conversationManagers.set(agentId, conversationManager);
+      }
+      
+      // Switch model and return conversation
+      const modelConversation = await conversationManager.switchModel(newModel);
+      
+      // CRITICAL FIX: Update agent's currentModel field in AgentPool
+      const agent = await this.agentPool?.getAgent(agentId);
+      if (agent) {
+        agent.currentModel = newModel;
+        await this.agentPool.persistAgentState(agentId);
+      }
+      
+      this.logger.info(`Agent model switched: ${agentId}`, {
+        newModel,
+        messageCount: modelConversation.messages.length
+      });
+      
+      return {
+        success: true,
+        agentId,
+        newModel,
+        conversation: modelConversation
+      };
+      
+    } catch (error) {
+      this.logger.error(`Model switch failed: ${error.message}`, { agentId, newModel });
+      throw error;
+    }
+  }
+
+  /**
+   * Initialize model specifications
+   * @private
+   */
+  _initializeModelSpecs() {
+    const baseSpecs = {
+      // Anthropic Claude models
+      [MODELS.ANTHROPIC_SONNET]: {
+        provider: MODEL_PROVIDERS.ANTHROPIC,
+        contextWindow: 200000,
+        maxTokens: 8192,  // Increased from 4096
+        costPer1kTokens: 0.015
+      },
+      [MODELS.ANTHROPIC_OPUS]: {
+        provider: MODEL_PROVIDERS.ANTHROPIC,
+        contextWindow: 200000,
+        maxTokens: 8192,  // Increased from 4096
+        costPer1kTokens: 0.075
+      },
+      [MODELS.ANTHROPIC_HAIKU]: {
+        provider: MODEL_PROVIDERS.ANTHROPIC,
+        contextWindow: 200000,
+        maxTokens: 8192,  // Increased from 4096
+        costPer1kTokens: 0.0025
+      },
+
+      // OpenAI models
+      [MODELS.GPT_4]: {
+        provider: MODEL_PROVIDERS.OPENAI,
+        contextWindow: 128000,
+        maxTokens: 8192,  // Increased from 4096
+        costPer1kTokens: 0.03
+      },
+      [MODELS.GPT_4_MINI]: {
+        provider: MODEL_PROVIDERS.OPENAI,
+        contextWindow: 128000,
+        maxTokens: 16384,
+        costPer1kTokens: 0.0015
+      },
+      'gpt-4o': {
+        provider: MODEL_PROVIDERS.OPENAI,
+        contextWindow: 128000,
+        maxTokens: 8192,
+        costPer1kTokens: 0.03
+      },
+      'gpt-4o-mini': {
+        provider: MODEL_PROVIDERS.OPENAI,
+        contextWindow: 128000,
+        maxTokens: 16384,
+        costPer1kTokens: 0.0015
+      },
+      'gpt-4-turbo': {
+        provider: MODEL_PROVIDERS.OPENAI,
+        contextWindow: 128000,
+        maxTokens: 8192,
+        costPer1kTokens: 0.03
+      },
+      'gpt-3.5-turbo': {
+        provider: MODEL_PROVIDERS.OPENAI,
+        contextWindow: 16384,
+        maxTokens: 4096,
+        costPer1kTokens: 0.001
+      },
+
+      // DeepSeek models
+      [MODELS.DEEPSEEK_R1]: {
+        provider: MODEL_PROVIDERS.DEEPSEEK,
+        contextWindow: 128000,
+        maxTokens: 8192,
+        costPer1kTokens: 0.002
+      },
+
+      // Phi models
+      [MODELS.PHI_4]: {
+        provider: MODEL_PROVIDERS.PHI,
+        contextWindow: 16384,
+        maxTokens: 4096,  // Increased from 2048
+        costPer1kTokens: 0.001
+      },
+
+      // Azure AI Foundry models
+      'azure-ai-grok3': {
+        provider: 'AZURE',
+        contextWindow: 128000,
+        maxTokens: 8192,  // Increased from 4096
+        costPer1kTokens: 0.01
+      },
+      'azure-ai-deepseek-r1': {
+        provider: 'AZURE',
+        contextWindow: 128000,
+        maxTokens: 8192,
+        costPer1kTokens: 0.002
+      },
+      'azure-openai-gpt-5': {
+        provider: 'AZURE',
+        contextWindow: 128000,
+        maxTokens: 8192,
+        costPer1kTokens: 0.03
+      },
+      'azure-openai-gpt-4': {
+        provider: 'AZURE',
+        contextWindow: 128000,
+        maxTokens: 8192,
+        costPer1kTokens: 0.03
+      },
+      'azure-openai-gpt-4o': {
+        provider: 'AZURE',
+        contextWindow: 128000,
+        maxTokens: 8192,
+        costPer1kTokens: 0.03
+      },
+
+      // Router model
+      'autopilot-model-router': {
+        provider: 'AZURE',
+        contextWindow: 16384,
+        maxTokens: 2048,
+        costPer1kTokens: 0.001
+      }
+    };
+
+    // No need for prefixed models anymore - just return clean base specs
+    return baseSpecs;
+  }
+
+  /**
+   * Format messages for specific model
+   * @private
+   */
+  _formatMessagesForModel(messages, model, options) {
+    // Get model spec or use default
+    const modelSpec = this.modelSpecs[model] || { provider: 'AZURE' };
+    
+    let formattedMessages;
+    
+    if (typeof messages === 'string') {
+      // Single message
+      formattedMessages = [{
+        role: 'user',
+        content: messages
+      }];
+    } else {
+      // Message array
+      formattedMessages = messages.map(msg => this._formatSingleMessage(msg, model));
+    }
+    
+    // Apply provider-specific formatting
+    switch (modelSpec.provider) {
+      case MODEL_PROVIDERS.ANTHROPIC:
+        return this._formatForAnthropic(formattedMessages);
+      case MODEL_PROVIDERS.OPENAI:
+        return this._formatForOpenAI(formattedMessages);
+      case MODEL_PROVIDERS.AZURE:
+        return this._formatForAzure(formattedMessages);
+      default:
+        return formattedMessages;
+    }
+  }
+
+  /**
+   * Format single message for model
+   * @private
+   */
+  _formatSingleMessage(message, model) {
+    return {
+      role: message.role || 'user',
+      content: message.content,
+      timestamp: message.timestamp
+    };
+  }
+
+  /**
+   * Format messages for Anthropic models
+   * @private
+   */
+  _formatForAnthropic(messages) {
+    return messages.map(msg => {
+      if (msg.role === 'system') {
+        return {
+          role: 'user',
+          content: `System: ${msg.content}`
+        };
+      }
+      return msg;
+    });
+  }
+
+  /**
+   * Format messages for OpenAI models
+   * @private
+   */
+  _formatForOpenAI(messages) {
+    // OpenAI supports system role natively
+    return messages;
+  }
+
+  /**
+   * Format messages for Azure models
+   * @private
+   */
+  _formatForAzure(messages) {
+    // Azure may have specific formatting requirements
+    return messages.map(msg => ({
+      ...msg,
+      content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content)
+    }));
+  }
+
+  /**
+   * Check if model is valid
+   * @private
+   */
+  _isValidModel(model) {
+    this.logger.debug('Validating model', { model, modelType: typeof model });
+    
+    // Check if model exists in our specs directly
+    if (this.modelSpecs[model] !== undefined) {
+      return true;
+    }
+    
+    this.logger.warn('Model validation failed', { 
+      model,
+      availableModels: Object.keys(this.modelSpecs)
+    });
+    
+    return false;
+  }
+
+  /**
+   * Check model health status
+   * @private
+   */
+  async _checkModelHealth(model) {
+    // Implementation would check model-specific health endpoints
+    // For now, return true (assuming all models are healthy)
+    return true;
+  }
+
+  /**
+   * Estimate tokens for content
+   * @private
+   */
+  async _estimateTokens(content, model) {
+    // Rough estimation: 1 token ≈ 4 characters for most models
+    return Math.ceil(content.length / 4);
+  }
+
+  /**
+   * Truncate message to fit token limit
+   * @private
+   */
+  async _truncateMessage(content, maxTokens) {
+    const maxChars = maxTokens * 4; // Rough estimation
+    if (content.length <= maxChars) {
+      return content;
+    }
+    
+    return content.substring(0, maxChars - 20) + '\n... [message truncated]';
+  }
+
+  /**
+   * Summarize messages for compactization
+   * @private
+   */
+  async _summarizeMessages(messages, model) {
+    const combinedContent = messages
+      .map(msg => `${msg.role}: ${msg.content}`)
+      .join('\n');
+    
+    // This would use the AI service to create a summary
+    // For now, return a simple truncated version
+    const maxLength = 500;
+    if (combinedContent.length <= maxLength) {
+      return combinedContent;
+    }
+    
+    return combinedContent.substring(0, maxLength) + '... [conversation summary truncated]';
+  }
+
+  /**
+   * Make API request with retry logic
+   * @private
+   */
+  async _makeAPIRequest(endpoint, payload, requestId, options = {}) {
+    // Make request directly to Azure backend (not through local proxy)
+    const azureBackendUrl = 'https://autopilot-api.azurewebsites.net/llm/chat';
+    let lastError;
+    
+    // Get API keys from session-based storage
+    let apiKey = null;
+    let vendorApiKey = null;
+    
+    // Log the state for debugging
+    this.logger?.info('🔑 API Key retrieval state', {
+      hasApiKeyManager: !!this.apiKeyManager,
+      sessionId: options.sessionId,
+      hasSessionId: !!options.sessionId,
+      optionsKeys: Object.keys(options),
+      model: payload.model
+    });
+    
+    // First try to get from API key manager using session ID
+    if (this.apiKeyManager && options.sessionId) {
+      const keys = this.apiKeyManager.getKeysForRequest(options.sessionId, {
+        platformProvided: options.platformProvided || false,
+        vendor: this._getVendorFromModel(payload.model)
+      });
+      
+      apiKey = keys.loxiaApiKey;
+      vendorApiKey = keys.vendorApiKey;
+      
+      this.logger?.debug('Retrieved API keys from session manager', {
+        sessionId: options.sessionId,
+        hasLoxiaKey: !!apiKey,
+        hasVendorKey: !!vendorApiKey,
+        vendor: this._getVendorFromModel(payload.model)
+      });
+    }
+    
+    // Fallback to options (passed from frontend)
+    if (!apiKey && options.apiKey) {
+      apiKey = options.apiKey;
+    }
+    
+    // Fallback to config if no API key from session or options
+    if (!apiKey && this.config.apiKey) {
+      apiKey = this.config.apiKey;
+    }
+    
+    if (!apiKey) {
+      throw new Error('No API key configured. Please configure your Loxia API key in Settings.');
+    }
+    
+    // Use the model name from payload (already transformed)
+    const modelName = payload.model;
+    
+    // Transform the payload to match the Azure backend API format
+    const azurePayload = {
+      conversationId: requestId,
+      message: payload.messages[payload.messages.length - 1]?.content || '',
+      messages: payload.messages,
+      model: modelName,
+      requestId,
+      options: payload.options || {},
+      platformProvided: options.platformProvided || false // Indicate if this is a platform model
+    };
+    
+    // Add system prompt if provided
+    if (payload.system) {
+      azurePayload.systemPrompt = payload.system;
+    }
+    
+    // Include appropriate API key based on model type
+    if (options.platformProvided) {
+      // Platform models use Loxia API key
+      azurePayload.apiKey = apiKey;
+    } else {
+      // Direct access models use vendor-specific keys
+      if (vendorApiKey) {
+        azurePayload.vendorApiKey = vendorApiKey;
+      }
+      
+      // Also include custom API keys from options for backward compatibility
+      if (options.customApiKeys) {
+        azurePayload.customApiKeys = options.customApiKeys;
+      }
+      
+      // Include Loxia API key as fallback
+      azurePayload.apiKey = apiKey;
+    }
+    
+    for (let attempt = 1; attempt <= this.retryAttempts; attempt++) {
+      try {
+        this.logger.info('Making request to Azure backend', {
+          url: azureBackendUrl,
+          model: payload.model,
+          requestId,
+          attempt,
+          hasApiKey: !!apiKey
+        });
+        
+        const response = await fetch(azureBackendUrl, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${apiKey}`,
+            'X-Request-ID': requestId
+          },
+          body: JSON.stringify(azurePayload),
+          timeout: this.timeout
+        });
+        
+        if (!response.ok) {
+          const errorText = await response.text();
+          const error = new Error(`HTTP ${response.status}: ${response.statusText}${errorText ? ` - ${errorText}` : ''}`);
+          error.status = response.status;
+          throw error;
+        }
+        
+        const data = await response.json();
+        
+        // Transform Azure backend response to match expected format
+        return {
+          choices: [{
+            message: {
+              content: data.content || '',
+              role: 'assistant'
+            },
+            finish_reason: data.finishReason || 'stop'
+          }],
+          usage: data.usage || {
+            prompt_tokens: 0,
+            completion_tokens: 0,
+            total_tokens: 0
+          },
+          model: data.model || payload.model,
+          id: data.requestId || requestId
+        };
+        
+      } catch (error) {
+        lastError = error;
+        
+        this.logger.warn('Request to Azure backend failed', {
+          attempt,
+          requestId,
+          error: error.message,
+          status: error.status
+        });
+        
+        if (attempt < this.retryAttempts) {
+          const delay = Math.pow(2, attempt) * 1000; // Exponential backoff
+          this.logger.warn(`Retrying in ${delay}ms`, { attempt, requestId });
+          await new Promise(resolve => setTimeout(resolve, delay));
+        }
+      }
+    }
+    
+    // If all attempts failed, return a mock response with error info
+    this.logger.error('All attempts to reach backend failed, using mock response', {
+      requestId,
+      error: lastError.message
+    });
+    
+    // Check if this is an API key error that should stop retries
+    const isApiKeyError = lastError.message && lastError.message.includes('No API key configured');
+    
+    // For API key errors, throw to stop the autonomous loop
+    if (isApiKeyError) {
+      throw new Error(`API Configuration Error: ${lastError.message}`);
+    }
+    
+    // For other errors, return a short error message without including the original content
+    return {
+      choices: [{
+        message: {
+          content: `I apologize, but I'm unable to connect to the AI service at the moment. Error: ${lastError.message}`,
+          role: 'assistant'
+        },
+        finish_reason: 'stop'
+      }],
+      usage: {
+        prompt_tokens: 0,
+        completion_tokens: 0,
+        total_tokens: 0
+      },
+      model: payload.model,
+      id: `error-${requestId}`,
+      error: lastError.message
+    };
+  }
+
+
+  /**
+   * Make API request for image generation
+   * @private
+   */
+  async _makeImageAPIRequest(payload, requestId, options = {}) {
+    // Image generation endpoint on Azure backend (CORRECTED)
+    const azureImageUrl = 'https://autopilot-api.azurewebsites.net/llm/generate-image';
+    let lastError;
+
+    // Get API keys from session-based storage
+    let apiKey = null;
+    let vendorApiKey = null;
+
+    this.logger?.info('🖼️ Image API request state', {
+      hasApiKeyManager: !!this.apiKeyManager,
+      sessionId: options.sessionId,
+      hasSessionId: !!options.sessionId,
+      model: payload.model
+    });
+
+    // First try to get from API key manager using session ID
+    if (this.apiKeyManager && options.sessionId) {
+      const keys = this.apiKeyManager.getKeysForRequest(options.sessionId, {
+        platformProvided: options.platformProvided || false,
+        vendor: this._getVendorFromModel(payload.model)
+      });
+
+      apiKey = keys.loxiaApiKey;
+      vendorApiKey = keys.vendorApiKey;
+
+      this.logger?.debug('Retrieved API keys from session manager for image', {
+        sessionId: options.sessionId,
+        hasLoxiaKey: !!apiKey,
+        hasVendorKey: !!vendorApiKey
+      });
+    }
+
+    // Fallback to options (passed from frontend)
+    if (!apiKey && options.apiKey) {
+      apiKey = options.apiKey;
+    }
+
+    // Fallback to config if no API key from session or options
+    if (!apiKey && this.config.apiKey) {
+      apiKey = this.config.apiKey;
+    }
+
+    if (!apiKey) {
+      throw new Error('No API key configured. Please configure your Loxia API key in Settings.');
+    }
+
+    // Transform the payload to match Azure backend format
+    // Backend expects: prompt, model, size, quality, style, n, requestId
+    const azurePayload = {
+      prompt: payload.prompt,
+      model: payload.model || 'azure-openai-dalle3', // Backend default
+      size: payload.size,
+      quality: payload.quality,
+      style: payload.style || 'vivid', // Backend default
+      n: payload.n || 1,
+      requestId
+    };
+
+    // API key is sent via Authorization header, not in body
+
+    for (let attempt = 1; attempt <= this.retryAttempts; attempt++) {
+      try {
+        this.logger.info('Making image request to Azure backend', {
+          url: azureImageUrl,
+          model: payload.model,
+          requestId,
+          attempt,
+          hasApiKey: !!apiKey
+        });
+
+        const response = await fetch(azureImageUrl, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${apiKey}`,
+            'X-Request-ID': requestId
+          },
+          body: JSON.stringify(azurePayload),
+          timeout: this.timeout * 2 // Image generation may take longer
+        });
+
+        if (!response.ok) {
+          const errorText = await response.text();
+          const error = new Error(`HTTP ${response.status}: ${response.statusText}${errorText ? ` - ${errorText}` : ''}`);
+          error.status = response.status;
+          throw error;
+        }
+
+        const data = await response.json();
+
+        // Backend returns: { images: [...], usage: {...}, model, requestId, created }
+        // Transform to match our expected format
+        return {
+          data: data.images || [],
+          model: data.model || payload.model,
+          created: data.created || Date.now(),
+          usage: data.usage
+        };
+
+      } catch (error) {
+        lastError = error;
+
+        this.logger.warn('Image request to Azure backend failed', {
+          attempt,
+          requestId,
+          error: error.message,
+          status: error.status
+        });
+
+        if (attempt < this.retryAttempts) {
+          const delay = Math.pow(2, attempt) * 1000; // Exponential backoff
+          this.logger.warn(`Retrying in ${delay}ms`, { attempt, requestId });
+          await new Promise(resolve => setTimeout(resolve, delay));
+        }
+      }
+    }
+
+    // If all attempts failed, throw error
+    this.logger.error('All image generation attempts failed', {
+      requestId,
+      error: lastError.message
+    });
+
+    throw new Error(`Image generation failed: ${lastError.message}`);
+  }
+
+  /**
+   * Check rate limits
+   * @private
+   */
+  async _checkRateLimit(model) {
+    // Implementation would check model-specific rate limits
+    // For now, just add a small delay
+    await new Promise(resolve => setTimeout(resolve, 100));
+  }
+
+  /**
+   * Handle rate limit exceeded
+   * @private
+   */
+  async _handleRateLimit(context) {
+    const delay = 60000; // 1 minute delay for rate limits
+    this.logger.info(`Rate limit exceeded, waiting ${delay}ms`, context);
+    await new Promise(resolve => setTimeout(resolve, delay));
+  }
+
+  /**
+   * Handle service unavailable
+   * @private
+   */
+  async _handleServiceUnavailable(context) {
+    this._recordFailure();
+    const delay = 30000; // 30 second delay for service issues
+    this.logger.info(`Service unavailable, waiting ${delay}ms`, context);
+    await new Promise(resolve => setTimeout(resolve, delay));
+  }
+
+  /**
+   * Check if circuit breaker is open
+   * @private
+   */
+  _isCircuitBreakerOpen() {
+    if (!this.circuitBreaker.isOpen) {
+      return false;
+    }
+    
+    const timeSinceLastFailure = Date.now() - this.circuitBreaker.lastFailureTime;
+    if (timeSinceLastFailure > this.circuitBreaker.timeout) {
+      this.circuitBreaker.isOpen = false;
+      this.circuitBreaker.failures = 0;
+      return false;
+    }
+    
+    return true;
+  }
+
+  /**
+   * Record failure for circuit breaker
+   * @private
+   */
+  _recordFailure() {
+    this.circuitBreaker.failures++;
+    this.circuitBreaker.lastFailureTime = Date.now();
+    
+    if (this.circuitBreaker.failures >= this.circuitBreaker.threshold) {
+      this.circuitBreaker.isOpen = true;
+      this.logger.warn('Circuit breaker opened due to repeated failures');
+    }
+  }
+
+  /**
+   * Reset circuit breaker on success
+   * @private
+   */
+  _resetCircuitBreaker() {
+    if (this.circuitBreaker.failures > 0) {
+      this.circuitBreaker.failures = 0;
+      this.circuitBreaker.isOpen = false;
+      this.logger.info('Circuit breaker reset - service recovered');
+    }
+  }
+
+  /**
+   * Extract vendor name from model name
+   * @param {string} model - Model name
+   * @returns {string|null} Vendor name
+   * @private
+   */
+  _getVendorFromModel(model) {
+    if (!model) return null;
+    
+    const modelName = model.toLowerCase();
+    
+    if (modelName.includes('anthropic') || modelName.includes('claude')) {
+      return 'anthropic';
+    } else if (modelName.includes('openai') || modelName.includes('gpt')) {
+      return 'openai';
+    } else if (modelName.includes('deepseek')) {
+      return 'deepseek';
+    } else if (modelName.includes('phi')) {
+      return 'microsoft';
+    }
+    
+    return null;
+  }
+}
+
+/**
+ * ConversationManager - Handles multi-model conversation state
+ */
+class ConversationManager {
+  constructor(agentId, logger) {
+    this.agentId = agentId;
+    this.logger = logger;
+    this.conversations = new Map();
+  }
+
+  async switchModel(newModel) {
+    // Implementation would handle model switching logic
+    // For now, return empty conversation
+    return {
+      messages: [],
+      model: newModel,
+      lastUpdated: new Date().toISOString()
+    };
+  }
+}
+
+export default AIService;