@loxia-labs/loxia-autopilot-one 1.0.1

package/src/services/modelRouterService.js

@@ -0,0 +1,366 @@
+/**
+ * ModelRouterService - Uses PHI-4 to make intelligent model routing decisions
+ * 
+ * Purpose:
+ * - Analyze incoming messages and conversation context
+ * - Use PHI-4 to determine optimal model for each message
+ * - Provide fallback to previous model on errors
+ * - Consider benchmark data and recent message history
+ */
+
+import { MODEL_ROUTER_CONFIG, HTTP_STATUS, MODELS } from '../utilities/constants.js';
+
+class ModelRouterService {
+  constructor(config, logger, benchmarkService, aiService) {
+    this.config = config;
+    this.logger = logger;
+    this.benchmarkService = benchmarkService;
+    this.aiService = aiService;
+    
+    this.routerModel = MODEL_ROUTER_CONFIG.ROUTER_MODEL;
+    this.contextMessagesCount = MODEL_ROUTER_CONFIG.CONTEXT_MESSAGES_COUNT;
+    this.requestTimeout = MODEL_ROUTER_CONFIG.REQUEST_TIMEOUT;
+  }
+
+  /**
+   * Route message to optimal model using autopilot-model-router analysis
+   * @param {Object} message - Current message to route
+   * @param {Array} recentMessages - Recent conversation history
+   * @param {string} currentModel - Current model being used
+   * @param {Array} availableModels - Models available for routing
+   * @param {Object} context - Message context with API keys
+   * @returns {Promise<string>} Selected model name
+   */
+  async routeMessage(message, recentMessages = [], currentModel = '', availableModels = [], context = {}) {
+    try {
+      this.logger.debug('Starting model routing analysis', {
+        messageLength: message.content?.length || 0,
+        recentMessagesCount: recentMessages.length,
+        currentModel,
+        availableModelsCount: availableModels.length
+      });
+
+      // Build context for autopilot-model-router
+      const routingContext = this._buildRoutingContext(
+        message, 
+        recentMessages, 
+        currentModel, 
+        availableModels
+      );
+
+      // Get benchmark data
+      const benchmarkTable = this.benchmarkService.getBenchmarkTable();
+
+      // Create routing prompt for autopilot-model-router
+      const routingPrompt = this._createRoutingPrompt(routingContext, benchmarkTable);
+
+      // Send to autopilot-model-router for analysis
+      const routingDecision = await this._askForRouting(routingPrompt, context);
+
+      // Validate and return model selection
+      const selectedModel = this._validateModelSelection(routingDecision, availableModels, currentModel);
+
+      this.logger.info('Model routing completed', {
+        selectedModel,
+        previousModel: currentModel,
+        changed: selectedModel !== currentModel,
+        reasoning: routingDecision.reasoning?.substring(0, 100) || 'No reasoning provided'
+      });
+
+      // Return full routing result object for AgentScheduler
+      return {
+        selectedModel,
+        previousModel: currentModel,
+        changed: selectedModel !== currentModel,
+        reasoning: routingDecision.reasoning || 'No reasoning provided'
+      };
+
+    } catch (error) {
+      this.logger.error('Model routing failed, falling back to current model', {
+        error: error.message,
+        currentModel
+      });
+
+      // Fallback to current model on any error
+      const fallbackModel = currentModel || availableModels[0] || MODELS.ANTHROPIC_SONNET;
+      return {
+        selectedModel: fallbackModel,
+        previousModel: currentModel,
+        changed: false,
+        reasoning: 'Routing failed, using fallback model'
+      };
+    }
+  }
+
+  /**
+   * Build routing context from message and conversation history
+   * @private
+   */
+  _buildRoutingContext(message, recentMessages, currentModel, availableModels) {
+    // Get recent messages (configurable count)
+    const contextMessages = recentMessages
+      .slice(-this.contextMessagesCount)
+      .map(msg => ({
+        role: msg.role,
+        content: msg.content?.substring(0, 500) || '', // Limit content length
+        timestamp: msg.timestamp
+      }));
+
+    return {
+      currentMessage: {
+        content: message.content?.substring(0, 1000) || '', // Limit current message
+        role: message.role || 'user',
+        hasContextReferences: !!(message.contextReferences?.length),
+        contextTypes: message.contextReferences?.map(ref => ref.type) || []
+      },
+      recentMessages: contextMessages,
+      currentModel,
+      availableModels: availableModels.map(model => ({
+        name: model,
+        isCurrentModel: model === currentModel
+      })),
+      messageCount: recentMessages.length + 1,
+      timestamp: new Date().toISOString()
+    };
+  }
+
+  /**
+   * Create routing prompt for autopilot-model-router
+   * @private
+   */
+  _createRoutingPrompt(context, benchmarkTable) {
+    return `You are a model routing assistant. Your job is to analyze a conversation and select the optimal AI model for the next response.
+
+## Current Situation
+- **Current Model**: ${context.currentModel || 'None'}
+- **Message Count**: ${context.messageCount}
+- **Available Models**: ${context.availableModels.map(m => m.name).join(', ')}
+
+## Recent Conversation Context
+${this._formatRecentMessages(context.recentMessages)}
+
+## Current Message to Route
+**Role**: ${context.currentMessage.role}
+**Content**: ${context.currentMessage.content}
+**Has Context References**: ${context.currentMessage.hasContextReferences}
+${context.currentMessage.contextTypes.length > 0 ? `**Context Types**: ${context.currentMessage.contextTypes.join(', ')}` : ''}
+
+## Model Benchmark Data
+${this._formatBenchmarkData(benchmarkTable)}
+
+## Routing Decision
+Analyze the current message and conversation context to select the best model. Consider:
+
+1. **Task Type**: Infer from conversation content - is this coding, analysis, creative writing, or a quick task?
+2. **Complexity**: Does it require deep reasoning or is it straightforward?
+3. **Context**: Are there code files or technical references?
+4. **Conversation Flow**: What has been discussed recently to understand the overall task?
+5. **Efficiency**: Balance performance with cost/speed needs
+
+Respond with JSON only:
+{
+  "selectedModel": "model-name",
+  "taskType": "coding|analysis|creative|quick-tasks",
+  "confidence": 0.85,
+  "reasoning": "Brief explanation of why this model was chosen",
+  "factors": ["factor1", "factor2", "factor3"]
+}`;
+  }
+
+  /**
+   * Format recent messages for prompt
+   * @private
+   */
+  _formatRecentMessages(messages) {
+    if (!messages.length) {
+      return 'No recent messages available.';
+    }
+
+    return messages.map((msg, i) => 
+      `${i + 1}. **${msg.role}**: ${msg.content}`
+    ).join('\n');
+  }
+
+  /**
+   * Format benchmark data for prompt
+   * @private
+   */
+  _formatBenchmarkData(benchmarkTable) {
+    const models = benchmarkTable.models || [];
+    const tasks = benchmarkTable.tasks || {};
+    const summary = benchmarkTable.summary || {};
+
+    let formatted = '### Model Performance Summary\n';
+    
+    // Task recommendations
+    Object.entries(tasks).forEach(([taskType, taskInfo]) => {
+      formatted += `**${taskType.toUpperCase()}** (${taskInfo.description}): ${taskInfo.topModels?.join(', ') || 'No data'}\n`;
+    });
+
+    formatted += '\n### Model Details\n';
+    
+    // Model details (limit to available models)
+    models.slice(0, 8).forEach(model => {
+      formatted += `**${model.name}**: `;
+      const taskScores = Object.entries(model.tasks || {})
+        .map(([task, info]) => `${task}(${info.score})`)
+        .join(', ');
+      formatted += `${taskScores} | Strengths: ${model.strengths?.join(', ') || 'N/A'}\n`;
+    });
+
+    return formatted;
+  }
+
+  /**
+   * Send routing request to autopilot-model-router
+   * @private
+   */
+  async _askForRouting(prompt, context = {}) {
+    try {
+      // Use AI service to send request to autopilot-model-router
+      const response = await this.aiService.sendMessage(
+        this.routerModel,
+        prompt,
+        {
+          agentId: 'model-router',
+          systemPrompt: 'You are a model routing expert. Analyze conversations and select optimal AI models. Always respond with valid JSON only.',
+          temperature: 0.3, // Low temperature for consistent routing decisions
+          maxTokens: 500,
+          timeout: this.requestTimeout,
+          sessionId: context.sessionId, // CRITICAL: Pass sessionId for API key retrieval
+          apiKey: context.apiKey || this.config.apiKey, // Fallback to API key from context if available
+          customApiKeys: context.customApiKeys,
+          platformProvided: true // autopilot-model-router is a platform model
+        }
+      );
+
+      if (!response.content) {
+        throw new Error('No response content from autopilot-model-router');
+      }
+
+      // Parse JSON response
+      const routingDecision = this._parseRoutingResponse(response.content);
+
+      return routingDecision;
+
+    } catch (error) {
+      this.logger.error('autopilot-model-router routing request failed', { 
+        error: error.message,
+        routerModel: this.routerModel
+      });
+      throw error;
+    }
+  }
+
+  /**
+   * Parse autopilot-model-router routing response
+   * @private
+   */
+  _parseRoutingResponse(content) {
+    try {
+      // Try to extract JSON from response
+      const jsonMatch = content.match(/\{[\s\S]*\}/);
+      if (!jsonMatch) {
+        throw new Error('No JSON found in autopilot-model-router response');
+      }
+
+      const parsed = JSON.parse(jsonMatch[0]);
+
+      // Validate required fields
+      if (!parsed.selectedModel) {
+        throw new Error('Missing selectedModel in autopilot-model-router response');
+      }
+
+      return {
+        selectedModel: parsed.selectedModel,
+        taskType: parsed.taskType || 'unknown',
+        confidence: parsed.confidence || 0.5,
+        reasoning: parsed.reasoning || 'No reasoning provided',
+        factors: parsed.factors || []
+      };
+
+    } catch (error) {
+      this.logger.warn('Failed to parse autopilot-model-router routing response', { 
+        error: error.message,
+        content: content.substring(0, 200)
+      });
+      
+      // Return default response on parse error
+      return {
+        selectedModel: null,
+        taskType: 'unknown',
+        confidence: 0.0,
+        reasoning: 'Failed to parse routing response',
+        factors: ['parsing-error']
+      };
+    }
+  }
+
+  /**
+   * Validate model selection against available models
+   * @private
+   */
+  _validateModelSelection(routingDecision, availableModels, currentModel) {
+    const { selectedModel } = routingDecision;
+
+    // If no model selected or parsing failed, use current model
+    if (!selectedModel) {
+      this.logger.debug('No model selected by router, using current model');
+      return currentModel;
+    }
+
+    // Check if selected model is available
+    if (!availableModels.includes(selectedModel)) {
+      this.logger.warn('Router selected unavailable model, using current model', {
+        selectedModel,
+        availableModels
+      });
+      return currentModel;
+    }
+
+    // Model is valid
+    return selectedModel;
+  }
+
+  /**
+   * Get router service status
+   */
+  getStatus() {
+    return {
+      routerModel: this.routerModel,
+      contextMessagesCount: this.contextMessagesCount,
+      requestTimeout: this.requestTimeout,
+      benchmarkServiceStatus: this.benchmarkService.getStatus(),
+      isAvailable: true
+    };
+  }
+
+  /**
+   * Test router with sample data
+   */
+  async testRouter() {
+    try {
+      const testMessage = {
+        content: 'Can you help me debug this JavaScript function?',
+        role: 'user'
+      };
+
+      const testResult = await this.routeMessage(
+        testMessage,
+        [],
+        MODELS.ANTHROPIC_SONNET,
+        [MODELS.ANTHROPIC_SONNET, MODELS.ANTHROPIC_OPUS, MODELS.GPT_4, MODELS.DEEPSEEK_R1],
+        { apiKey: 'test-key' } // Mock context for testing
+      );
+
+      this.logger.info('Router test completed', { selectedModel: testResult });
+      return { success: true, selectedModel: testResult };
+
+    } catch (error) {
+      this.logger.error('Router test failed', { error: error.message });
+      return { success: false, error: error.message };
+    }
+  }
+}
+
+export default ModelRouterService;

