fss-link 1.0.49 → 1.0.51

package/dist/config/modelManager.ts

@@ -1,326 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { AuthType, ModelConfig } from 'fss-link-core';
-import { getFSSLinkDatabase } from './database.js';
-
-/**
- * Model Manager - High-level interface for model switching and persistence
- * Implements ModelStateProvider for integration with Config class
- */
-export class ModelManager {
-  private async getDb() {
-    return await getFSSLinkDatabase();
-  }
-
-  /**
-   * Set up a new model configuration and make it active
-   * Implements ModelStateProvider.setActiveModel
-   */
-  async setActiveModel(config: ModelConfig): Promise<number> {
-    const db = await this.getDb();
-    
-    // Insert the model and get its ID
-    const modelId = await db.upsertModelConfig(config);
-    
-    // Set as active model (deactivates others)
-    await db.setActiveModel(modelId);
-    
-    // Update environment variables for immediate use
-    await this.updateEnvironmentFromModel(config);
-    
-    return modelId;
-  }
-
-  /**
-   * Set up a new model configuration and make it active (legacy method)
-   */
-  async configureModel(
-    authType: AuthType,
-    modelName: string,
-    endpointUrl?: string,
-    apiKey?: string,
-    displayName?: string
-  ): Promise<number> {
-    const db = await this.getDb();
-    const config: ModelConfig = {
-      authType: this.mapAuthType(authType),
-      modelName,
-      endpointUrl,
-      apiKey,
-      displayName,
-      isFavorite: false,
-      isActive: true, // Make this the active model
-    };
-
-    // Insert the model and get its ID
-    const modelId = await db.upsertModelConfig(config);
-    
-    // Set as active model (deactivates others)
-    await db.setActiveModel(modelId);
-    
-    // Update environment variables for immediate use
-    await this.updateEnvironmentFromModel(config);
-    
-    return modelId;
-  }
-
-  /**
-   * Switch to an existing model by ID
-   */
-  async switchToModel(modelId: number): Promise<boolean> {
-    try {
-      const db = await this.getDb();
-      await db.setActiveModel(modelId);
-      
-      const activeModel = await db.getActiveModel();
-      if (activeModel) {
-        await this.updateEnvironmentFromModel(activeModel);
-        return true;
-      }
-      
-      return false;
-    } catch (error) {
-      console.error('Failed to switch to model:', error);
-      return false;
-    }
-  }
-
-  /**
-   * Get the currently active model
-   */
-  async getActiveModel(): Promise<ModelConfig | null> {
-    const db = await this.getDb();
-    return await db.getActiveModel();
-  }
-
-  /**
-   * Get all configured models
-   */
-  async getAllModels(): Promise<ModelConfig[]> {
-    const db = await this.getDb();
-    return await db.getAllModels();
-  }
-
-  /**
-   * Get favorite models
-   */
-  async getFavoriteModels(): Promise<ModelConfig[]> {
-    const db = await this.getDb();
-    return await db.getFavoriteModels();
-  }
-
-  /**
-   * Get recently used models
-   */
-  async getRecentModels(limit: number = 5): Promise<ModelConfig[]> {
-    const db = await this.getDb();
-    return await db.getRecentModels(limit);
-  }
-
-  /**
-   * Toggle favorite status for a model
-   */
-  async toggleFavorite(modelId: number): Promise<void> {
-    const db = await this.getDb();
-    await db.toggleModelFavorite(modelId);
-  }
-
-  /**
-   * Delete a model configuration
-   */
-  async deleteModel(modelId: number): Promise<void> {
-    const db = await this.getDb();
-    await db.deleteModel(modelId);
-  }
-
-  /**
-   * Initialize environment variables from active model on startup
-   * Implements ModelStateProvider.initializeFromStore
-   */
-  async initializeFromStore(): Promise<boolean> {
-    const db = await this.getDb();
-    const activeModel = await db.getActiveModel();
-    
-    if (activeModel) {
-      await this.updateEnvironmentFromModel(activeModel);
-      return true;
-    }
-    
-    return false;
-  }
-
-  /**
-   * Check if we have a valid active model configuration
-   */
-  async hasValidConfiguration(): Promise<boolean> {
-    const db = await this.getDb();
-    const activeModel = await db.getActiveModel();
-    return activeModel !== null;
-  }
-
-  /**
-   * Get current auth type from active model
-   * Implements ModelStateProvider.getCurrentAuthType
-   */
-  async getCurrentAuthType(): Promise<string | undefined> {
-    const db = await this.getDb();
-    const activeModel = await db.getActiveModel();
-    if (!activeModel || !activeModel.authType) return undefined;
-    
-    const authType = this.mapToFSSLinkAuthType(activeModel.authType);
-    return authType as string;
-  }
-
-  /**
-   * Get current auth type as FSS Link AuthType enum (legacy method)
-   */
-  async getCurrentFSSAuthType(): Promise<AuthType | undefined> {
-    const db = await this.getDb();
-    const activeModel = await db.getActiveModel();
-    if (!activeModel || !activeModel.authType) return undefined;
-    
-    return this.mapToFSSLinkAuthType(activeModel.authType);
-  }
-
-  /**
-   * Update process environment variables from model configuration
-   * Now includes provider settings like context window
-   */
-  private async updateEnvironmentFromModel(model: ModelConfig): Promise<void> {
-    // Load provider settings if we have a model ID
-    let settings: Record<string, string> = {};
-    if (model.id) {
-      try {
-        const db = await this.getDb();
-        settings = await db.getProviderSettings(model.id);
-      } catch (error) {
-        console.warn('Failed to load provider settings:', error);
-      }
-    }
-    switch (model.authType) {
-      case 'openai':
-        process.env['OPENAI_API_KEY'] = model.apiKey || '';
-        process.env['OPENAI_BASE_URL'] = model.endpointUrl || '';
-        process.env['OPENAI_MODEL'] = model.modelName || '';
-        break;
-        
-      case 'ollama':
-        process.env['OLLAMA_API_KEY'] = model.apiKey || '1';
-        process.env['OLLAMA_BASE_URL'] = model.endpointUrl || 'http://localhost:11434/v1';
-        process.env['OLLAMA_MODEL'] = model.modelName || '';
-        break;
-        
-      case 'lmstudio':
-        process.env['LM_STUDIO_API_KEY'] = model.apiKey || '1';
-        process.env['LM_STUDIO_BASE_URL'] = model.endpointUrl || 'http://localhost:1234/v1';
-        process.env['LM_STUDIO_MODEL'] = model.modelName || '';
-        break;
-        
-      case 'qwen-oauth':
-        // FSS Link OAuth doesn't use these environment variables
-        break;
-        
-      default:
-        // Unknown auth type, no environment variables to set
-        console.warn(`Unknown auth type: ${model.authType}`);
-        break;
-    }
-    
-    // Apply provider settings to the global configuration if available
-    if (Object.keys(settings).length > 0) {
-      await this.applyProviderSettings(settings);
-    }
-  }
-
-  /**
-   * Apply provider settings to the global configuration
-   */
-  private async applyProviderSettings(settings: Record<string, string>): Promise<void> {
-    try {
-      const { getConfig } = await import('./settings.js');
-      const config = getConfig();
-      
-      // Convert string settings to appropriate types and update config
-      const samplingParams: Record<string, unknown> = {};
-      
-      if (settings.num_ctx) {
-        samplingParams.num_ctx = parseInt(settings.num_ctx, 10);
-      }
-      
-      if (settings.temperature) {
-        samplingParams.temperature = parseFloat(settings.temperature);
-      }
-      
-      if (settings.top_p) {
-        samplingParams.top_p = parseFloat(settings.top_p);
-      }
-      
-      if (settings.top_k) {
-        samplingParams.top_k = parseInt(settings.top_k, 10);
-      }
-      
-      if (Object.keys(samplingParams).length > 0) {
-        config.setContentGeneratorSamplingParams(samplingParams);
-      }
-    } catch (error) {
-      console.warn('Failed to apply provider settings:', error);
-    }
-  }
-
-  /**
-   * Map FSS Link AuthType to database auth type
-   */
-  private mapAuthType(authType: AuthType): 'openai' | 'ollama' | 'lmstudio' | 'qwen-oauth' {
-    switch (authType) {
-      case AuthType.USE_OPENAI:
-        return 'openai';
-      case AuthType.OLLAMA:
-        return 'ollama';
-      case AuthType.LM_STUDIO:
-        return 'lmstudio';
-      case AuthType.QWEN_OAUTH:
-        return 'qwen-oauth';
-      default:
-        throw new Error(`Unsupported auth type: ${authType}`);
-    }
-  }
-
-  /**
-   * Map database auth type to FSS Link AuthType
-   */
-  private mapToFSSLinkAuthType(authType: string): AuthType {
-    if (!authType) {
-      throw new Error(`Auth type is null or undefined`);
-    }
-    
-    switch (authType) {
-      case 'openai':
-        return AuthType.USE_OPENAI;
-      case 'ollama':
-        return AuthType.OLLAMA;
-      case 'lmstudio':
-        return AuthType.LM_STUDIO;
-      case 'qwen-oauth':
-        return AuthType.QWEN_OAUTH;
-      default:
-        throw new Error(`Unsupported database auth type: ${authType}`);
-    }
-  }
-}
-
-// Singleton instance
-let modelManagerInstance: ModelManager | null = null;
-
-/**
- * Get the global model manager instance
- */
-export function getModelManager(): ModelManager {
-  if (!modelManagerInstance) {
-    modelManagerInstance = new ModelManager();
-  }
-  return modelManagerInstance;
-}

