onbuzz 3.3.0

package/src/services/modelRouterService.js

@@ -0,0 +1,365 @@
+/**
+ * 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, context.routingStrategy);
+
+      // 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 => {
+        const name = typeof model === 'string' ? model : (model.id || model.name);
+        const pricing = typeof model === 'object' ? model.pricing : null;
+        return {
+          name,
+          isCurrentModel: name === currentModel,
+          ...(pricing && { pricing })
+        };
+      }),
+      messageCount: recentMessages.length + 1,
+      timestamp: new Date().toISOString()
+    };
+  }
+
+  /**
+   * Create routing prompt for autopilot-model-router
+   * @private
+   */
+  _createRoutingPrompt(context, benchmarkTable, routingStrategy) {
+    const maxLen = MODEL_ROUTER_CONFIG.MAX_ROUTING_STRATEGY_LENGTH;
+    const strategySection = routingStrategy?.trim()
+      ? `\n## Agent-Specific Routing Strategy\n${routingStrategy.trim().substring(0, maxLen)}\n\nApply the above strategy when making your routing decision. It takes priority over the generic criteria.\n`
+      : '';
+
+    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 => {
+  const pricingInfo = m.pricing
+    ? ` (input: $${m.pricing.input}/1K tokens, output: $${m.pricing.output}/1K tokens)`
+    : '';
+  return `  - ${m.name}${m.isCurrentModel ? ' [current]' : ''}${pricingInfo}`;
+}).join('\n')}
+
+## 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
+${strategySection}
+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(benchmarkText) {
+    // Benchmark text is provided as-is from backend, no processing needed
+    if (!benchmarkText) {
+      return 'No benchmark data available.';
+    }
+    return benchmarkText;
+  }
+
+  /**
+   * 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 (supports both string arrays and object arrays)
+    const modelNames = availableModels.map(m => typeof m === 'string' ? m : (m.id || m.name));
+    if (!modelNames.includes(selectedModel)) {
+      this.logger.warn('Router selected unavailable model, using current model', {
+        selectedModel,
+        availableModels: modelNames
+      });
+      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.GPT_4, MODELS.GPT_5_1_CODEX_MINI, 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,323 @@
+/**
+ * ModelsService - Manages available models from the backend API
+ *
+ * Purpose:
+ * - Fetch available models from /api/llm/models endpoint
+ * - Cache models for the session
+ * - Provide model names for routing
+ * - Show errors 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
+
+    // Use config backend URL (set via LOXIA_BACKEND_URL env var), fallback to local server
+    this.backendUrl = config.backend?.baseUrl || config.backendUrl || 'http://localhost:8080';
+
+    // Retry configuration
+    this.retryAttempts = 0;
+    this.maxRetries = 3;
+    this.retryDelay = 2000; // Start with 2 seconds
+    this.retryTimer = null;
+    this.lastError = null;
+
+    // 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.lastError = error.message;
+      this.logger.error('Failed to initialize models service - NO FALLBACK AVAILABLE', {
+        error: error.message,
+        endpoint: this.backendUrl,
+        willRetry: true
+      });
+      // Schedule retry instead of using hardcoded fallback
+      this._scheduleRetry();
+    }
+  }
+
+  /**
+   * Get available model names for routing
+   */
+  getAvailableModelNames() {
+    if (!this.models || this.models.length === 0) {
+      this.logger.error('No models available - API fetch failed', {
+        lastError: this.lastError,
+        endpoint: this.backendUrl,
+        retryAttempt: this.retryAttempts,
+        maxRetries: this.maxRetries
+      });
+      return [];
+    }
+
+    return this.models.map(model => model.name);
+  }
+
+  /**
+   * Get all model information
+   */
+  getModels() {
+    if (!this.models || this.models.length === 0) {
+      this.logger.error('No models available - API fetch failed', {
+        lastError: this.lastError,
+        endpoint: this.backendUrl
+      });
+      return [];
+    }
+    return this.models;
+  }
+
+  /**
+   * 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;
+    // Local server uses /api prefix, Azure backend doesn't
+    const isLocalServer = this.backendUrl.includes('localhost') || this.backendUrl.includes('127.0.0.1');
+    const url = isLocalServer ? `${this.backendUrl}/api/llm/models` : `${this.backendUrl}/llm/models`;
+
+    try {
+      
+      // Get API key from multiple sources
+      let apiKey = null;
+
+      // First try to get from API key manager (global storage)
+      if (this.apiKeyManager) {
+        const keys = this.apiKeyManager.getKeysForRequest(null, {
+          platformProvided: true, // Models endpoint uses platform key
+          vendor: null
+        });
+        apiKey = keys.loxiaApiKey;
+      }
+
+      // 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;
+      }
+
+      // Use AbortController for timeout (Node.js fetch doesn't support timeout option)
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 10000);
+
+      const fetchOptions = {
+        method: 'GET',
+        headers: {
+          'Content-Type': 'application/json',
+          ...(apiKey && { 'Authorization': `Bearer ${apiKey}` })
+        },
+        signal: controller.signal
+      };
+
+      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'
+      });
+
+      let response;
+      try {
+        response = await fetch(url, fetchOptions);
+        clearTimeout(timeoutId);
+      } catch (fetchError) {
+        clearTimeout(timeoutId);
+        if (fetchError.name === 'AbortError') {
+          throw new Error('Request timeout after 10 seconds');
+        }
+        throw fetchError;
+      }
+
+      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.lastError = error.message;
+      this.logger.error('Failed to fetch models from backend - NO FALLBACK', {
+        error: error.message,
+        endpoint: url,
+        retryAttempt: this.retryAttempts,
+        maxRetries: this.maxRetries
+      });
+
+      // Schedule retry instead of using fallback
+      this._scheduleRetry(context);
+
+      // Rethrow if this was initial fetch and we have no models yet
+      if (!this.models) {
+        throw error;
+      }
+
+    } 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);
+    }
+  }
+
+  /**
+   * Schedule retry for failed model fetch
+   * Implements exponential backoff
+   * @private
+   */
+  _scheduleRetry(context = null) {
+    // Clear any existing retry timer
+    if (this.retryTimer) {
+      clearTimeout(this.retryTimer);
+      this.retryTimer = null;
+    }
+
+    // Check if we've exceeded max retries
+    if (this.retryAttempts >= this.maxRetries) {
+      this.logger.error('Max retry attempts reached for model fetch', {
+        attempts: this.retryAttempts,
+        maxRetries: this.maxRetries,
+        lastError: this.lastError
+      });
+      return;
+    }
+
+    // Calculate delay with exponential backoff: 2s, 4s, 8s, etc.
+    const delay = this.retryDelay * Math.pow(2, this.retryAttempts);
+    this.retryAttempts++;
+
+    this.logger.info('Scheduling model fetch retry', {
+      attempt: this.retryAttempts,
+      maxRetries: this.maxRetries,
+      delayMs: delay
+    });
+
+    // Schedule retry
+    this.retryTimer = setTimeout(async () => {
+      this.logger.info('Executing scheduled model fetch retry', {
+        attempt: this.retryAttempts
+      });
+
+      try {
+        await this.fetchModels(context);
+        // Success - reset retry counter
+        this.retryAttempts = 0;
+        this.lastError = null;
+      } catch (error) {
+        // fetchModels will handle scheduling next retry
+        this.logger.warn('Retry attempt failed', {
+          attempt: this.retryAttempts,
+          error: error.message
+        });
+      }
+    }, delay);
+  }
+
+  /**
+   * Cancel any pending retry
+   * @private
+   */
+  _cancelRetry() {
+    if (this.retryTimer) {
+      clearTimeout(this.retryTimer);
+      this.retryTimer = null;
+      this.logger.debug('Cancelled pending model fetch retry');
+    }
+  }
+
+  /**
+   * Get service status
+   */
+  getStatus() {
+    return {
+      initialized: !!this.models,
+      lastFetched: this.lastFetched?.toISOString() || null,
+      modelCount: this.models?.length || 0,
+      isLoading: this.isLoading,
+      needsRefresh: this.needsRefresh(),
+      error: this.lastError || null,
+      retryAttempts: this.retryAttempts,
+      maxRetries: this.maxRetries,
+      hasError: !!this.lastError
+    };
+  }
+}
+
+export default ModelsService;