@loxia-labs/loxia-autopilot-one 1.0.1

package/src/services/apiKeyManager.js

@@ -0,0 +1,164 @@
+/**
+ * API Key Manager - Session-based API key storage and management
+ * 
+ * Purpose:
+ * - Store API keys per session (no persistent storage)
+ * - Manage both platform (Loxia) and vendor-specific keys
+ * - Provide keys to AI services based on model requirements
+ */
+
+class ApiKeyManager {
+  constructor(logger) {
+    this.logger = logger;
+    
+    // Session-based storage: sessionId -> { loxiaApiKey, vendorKeys: { anthropic, openai, etc. } }
+    this.sessionKeys = new Map();
+    
+    // Global fallback keys (can be set via config, but session keys take priority)
+    this.globalKeys = {
+      loxiaApiKey: null,
+      vendorKeys: {}
+    };
+  }
+
+  /**
+   * Set API keys for a session
+   * @param {string} sessionId - Session identifier
+   * @param {Object} keys - API keys object
+   * @param {string} keys.loxiaApiKey - Loxia platform API key
+   * @param {Object} keys.vendorKeys - Vendor-specific keys { anthropic: 'key', openai: 'key', etc. }
+   */
+  setSessionKeys(sessionId, keys) {
+    if (!sessionId) {
+      throw new Error('Session ID is required');
+    }
+
+    this.sessionKeys.set(sessionId, {
+      loxiaApiKey: keys.loxiaApiKey || null,
+      vendorKeys: keys.vendorKeys || {},
+      updatedAt: new Date().toISOString()
+    });
+
+    this.logger?.info('API keys updated for session', {
+      sessionId,
+      hasLoxiaKey: !!keys.loxiaApiKey,
+      vendorKeys: Object.keys(keys.vendorKeys || {}),
+      timestamp: new Date().toISOString()
+    });
+  }
+
+  /**
+   * Get API keys for a session
+   * @param {string} sessionId - Session identifier
+   * @returns {Object} API keys object
+   */
+  getSessionKeys(sessionId) {
+    if (!sessionId) {
+      return this.globalKeys;
+    }
+
+    const sessionKeys = this.sessionKeys.get(sessionId);
+    if (sessionKeys) {
+      return sessionKeys;
+    }
+
+    // Fallback to global keys
+    return this.globalKeys;
+  }
+
+  /**
+   * Get the appropriate API key for a model/request
+   * @param {string} sessionId - Session identifier
+   * @param {Object} options - Request options
+   * @param {boolean} options.platformProvided - Whether this is a platform-provided model
+   * @param {string} options.vendor - Vendor name (anthropic, openai, etc.)
+   * @returns {Object} { loxiaApiKey, vendorApiKey }
+   */
+  getKeysForRequest(sessionId, options = {}) {
+    const keys = this.getSessionKeys(sessionId);
+    
+    const result = {
+      loxiaApiKey: keys.loxiaApiKey,
+      vendorApiKey: null
+    };
+
+    // For direct access models, also include vendor-specific key
+    if (!options.platformProvided && options.vendor && keys.vendorKeys) {
+      result.vendorApiKey = keys.vendorKeys[options.vendor];
+    }
+
+    return result;
+  }
+
+  /**
+   * Remove API keys for a session
+   * @param {string} sessionId - Session identifier
+   */
+  removeSessionKeys(sessionId) {
+    if (this.sessionKeys.delete(sessionId)) {
+      this.logger?.info('API keys removed for session', { sessionId });
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Set global fallback API keys
+   * @param {Object} keys - Global API keys
+   */
+  setGlobalKeys(keys) {
+    this.globalKeys = {
+      loxiaApiKey: keys.loxiaApiKey || this.globalKeys.loxiaApiKey,
+      vendorKeys: { ...this.globalKeys.vendorKeys, ...(keys.vendorKeys || {}) }
+    };
+
+    this.logger?.info('Global API keys updated', {
+      hasLoxiaKey: !!this.globalKeys.loxiaApiKey,
+      vendorKeys: Object.keys(this.globalKeys.vendorKeys)
+    });
+  }
+
+  /**
+   * List all active sessions with API keys
+   * @returns {Array} Array of session information
+   */
+  getActiveSessions() {
+    return Array.from(this.sessionKeys.entries()).map(([sessionId, keys]) => ({
+      sessionId,
+      hasLoxiaKey: !!keys.loxiaApiKey,
+      vendorKeys: Object.keys(keys.vendorKeys || {}),
+      updatedAt: keys.updatedAt
+    }));
+  }
+
+  /**
+   * Clean up expired sessions (optional)
+   * @param {number} maxAge - Maximum age in milliseconds
+   */
+  cleanupExpiredSessions(maxAge = 24 * 60 * 60 * 1000) { // 24 hours default
+    const now = Date.now();
+    const expired = [];
+
+    for (const [sessionId, keys] of this.sessionKeys.entries()) {
+      const age = now - new Date(keys.updatedAt).getTime();
+      if (age > maxAge) {
+        expired.push(sessionId);
+      }
+    }
+
+    expired.forEach(sessionId => {
+      this.sessionKeys.delete(sessionId);
+    });
+
+    if (expired.length > 0) {
+      this.logger?.info('Cleaned up expired API key sessions', {
+        expiredSessions: expired.length,
+        remainingSessions: this.sessionKeys.size
+      });
+    }
+
+    return expired.length;
+  }
+}
+
+export default ApiKeyManager;

package/src/services/benchmarkService.js

@@ -0,0 +1,366 @@
+/**
+ * BenchmarkService - Manages model performance benchmarks for routing decisions
+ * 
+ * Purpose:
+ * - Fetch benchmark data from Azure backend
+ * - Provide local fallback data
+ * - Refresh benchmarks periodically
+ * - Supply benchmark data to model router
+ */
+
+import { MODEL_ROUTER_CONFIG, HTTP_STATUS } from '../utilities/constants.js';
+
+class BenchmarkService {
+  constructor(config, logger) {
+    this.config = config;
+    this.logger = logger;
+    
+    this.benchmarks = null;
+    this.lastUpdated = null;
+    this.isLoading = false;
+    
+    this.azureBackendUrl = 'https://autopilot-api.azurewebsites.net';
+    this.refreshInterval = MODEL_ROUTER_CONFIG.BENCHMARK_REFRESH_INTERVAL;
+  }
+
+  /**
+   * Initialize benchmark service and load initial data
+   */
+  async initialize() {
+    try {
+      await this.loadBenchmarks();
+      this._scheduleRefresh();
+      this.logger.info('Benchmark service initialized');
+    } catch (error) {
+      this.logger.error('Failed to initialize benchmark service', { error: error.message });
+      // Use fallback data on initialization failure
+      this.benchmarks = this._getFallbackBenchmarks();
+    }
+  }
+
+  /**
+   * Get current benchmark data
+   */
+  getBenchmarks() {
+    if (!this.benchmarks) {
+      this.logger.warn('No benchmark data available, using fallback');
+      return this._getFallbackBenchmarks();
+    }
+    return this.benchmarks;
+  }
+
+  /**
+   * Load benchmarks from Azure backend with fallback
+   */
+  async loadBenchmarks() {
+    if (this.isLoading) {
+      this.logger.debug('Benchmark loading already in progress');
+      return;
+    }
+
+    this.isLoading = true;
+
+    try {
+      // Try to load from Azure backend
+      const benchmarks = await this._fetchFromAzureBackend();
+      
+      if (benchmarks) {
+        this.benchmarks = benchmarks;
+        this.lastUpdated = new Date();
+        this.logger.info('Benchmarks loaded from Azure backend', { 
+          modelCount: benchmarks.models?.length || 0 
+        });
+      } else {
+        throw new Error('No benchmark data received from backend');
+      }
+
+    } catch (error) {
+      this.logger.warn('Failed to fetch benchmarks from Azure backend, using fallback', {
+        error: error.message
+      });
+      
+      // Use fallback data
+      this.benchmarks = this._getFallbackBenchmarks();
+      this.lastUpdated = new Date();
+
+    } finally {
+      this.isLoading = false;
+    }
+  }
+
+  /**
+   * Get benchmark comparison table formatted for PHI-4 router
+   */
+  getBenchmarkTable() {
+    const benchmarks = this.getBenchmarks();
+    
+    return {
+      lastUpdated: this.lastUpdated?.toISOString() || 'unknown',
+      models: benchmarks.models || [],
+      tasks: benchmarks.tasks || {},
+      summary: this._generateBenchmarkSummary(benchmarks)
+    };
+  }
+
+  /**
+   * Check if benchmarks need refresh
+   */
+  needsRefresh() {
+    if (!this.lastUpdated) return true;
+    
+    const timeSinceUpdate = Date.now() - this.lastUpdated.getTime();
+    return timeSinceUpdate > this.refreshInterval;
+  }
+
+  /**
+   * Fetch benchmarks from Azure backend
+   * @private
+   */
+  async _fetchFromAzureBackend() {
+    const url = `${this.azureBackendUrl}/llm/model-benchmarks`;
+    
+    // Get platform API key
+    let apiKey = null;
+    if (this.config.apiKey) {
+      apiKey = this.config.apiKey;
+    }
+
+    const fetchOptions = {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+        ...(apiKey && { 'Authorization': `Bearer ${apiKey}` })
+      },
+      timeout: 10000 // 10 second timeout
+    };
+
+    this.logger.debug('Fetching benchmarks from Azure backend', { url });
+
+    const response = await fetch(url, fetchOptions);
+
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+
+    const data = await response.json();
+    return data;
+  }
+
+  /**
+   * Get fallback benchmark data
+   * @private
+   */
+  _getFallbackBenchmarks() {
+    return {
+      version: '1.0.0',
+      lastUpdated: new Date().toISOString(),
+      source: 'fallback',
+      models: [
+        {
+          name: 'anthropic-sonnet',
+          provider: 'anthropic',
+          tasks: {
+            coding: { score: 85, speed: 'medium', cost: 'medium' },
+            analysis: { score: 90, speed: 'medium', cost: 'medium' },
+            'quick-tasks': { score: 75, speed: 'fast', cost: 'low' },
+            creative: { score: 88, speed: 'medium', cost: 'medium' }
+          },
+          strengths: ['reasoning', 'code-understanding', 'analysis'],
+          contextWindow: 200000,
+          maxTokens: 4096
+        },
+        {
+          name: 'anthropic-opus',
+          provider: 'anthropic',
+          tasks: {
+            coding: { score: 92, speed: 'slow', cost: 'high' },
+            analysis: { score: 95, speed: 'slow', cost: 'high' },
+            'quick-tasks': { score: 80, speed: 'medium', cost: 'high' },
+            creative: { score: 95, speed: 'slow', cost: 'high' }
+          },
+          strengths: ['complex-reasoning', 'creative-writing', 'deep-analysis'],
+          contextWindow: 200000,
+          maxTokens: 4096
+        },
+        {
+          name: 'anthropic-haiku',
+          provider: 'anthropic',
+          tasks: {
+            coding: { score: 70, speed: 'fast', cost: 'low' },
+            analysis: { score: 75, speed: 'fast', cost: 'low' },
+            'quick-tasks': { score: 85, speed: 'very-fast', cost: 'very-low' },
+            creative: { score: 70, speed: 'fast', cost: 'low' }
+          },
+          strengths: ['speed', 'simple-tasks', 'cost-efficiency'],
+          contextWindow: 200000,
+          maxTokens: 4096
+        },
+        {
+          name: 'gpt-4',
+          provider: 'openai',
+          tasks: {
+            coding: { score: 88, speed: 'medium', cost: 'high' },
+            analysis: { score: 85, speed: 'medium', cost: 'high' },
+            'quick-tasks': { score: 80, speed: 'medium', cost: 'high' },
+            creative: { score: 90, speed: 'medium', cost: 'high' }
+          },
+          strengths: ['general-purpose', 'coding', 'problem-solving'],
+          contextWindow: 128000,
+          maxTokens: 4096
+        },
+        {
+          name: 'gpt-4-mini',
+          provider: 'openai',
+          tasks: {
+            coding: { score: 75, speed: 'fast', cost: 'low' },
+            analysis: { score: 70, speed: 'fast', cost: 'low' },
+            'quick-tasks': { score: 80, speed: 'very-fast', cost: 'very-low' },
+            creative: { score: 72, speed: 'fast', cost: 'low' }
+          },
+          strengths: ['speed', 'cost-efficiency', 'simple-coding'],
+          contextWindow: 128000,
+          maxTokens: 16384
+        },
+        {
+          name: 'azure-ai-grok3',
+          provider: 'xai',
+          tasks: {
+            coding: { score: 82, speed: 'medium', cost: 'medium' },
+            analysis: { score: 85, speed: 'medium', cost: 'medium' },
+            'quick-tasks': { score: 78, speed: 'fast', cost: 'medium' },
+            creative: { score: 88, speed: 'medium', cost: 'medium' }
+          },
+          strengths: ['reasoning', 'real-time-data', 'analysis'],
+          contextWindow: 128000,
+          maxTokens: 4096
+        },
+        {
+          name: 'deepseek-r1',
+          provider: 'deepseek',
+          tasks: {
+            coding: { score: 90, speed: 'medium', cost: 'low' },
+            analysis: { score: 80, speed: 'medium', cost: 'low' },
+            'quick-tasks': { score: 75, speed: 'fast', cost: 'very-low' },
+            creative: { score: 65, speed: 'medium', cost: 'low' }
+          },
+          strengths: ['coding', 'reasoning', 'cost-efficiency'],
+          contextWindow: 128000,
+          maxTokens: 8192
+        },
+        {
+          name: 'phi-4',
+          provider: 'microsoft',
+          tasks: {
+            coding: { score: 72, speed: 'fast', cost: 'very-low' },
+            analysis: { score: 78, speed: 'fast', cost: 'very-low' },
+            'quick-tasks': { score: 82, speed: 'very-fast', cost: 'very-low' },
+            creative: { score: 68, speed: 'fast', cost: 'very-low' }
+          },
+          strengths: ['speed', 'efficiency', 'small-tasks'],
+          contextWindow: 16384,
+          maxTokens: 2048
+        }
+      ],
+      tasks: {
+        coding: {
+          description: 'Programming, debugging, code review, refactoring',
+          topModels: ['deepseek-r1', 'anthropic-opus', 'gpt-4', 'anthropic-sonnet']
+        },
+        analysis: {
+          description: 'Data analysis, research, document review, reasoning',
+          topModels: ['anthropic-opus', 'anthropic-sonnet', 'azure-ai-grok3', 'gpt-4']
+        },
+        'quick-tasks': {
+          description: 'Simple questions, formatting, quick edits, summaries',
+          topModels: ['anthropic-haiku', 'phi-4', 'gpt-4-mini', 'azure-ai-grok3']
+        },
+        creative: {
+          description: 'Writing, brainstorming, content creation, storytelling',
+          topModels: ['anthropic-opus', 'gpt-4', 'azure-ai-grok3', 'anthropic-sonnet']
+        }
+      }
+    };
+  }
+
+  /**
+   * Generate benchmark summary for router
+   * @private
+   */
+  _generateBenchmarkSummary(benchmarks) {
+    const models = benchmarks.models || [];
+    
+    return {
+      totalModels: models.length,
+      taskCategories: Object.keys(benchmarks.tasks || {}),
+      bestForCoding: this._getBestModelForTask(models, 'coding'),
+      bestForAnalysis: this._getBestModelForTask(models, 'analysis'),
+      bestForQuickTasks: this._getBestModelForTask(models, 'quick-tasks'),
+      bestForCreative: this._getBestModelForTask(models, 'creative'),
+      fastestModel: this._getFastestModel(models),
+      mostCostEfficient: this._getMostCostEfficient(models)
+    };
+  }
+
+  _getBestModelForTask(models, task) {
+    return models
+      .filter(m => m.tasks && m.tasks[task])
+      .sort((a, b) => (b.tasks[task].score || 0) - (a.tasks[task].score || 0))[0]?.name || 'unknown';
+  }
+
+  _getFastestModel(models) {
+    const speedOrder = { 'very-fast': 4, 'fast': 3, 'medium': 2, 'slow': 1 };
+    return models
+      .sort((a, b) => {
+        const aSpeed = Math.max(...Object.values(a.tasks || {}).map(t => speedOrder[t.speed] || 0));
+        const bSpeed = Math.max(...Object.values(b.tasks || {}).map(t => speedOrder[t.speed] || 0));
+        return bSpeed - aSpeed;
+      })[0]?.name || 'unknown';
+  }
+
+  _getMostCostEfficient(models) {
+    const costOrder = { 'very-low': 4, 'low': 3, 'medium': 2, 'high': 1 };
+    return models
+      .sort((a, b) => {
+        const aCost = Math.max(...Object.values(a.tasks || {}).map(t => costOrder[t.cost] || 0));
+        const bCost = Math.max(...Object.values(b.tasks || {}).map(t => costOrder[t.cost] || 0));
+        return bCost - aCost;
+      })[0]?.name || 'unknown';
+  }
+
+  /**
+   * Schedule periodic refresh
+   * @private
+   */
+  _scheduleRefresh() {
+    setInterval(async () => {
+      if (this.needsRefresh()) {
+        this.logger.debug('Refreshing benchmark data');
+        await this.loadBenchmarks();
+      }
+    }, this.refreshInterval);
+  }
+
+  /**
+   * Force refresh benchmarks
+   */
+  async forceRefresh() {
+    this.logger.info('Force refreshing benchmark data');
+    await this.loadBenchmarks();
+  }
+
+  /**
+   * Get service status
+   */
+  getStatus() {
+    return {
+      initialized: !!this.benchmarks,
+      lastUpdated: this.lastUpdated?.toISOString() || null,
+      source: this.benchmarks?.source || 'unknown',
+      modelCount: this.benchmarks?.models?.length || 0,
+      isLoading: this.isLoading,
+      needsRefresh: this.needsRefresh()
+    };
+  }
+}
+
+export default BenchmarkService;