package/dist/config/providerManager.ts

@@ -1,244 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { AuthType, ModelConfig } from 'fss-link-core';
-import { getFSSLinkDatabase } from './database.js';
-
-/**
- * Comprehensive Provider Manager
- * Handles all provider configurations, persistence, and smart defaults
- */
-export class ProviderManager {
-  private static instance: ProviderManager;
-  
-  static getInstance(): ProviderManager {
-    if (!ProviderManager.instance) {
-      ProviderManager.instance = new ProviderManager();
-    }
-    return ProviderManager.instance;
-  }
-
-  /**
-   * Get all configured providers with usage statistics
-   */
-  async getAllProviders(): Promise<ModelConfig[]> {
-    const db = await getFSSLinkDatabase();
-    return await db.getAllModels();
-  }
-
-  /**
-   * Get smart default provider based on usage and user preferences
-   */
-  async getDefaultProvider(): Promise<ModelConfig | null> {
-    const db = await getFSSLinkDatabase();
-    return await db.getSmartDefaultProvider();
-  }
-
-  /**
-   * Save provider configuration with automatic usage tracking setup
-   */
-  async saveProvider(config: ModelConfig): Promise<number> {
-    const db = await getFSSLinkDatabase();
-    const providerId = await db.upsertModelConfig(config);
-    
-    // Save additional settings if present
-    if (config.additionalSettings) {
-      for (const [key, value] of Object.entries(config.additionalSettings)) {
-        await db.saveProviderSetting(providerId, key, JSON.stringify(value));
-      }
-    }
-
-    return providerId;
-  }
-
-  /**
-   * Record provider usage for intelligent defaults
-   */
-  async recordUsage(providerId: number, tokensUsed: number, sessionDurationMs: number): Promise<void> {
-    const db = await getFSSLinkDatabase();
-    await db.recordProviderUsage(providerId, tokensUsed, Math.floor(sessionDurationMs / 1000));
-  }
-
-  /**
-   * Get custom endpoints for a provider
-   */
-  async getCustomEndpoints(providerId: number): Promise<Array<Record<string, unknown>>> {
-    const db = await getFSSLinkDatabase();
-    return await db.getCustomEndpoints(providerId);
-  }
-
-  /**
-   * Save custom endpoint
-   */
-  async saveCustomEndpoint(
-    providerId: number, 
-    name: string, 
-    url: string, 
-    description?: string, 
-    isDefault = false
-  ): Promise<number> {
-    const db = await getFSSLinkDatabase();
-    return await db.saveCustomEndpoint(providerId, name, url, description, isDefault);
-  }
-
-  /**
-   * Get provider-specific settings (like sampling params, API keys, etc.)
-   */
-  async getProviderSettings(providerId: number): Promise<Record<string, unknown>> {
-    const db = await getFSSLinkDatabase();
-    const settings = await db.getProviderSettings(providerId);
-    
-    // Parse JSON values back to their original types
-    const parsed: Record<string, unknown> = {};
-    for (const [key, value] of Object.entries(settings)) {
-      try {
-        parsed[key] = JSON.parse(value);
-      } catch {
-        parsed[key] = value; // Keep as string if not valid JSON
-      }
-    }
-    
-    return parsed;
-  }
-
-  /**
-   * Save provider-specific setting
-   */
-  async saveProviderSetting(providerId: number, key: string, value: unknown): Promise<void> {
-    const db = await getFSSLinkDatabase();
-    const serializedValue = typeof value === 'string' ? value : JSON.stringify(value);
-    await db.saveProviderSetting(providerId, key, serializedValue);
-  }
-
-  /**
-   * Get providers by type (OpenAI, Ollama, etc.)
-   */
-  async getProvidersByType(authType: AuthType): Promise<ModelConfig[]> {
-    const allProviders = await this.getAllProviders();
-    return allProviders.filter(p => p.authType === authType);
-  }
-
-  /**
-   * Mark provider as favorite (affects smart default selection)
-   */
-  async setFavoriteProvider(providerId: number, isFavorite: boolean): Promise<void> {
-    const db = await getFSSLinkDatabase();
-    
-    // If setting as favorite, unmark others as favorite for this auth type
-    if (isFavorite) {
-      const provider = await db.getModelById(providerId);
-      if (provider) {
-        const sameTypeProviders = await this.getProvidersByType(provider.authType);
-        for (const otherProvider of sameTypeProviders) {
-          if (otherProvider.id !== providerId && otherProvider.isFavorite) {
-            await this.updateProvider(otherProvider.id!, { ...otherProvider, isFavorite: false });
-          }
-        }
-      }
-    }
-    
-    const existingProvider = await db.getModelById(providerId);
-    if (existingProvider) {
-      await db.upsertModelConfig({ ...existingProvider, isFavorite });
-    }
-  }
-
-  /**
-   * Update provider configuration
-   */
-  async updateProvider(providerId: number, updates: Partial<ModelConfig>): Promise<void> {
-    const db = await getFSSLinkDatabase();
-    const existing = await db.getModelById(providerId);
-    if (existing) {
-      const updated = { ...existing, ...updates };
-      await db.upsertModelConfig(updated);
-    }
-  }
-
-  /**
-   * Delete provider configuration
-   */
-  async deleteProvider(providerId: number): Promise<void> {
-    const _db = await getFSSLinkDatabase();
-    // Note: This would need to be added to the database class
-    // For now, we can mark as inactive
-    await this.updateProvider(providerId, { isActive: false });
-  }
-
-  /**
-   * Get usage statistics for all providers
-   */
-  async getUsageStatistics(): Promise<Record<number, unknown>> {
-    const _db = await getFSSLinkDatabase();
-    const allProviders = await this.getAllProviders();
-    const stats: Record<number, unknown> = {};
-    
-    for (const provider of allProviders) {
-      if (provider.id) {
-        // This would need to be implemented in the database class
-        // stats[provider.id] = await db.getProviderUsageStats(provider.id);
-      }
-    }
-    
-    return stats;
-  }
-
-  /**
-   * Auto-configure provider based on successful authentication
-   */
-  async autoConfigureFromSuccess(
-    authType: AuthType,
-    modelName: string,
-    endpointUrl?: string,
-    apiKey?: string,
-    additionalConfig?: Record<string, unknown>
-  ): Promise<number> {
-    const config: ModelConfig = {
-      authType,
-      modelName,
-      endpointUrl,
-      apiKey,
-      displayName: `${authType} - ${modelName}`,
-      isFavorite: false,
-      isActive: true,
-      additionalSettings: additionalConfig
-    };
-
-    const providerId = await this.saveProvider(config);
-    
-    // Mark as recently used
-    await this.recordUsage(providerId, 0, 0);
-    
-    return providerId;
-  }
-
-  /**
-   * Get recommended providers based on usage patterns
-   */
-  async getRecommendedProviders(limit = 5): Promise<ModelConfig[]> {
-    // This would implement intelligent recommendations based on:
-    // - Recent usage
-    // - Success rates
-    // - Performance metrics
-    // - User preferences
-    
-    const allProviders = await this.getAllProviders();
-    
-    // For now, return most recently used active providers
-    return allProviders
-      .filter(p => p.isActive)
-      .sort((a, b) => {
-        // Sort by favorite first, then by last used
-        if (a.isFavorite && !b.isFavorite) return -1;
-        if (!a.isFavorite && b.isFavorite) return 1;
-        
-        const aTime = a.lastUsed?.getTime() || 0;
-        const bTime = b.lastUsed?.getTime() || 0;
-        return bTime - aTime;
-      })
-      .slice(0, limit);
-  }
-}