Update flare-ui/src/app/services/environment.service.ts

flare-ui/src/app/services/environment.service.ts

@@ -2,8 +2,8 @@
 // Path: /flare-ui/src/app/services/environment.service.ts
 
 import { Injectable } from '@angular/core';
-import { BehaviorSubject, Observable, throwError } from 'rxjs';
-import { Environment } from './api.service';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { Environment, ProviderSettings } from './api.service';
 
 export interface EnvironmentError {
   type: 'validation' | 'update' | 'unknown';
@@ -32,26 +32,22 @@ export class EnvironmentService {
   sttEnabled$ = this.sttEnabledSource.asObservable();
 
   constructor() {
-    // Load saved preferences
     this.loadPreferences();
   }
 
   private loadPreferences(): void {
     try {
-      // Load TTS preference
       const savedTTS = localStorage.getItem(this.TTS_KEY);
       if (savedTTS !== null) {
         this.ttsEnabledSource.next(savedTTS === 'true');
       }
       
-      // Load STT preference
       const savedSTT = localStorage.getItem(this.STT_KEY);
       if (savedSTT !== null) {
         this.sttEnabledSource.next(savedSTT === 'true');
       }
     } catch (error) {
       console.error('Error loading preferences:', error);
-      // Use defaults on error
       this.ttsEnabledSource.next(false);
       this.sttEnabledSource.next(false);
     }
@@ -65,7 +61,6 @@ export class EnvironmentService {
       
       this.ttsEnabledSource.next(enabled);
       
-      // Save preference
       try {
         localStorage.setItem(this.TTS_KEY, enabled.toString());
       } catch (error) {
@@ -86,7 +81,6 @@ export class EnvironmentService {
       
       this.sttEnabledSource.next(enabled);
       
-      // Save preference
       try {
         localStorage.setItem(this.STT_KEY, enabled.toString());
       } catch (error) {
@@ -109,30 +103,24 @@ export class EnvironmentService {
   
   updateEnvironment(env: Environment | null): void {
     try {
+      this.environmentSubject.next(env);
+      this.errorSubject.next(null);
+      
       if (env) {
-        // Validate environment object
-        this.validateEnvironment(env);
-        
-        // Check for changes
-        const currentEnv = this.environmentSubject.value;
-        const hasChanged = !currentEnv || 
-                          currentEnv.id !== env.id || 
-                          currentEnv.work_mode !== env.work_mode ||
-                          currentEnv.last_update_date !== env.last_update_date;
+        console.log('Environment updated:', {
+          llm_provider: env.llm_provider.name,
+          tts_provider: env.tts_provider.name,
+          stt_provider: env.stt_provider.name
+        });
         
-        if (hasChanged) {
-          console.log('Environment updated:', {
-            id: env.id,
-            name: env.name,
-            work_mode: env.work_mode,
-            version: env.active_version_id
-          });
+        // Update TTS/STT enabled states based on provider
+        if (env.tts_provider.name !== 'no_tts') {
+          this.setTTSEnabled(true);
+        }
+        if (env.stt_provider.name !== 'no_stt') {
+          this.setSTTEnabled(true);
         }
       }
-      
-      this.environmentSubject.next(env);
-      this.errorSubject.next(null); // Clear any previous errors
-      
     } catch (error: any) {
       this.handleError('update', error.message || 'Failed to update environment', error);
     }
@@ -142,10 +130,26 @@ export class EnvironmentService {
     return this.environmentSubject.value;
   }
 
+  getCurrentLLMProvider(): ProviderSettings | null {
+    const env = this.environmentSubject.value;
+    return env?.llm_provider || null;
+  }
+
+  getCurrentTTSProvider(): ProviderSettings | null {
+    const env = this.environmentSubject.value;
+    return env?.tts_provider || null;
+  }
+
+  getCurrentSTTProvider(): ProviderSettings | null {
+    const env = this.environmentSubject.value;
+    return env?.stt_provider || null;
+  }
+
   isGPTMode(): boolean {
     try {
       const env = this.environmentSubject.value;
-      return env?.work_mode?.toLowerCase()?.startsWith('gpt4o') || false;
+      const llmName = env?.llm_provider?.name?.toLowerCase();
+      return llmName?.startsWith('gpt4o') || false;
     } catch (error) {
       console.error('Error checking GPT mode:', error);
       return false;
@@ -154,17 +158,17 @@ export class EnvironmentService {
 
   getWorkMode(): string | null {
     const env = this.environmentSubject.value;
-    return env?.work_mode || null;
+    return env?.llm_provider?.name || null;
   }
 
-  isEnvironmentActive(): boolean {
+  isTTSAvailable(): boolean {
     const env = this.environmentSubject.value;
-    return env?.enabled === true;
+    return env?.tts_provider?.name !== 'no_tts' && env?.tts_provider?.name !== undefined;
   }
 
-  hasActiveVersion(): boolean {
+  isSTTAvailable(): boolean {
     const env = this.environmentSubject.value;
-    return !!env?.active_version_id;
+    return env?.stt_provider?.name !== 'no_stt' && env?.stt_provider?.name !== undefined;
   }
 
   // Check if environment supports a specific feature
@@ -174,18 +178,26 @@ export class EnvironmentService {
     
     switch (feature) {
       case 'tts':
-        return this.isTTSEnabled() && env.enabled;
+        return this.isTTSAvailable() && this.isTTSEnabled();
       case 'stt':
-        return this.isSTTEnabled() && env.enabled;
+        return this.isSTTAvailable() && this.isSTTEnabled();
       case 'realtime':
-        return this.isGPTMode() && env.enabled;
+        return this.isGPTMode();
       case 'streaming':
-        return env.enabled;
+        return true;
       default:
         return false;
     }
   }
 
+  // Get available providers
+  getAvailableProviders(type: 'llm' | 'tts' | 'stt'): any[] {
+    const env = this.environmentSubject.value;
+    if (!env?.providers) return [];
+    
+    return env.providers.filter(p => p.type === type);
+  }
+
   // Reset all settings
   reset(): void {
     try {
@@ -194,7 +206,6 @@ export class EnvironmentService {
       this.setSTTEnabled(false);
       this.errorSubject.next(null);
       
-      // Clear saved preferences
       try {
         localStorage.removeItem(this.TTS_KEY);
         localStorage.removeItem(this.STT_KEY);
@@ -210,8 +221,9 @@ export class EnvironmentService {
 
   // Get configuration summary
   getConfigSummary(): {
-    environment: string | null;
-    workMode: string | null;
+    llmProvider: string | null;
+    ttsProvider: string | null;
+    sttProvider: string | null;
     ttsEnabled: boolean;
     sttEnabled: boolean;
     features: string[];
@@ -225,37 +237,15 @@ export class EnvironmentService {
     if (this.supportsFeature('streaming')) features.push('Streaming');
     
     return {
-      environment: env?.name || null,
-      workMode: env?.work_mode || null,
+      llmProvider: env?.llm_provider?.name || null,
+      ttsProvider: env?.tts_provider?.name || null,
+      sttProvider: env?.stt_provider?.name || null,
       ttsEnabled: this.isTTSEnabled(),
       sttEnabled: this.isSTTEnabled(),
       features
     };
   }
 
-  private validateEnvironment(env: Environment): void {
-    if (!env.id) {
-      throw new Error('Environment must have an ID');
-    }
-    
-    if (!env.name || env.name.trim().length === 0) {
-      throw new Error('Environment must have a name');
-    }
-    
-    if (!env.project_id) {
-      throw new Error('Environment must be associated with a project');
-    }
-    
-    if (env.work_mode && !this.isValidWorkMode(env.work_mode)) {
-      throw new Error(`Invalid work mode: ${env.work_mode}`);
-    }
-  }
-
-  private isValidWorkMode(workMode: string): boolean {
-    const validModes = ['stream', 'batch', 'gpt4o', 'gpt4o-mini', 'gpt4o-realtime'];
-    return validModes.includes(workMode.toLowerCase());
-  }
-
   private handleError(type: EnvironmentError['type'], message: string, details?: any): void {
     const error: EnvironmentError = {
       type,
@@ -271,7 +261,14 @@ export class EnvironmentService {
   isReady(): Observable<boolean> {
     return new Observable(subscriber => {
       const sub = this.environment$.subscribe(env => {
-        subscriber.next(!!env && env.enabled && !!env.active_version_id);
+        // Environment is ready if we have all providers configured
+        const isReady = !!(
+          env && 
+          env.llm_provider && 
+          env.tts_provider && 
+          env.stt_provider
+        );
+        subscriber.next(isReady);
       });
       
       return () => sub.unsubscribe();