package/src/services/modelsService.js

@@ -0,0 +1,322 @@
+/**
+ * ModelsService - Manages available models from the backend API
+ * 
+ * Purpose:
+ * - Fetch available models from /llm/models endpoint
+ * - Cache models for the session
+ * - Provide model names for routing
+ * - Handle fallback when API is unavailable
+ */
+
+class ModelsService {
+  constructor(config, logger) {
+    this.config = config;
+    this.logger = logger;
+    
+    this.models = null;
+    this.lastFetched = null;
+    this.isLoading = false;
+    this.cacheExpiry = 5 * 60 * 1000; // 5 minutes cache
+    
+    this.backendUrl = 'https://autopilot-api.azurewebsites.net';
+    
+    // API Key Manager reference (will be set by LoxiaSystem)
+    this.apiKeyManager = null;
+  }
+
+  /**
+   * 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 models service', {
+      hasManager: !!apiKeyManager
+    });
+  }
+
+  /**
+   * Initialize the models service and fetch initial data
+   */
+  async initialize() {
+    try {
+      await this.fetchModels();
+      this.logger.info('Models service initialized', { 
+        modelCount: this.models?.length || 0 
+      });
+    } catch (error) {
+      this.logger.error('Failed to initialize models service', { 
+        error: error.message 
+      });
+      // Use fallback models on initialization failure
+      this.models = this._getFallbackModels();
+    }
+  }
+
+  /**
+   * Get available model names for routing
+   */
+  getAvailableModelNames() {
+    if (!this.models || this.models.length === 0) {
+      this.logger.warn('No models available, using fallback');
+      return this._getFallbackModelNames();
+    }
+    
+    return this.models.map(model => model.name);
+  }
+
+  /**
+   * Get all model information
+   */
+  getModels() {
+    return this.models || this._getFallbackModels();
+  }
+
+  /**
+   * Fetch models from backend API
+   * @param {Object} context - Optional context with API key
+   */
+  async fetchModels(context = null) {
+    if (this.isLoading) {
+      this.logger.debug('Models fetch already in progress');
+      return;
+    }
+
+    this.isLoading = true;
+
+    try {
+      const url = `${this.backendUrl}/llm/models`;
+      
+      // Get API key from multiple sources
+      let apiKey = null;
+      
+      // First try to get from API key manager using session ID
+      if (this.apiKeyManager && context && context.sessionId) {
+        const keys = this.apiKeyManager.getKeysForRequest(context.sessionId, {
+          platformProvided: true, // Models endpoint uses platform key
+          vendor: null
+        });
+        
+        apiKey = keys.loxiaApiKey;
+        
+        this.logger?.info('Retrieved API key from session manager for models fetch', {
+          sessionId: context.sessionId,
+          hasLoxiaKey: !!apiKey
+        });
+      }
+      
+      // Fallback to context, config, then environment
+      if (!apiKey && context && context.apiKey) {
+        apiKey = context.apiKey;
+      } else if (!apiKey && this.config.apiKey) {
+        apiKey = this.config.apiKey;
+      } else if (!apiKey && process.env.LOXIA_API_KEY) {
+        apiKey = process.env.LOXIA_API_KEY;
+      }
+
+      const fetchOptions = {
+        method: 'GET',
+        headers: {
+          'Content-Type': 'application/json',
+          ...(apiKey && { 'Authorization': `Bearer ${apiKey}` })
+        },
+        timeout: 10000 // 10 second timeout
+      };
+
+      this.logger.debug('Fetching models from backend', { 
+        url, 
+        hasApiKey: !!apiKey,
+        apiKeySource: context?.apiKey ? 'context' : this.config.apiKey ? 'config' : process.env.LOXIA_API_KEY ? 'env' : 'none'
+      });
+
+      const response = await fetch(url, fetchOptions);
+
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+
+      const data = await response.json();
+      
+      if (data.models && Array.isArray(data.models)) {
+        this.models = data.models;
+        this.lastFetched = new Date();
+        this.needsRefresh = false;
+        
+        this.logger.info('Models fetched from backend', { 
+          modelCount: this.models.length,
+          models: this.models.map(m => m.name)
+        });
+      } else {
+        throw new Error('Invalid response format from models API');
+      }
+
+    } catch (error) {
+      this.logger.warn('Failed to fetch models from backend, using fallback', {
+        error: error.message
+      });
+      
+      // Use fallback data on fetch error
+      if (!this.models) {
+        this.models = this._getFallbackModels();
+      }
+
+    } finally {
+      this.isLoading = false;
+    }
+  }
+
+  /**
+   * Check if models cache needs refresh
+   */
+  needsRefresh() {
+    if (!this.lastFetched) return true;
+    
+    const timeSinceUpdate = Date.now() - this.lastFetched.getTime();
+    return timeSinceUpdate > this.cacheExpiry;
+  }
+
+  /**
+   * Force refresh models from backend
+   * @param {Object} context - Optional context with API key
+   */
+  async refresh(context = null) {
+    this.logger.info('Force refreshing models');
+    await this.fetchModels(context);
+  }
+
+  /**
+   * Refresh models with API key context if needed
+   * @param {Object} context - Context with API key
+   */
+  async refreshWithContext(context) {
+    // Only refresh if we haven't successfully fetched or if we need a refresh
+    if (this.needsRefresh || !this.lastFetched) {
+      this.logger.debug('Refreshing models with API key context');
+      await this.fetchModels(context);
+    }
+  }
+
+  /**
+   * Get fallback models when API is unavailable
+   * @private
+   */
+  _getFallbackModels() {
+    return [
+      {
+        name: 'anthropic-sonnet',
+        category: 'anthropic',
+        type: 'chat',
+        maxTokens: 10000,
+        supportsVision: true,
+        supportsSystem: true,
+        pricing: { input: 0.003, output: 0.015, unit: '1K tokens' }
+      },
+      {
+        name: 'anthropic-opus',
+        category: 'anthropic',
+        type: 'chat',
+        maxTokens: 10000,
+        supportsVision: true,
+        supportsSystem: true,
+        pricing: { input: 0.015, output: 0.075, unit: '1K tokens' }
+      },
+      {
+        name: 'anthropic-haiku',
+        category: 'anthropic',
+        type: 'chat',
+        maxTokens: 10000,
+        supportsVision: true,
+        supportsSystem: true,
+        pricing: { input: 0.00025, output: 0.00125, unit: '1K tokens' }
+      },
+      {
+        name: 'gpt-4',
+        category: 'openai',
+        type: 'chat',
+        maxTokens: 4096,
+        supportsVision: false,
+        supportsSystem: true,
+        pricing: { input: 0.030, output: 0.060, unit: '1K tokens' }
+      },
+      {
+        name: 'gpt-4-mini',
+        category: 'openai',
+        type: 'chat',
+        maxTokens: 16384,
+        supportsVision: false,
+        supportsSystem: true,
+        pricing: { input: 0.00015, output: 0.0006, unit: '1K tokens' }
+      },
+      {
+        name: 'deepseek-r1',
+        category: 'deepseek',
+        type: 'chat',
+        maxTokens: 8192,
+        supportsVision: false,
+        supportsSystem: true,
+        pricing: { input: 0.014, output: 0.028, unit: '1K tokens' }
+      },
+      {
+        name: 'azure-ai-grok3',
+        category: 'azure',
+        type: 'chat',
+        maxTokens: 4096,
+        supportsVision: false,
+        supportsSystem: true,
+        pricing: { input: 0.01, output: 0.02, unit: '1K tokens' }
+      },
+      {
+        name: 'phi-4',
+        category: 'microsoft',
+        type: 'chat',
+        maxTokens: 2048,
+        supportsVision: false,
+        supportsSystem: true,
+        pricing: { input: 0.010, output: 0.020, unit: '1K tokens' }
+      },
+      {
+        name: 'autopilot-model-router',
+        category: 'azure',
+        type: 'chat',
+        maxTokens: 2048,
+        supportsVision: false,
+        supportsSystem: true,
+        pricing: { input: 0.001, output: 0.002, unit: '1K tokens' }
+      }
+    ];
+  }
+
+  /**
+   * Get fallback model names only
+   * @private
+   */
+  _getFallbackModelNames() {
+    return [
+      'anthropic-sonnet',
+      'anthropic-opus',
+      'anthropic-haiku',
+      'gpt-4',
+      'gpt-4-mini',
+      'deepseek-r1',
+      'azure-ai-grok3',
+      'phi-4',
+      'autopilot-model-router'
+    ];
+  }
+
+  /**
+   * Get service status
+   */
+  getStatus() {
+    return {
+      initialized: !!this.models,
+      lastFetched: this.lastFetched?.toISOString() || null,
+      modelCount: this.models?.length || 0,
+      isLoading: this.isLoading,
+      needsRefresh: this.needsRefresh()
+    };
+  }
+}
+
+export default ModelsService;