@vybestack/llxprt-code-core 0.1.19-beta → 0.1.19

package/dist/src/providers/gemini/GeminiProvider.js

@@ -4,65 +4,115 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { AuthType, ContentGeneratorRole, AuthenticationRequiredError, getCoreSystemPromptAsync, createCodeAssistContentGenerator, } from '@vybestack/llxprt-code-core';
-export class GeminiProvider {
-    name = 'gemini';
-    apiKey;
+import { BaseProvider } from '../BaseProvider.js';
+import { getSettingsService } from '../../settings/settingsServiceInstance.js';
+export class GeminiProvider extends BaseProvider {
     authMode = 'none';
-    config;
+    geminiConfig;
     currentModel = 'gemini-2.5-pro';
     modelExplicitlySet = false;
     authDetermined = false;
     baseURL;
     modelParams;
     toolSchemas;
-    constructor(apiKey, baseURL, config) {
-        // For consistency with other providers
-        this.apiKey = apiKey;
-        // baseURL is not used by Gemini but kept for consistent interface
-        this.config = config;
+    geminiOAuthManager;
+    constructor(apiKey, baseURL, config, oauthManager) {
+        // Initialize base provider with auth configuration
+        // Check if OAuth is enabled for Gemini
+        let oauthEnabled = false;
+        if (oauthManager) {
+            // Cast to specific interface with isOAuthEnabled method
+            const manager = oauthManager;
+            if (manager.isOAuthEnabled &&
+                typeof manager.isOAuthEnabled === 'function') {
+                oauthEnabled = manager.isOAuthEnabled('gemini');
+            }
+        }
+        const baseConfig = {
+            name: 'gemini',
+            apiKey,
+            baseURL,
+            cliKey: apiKey, // CLI --key argument
+            envKeyNames: ['GEMINI_API_KEY', 'GOOGLE_API_KEY'],
+            isOAuthEnabled: oauthEnabled, // Check if OAuth is enabled
+            oauthProvider: 'gemini',
+            oauthManager, // Keep the manager for checking enablement
+        };
+        super(baseConfig);
+        // Store Gemini-specific configuration
+        this.geminiConfig = config;
+        this.baseURL = baseURL;
+        this.geminiOAuthManager = oauthManager;
         // Do not determine auth mode on instantiation.
         // This will be done lazily when a chat completion is requested.
     }
+    /**
+     * Updates OAuth configuration based on current OAuth manager state
+     */
+    updateOAuthState() {
+        if (this.geminiOAuthManager) {
+            const manager = this.geminiOAuthManager;
+            if (manager.isOAuthEnabled &&
+                typeof manager.isOAuthEnabled === 'function') {
+                const isEnabled = manager.isOAuthEnabled('gemini');
+                // Update the OAuth configuration if state has changed
+                this.updateOAuthConfig(isEnabled, 'gemini', this.geminiOAuthManager);
+            }
+        }
+    }
     /**
      * Determines the best available authentication method based on environment variables
-     * and existing configuration. Follows the hierarchy: Vertex AI → Gemini API key → OAuth
+     * and existing configuration. Now uses lazy evaluation with proper precedence chain.
      */
-    determineBestAuth() {
-        // Skip if already determined
-        if (this.authDetermined) {
-            return;
-        }
-        // Mark as determined early to prevent concurrent determinations
-        this.authDetermined = true;
-        // Check if user explicitly selected USE_NONE via the content generator config
-        const authType = this.config?.getContentGeneratorConfig()?.authType;
-        if (authType === AuthType.USE_NONE) {
-            this.authMode = 'none';
-            return;
-        }
-        // If authType is USE_PROVIDER and no credentials exist, fall back to OAuth
-        if (authType === AuthType.USE_PROVIDER) {
-            if (!this.hasVertexAICredentials() && !this.hasGeminiAPIKey()) {
+    async determineBestAuth() {
+        // Re-check OAuth enablement state before determining auth
+        this.updateOAuthState();
+        // Use the base provider's auth precedence resolution
+        try {
+            const token = await this.getAuthToken();
+            // Check for special OAuth signal
+            if (token === 'USE_LOGIN_WITH_GOOGLE') {
                 this.authMode = 'oauth';
-                return;
+                this.authDetermined = true;
+                return token; // Return the magic token
             }
+            // Determine auth mode based on resolved authentication method
+            const authMethodName = await this.getAuthMethodName();
+            if (authMethodName?.startsWith('oauth-')) {
+                this.authMode = 'oauth';
+            }
+            else if (this.hasVertexAICredentials()) {
+                this.authMode = 'vertex-ai';
+                this.setupVertexAIAuth();
+            }
+            else if (this.hasGeminiAPIKey() || authMethodName?.includes('key')) {
+                this.authMode = 'gemini-api-key';
+            }
+            else {
+                this.authMode = 'none';
+            }
+            this.authDetermined = true;
+            return token;
         }
-        // Check for Vertex AI credentials first
-        if (this.hasVertexAICredentials()) {
-            this.authMode = 'vertex-ai';
-            this.setupVertexAIAuth();
-        }
-        // Check for Gemini API key second
-        else if (this.hasGeminiAPIKey()) {
-            this.authMode = 'gemini-api-key';
-            // API key is already in environment, no additional setup needed
-        }
-        // Fall back to OAuth (will prompt user if needed)
-        else {
-            this.authMode = 'oauth';
-            // OAuth will be handled by the existing auth system
+        catch (error) {
+            // Handle case where no auth is available
+            const authType = this.geminiConfig?.getContentGeneratorConfig()?.authType;
+            if (authType === AuthType.USE_NONE) {
+                this.authMode = 'none';
+                this.authDetermined = true;
+                throw new AuthenticationRequiredError('Authentication is set to USE_NONE but no credentials are available', this.authMode, ['GEMINI_API_KEY', 'GOOGLE_API_KEY']);
+            }
+            throw error;
         }
     }
+    /**
+     * Implementation of BaseProvider abstract method
+     * Determines if this provider supports OAuth authentication
+     */
+    supportsOAuth() {
+        // Gemini always supports Google OAuth
+        return true;
+    }
     /**
      * Checks if Vertex AI credentials are available
      */
@@ -75,7 +125,7 @@ export class GeminiProvider {
      * Checks if Gemini API key is available
      */
     hasGeminiAPIKey() {
-        return !!this.apiKey || !!process.env.GEMINI_API_KEY;
+        return !!process.env.GEMINI_API_KEY;
     }
     /**
      * Sets up environment variables for Vertex AI authentication
@@ -88,17 +138,18 @@ export class GeminiProvider {
      * Sets the config instance for reading OAuth credentials
      */
     setConfig(config) {
-        this.config = config;
+        this.geminiConfig = config;
         // Sync with config model if user hasn't explicitly set a model
         // This ensures consistency between config and provider state
         const configModel = config.getModel();
         if (!this.modelExplicitlySet && configModel) {
             this.currentModel = configModel;
         }
+        // Update OAuth configuration based on config
+        const authType = config.getContentGeneratorConfig()?.authType;
+        this.updateOAuthConfig(authType === AuthType.LOGIN_WITH_GOOGLE, 'gemini', this.geminiOAuthManager);
         // Clear auth cache when config changes to allow re-determination
         this.authDetermined = false;
-        // Re-determine auth after config is set
-        this.determineBestAuth();
     }
     async getModels() {
         // For OAuth mode, return fixed list of models
@@ -126,7 +177,7 @@ export class GeminiProvider {
         }
         // For API key modes (gemini-api-key or vertex-ai), try to fetch real models
         if (this.authMode === 'gemini-api-key' || this.authMode === 'vertex-ai') {
-            const apiKey = this.apiKey || process.env.GEMINI_API_KEY;
+            const apiKey = (await this.getAuthToken()) || process.env.GEMINI_API_KEY;
             if (apiKey) {
                 try {
                     const url = this.baseURL
@@ -206,39 +257,20 @@ export class GeminiProvider {
                 console.log('DEBUG: GeminiProvider.generateChatCompletion called with messages:', JSON.stringify(messages, null, 2));
             }
         }
-        // Check if we need to re-determine auth
-        const oauthValid = await this.isOAuthValid();
-        if (!oauthValid) {
-            this.authDetermined = false;
-        }
         // Lazily determine the best auth method now that it's needed.
-        this.determineBestAuth();
-        // Early authentication validation - check if we have the required credentials
-        // for the determined auth mode BEFORE processing messages
-        switch (this.authMode) {
-            case 'gemini-api-key':
-                if (!this.apiKey && !process.env.GEMINI_API_KEY) {
-                    throw new AuthenticationRequiredError('Gemini API key required but not found. Please set GEMINI_API_KEY environment variable or use /auth to login with Google OAuth.', this.authMode, ['GEMINI_API_KEY']);
-                }
-                break;
-            case 'vertex-ai':
-                if (!process.env.GOOGLE_API_KEY) {
-                    throw new AuthenticationRequiredError('Google API key required for Vertex AI. Please set GOOGLE_API_KEY environment variable or use /auth to login with Google OAuth.', this.authMode, ['GOOGLE_API_KEY', 'GOOGLE_CLOUD_PROJECT', 'GOOGLE_CLOUD_LOCATION']);
-                }
-                break;
-            case 'oauth':
-                // OAuth auth will be validated when creating the content generator
-                break;
-            case 'none':
-                // In 'none' mode, check if ANY credentials are available
-                if (!this.hasGeminiAPIKey() && !this.hasVertexAICredentials()) {
-                    throw new AuthenticationRequiredError('No authentication credentials found. Please use /auth to login with Google OAuth, set GEMINI_API_KEY, or configure Vertex AI credentials.', this.authMode, ['GEMINI_API_KEY', 'GOOGLE_API_KEY']);
-                }
-                break;
-            default:
-                // For any other auth mode, proceed without validation
-                break;
+        // This implements lazy OAuth triggering - OAuth is only triggered when making API calls
+        let authToken;
+        try {
+            authToken = await this.determineBestAuth();
+        }
+        catch (error) {
+            if (error instanceof AuthenticationRequiredError) {
+                throw error;
+            }
+            throw new AuthenticationRequiredError('Failed to resolve authentication for Gemini provider', this.authMode, ['GEMINI_API_KEY', 'GOOGLE_API_KEY']);
         }
+        // Authentication has already been resolved by determineBestAuth()
+        // No need for additional validation since the auth token is already obtained
         // Import the necessary modules dynamically to avoid circular dependencies
         const { GoogleGenAI } = await import('@google/genai');
         // Create the appropriate client based on auth mode
@@ -250,11 +282,8 @@ export class GeminiProvider {
         };
         switch (this.authMode) {
             case 'gemini-api-key':
-                if (!this.apiKey && !process.env.GEMINI_API_KEY) {
-                    throw new Error('Gemini API key required but not found');
-                }
                 genAI = new GoogleGenAI({
-                    apiKey: this.apiKey || process.env.GEMINI_API_KEY,
+                    apiKey: authToken,
                     httpOptions: this.baseURL
                         ? {
                             ...httpOptions,
@@ -264,11 +293,8 @@ export class GeminiProvider {
                 });
                 break;
             case 'vertex-ai':
-                if (!process.env.GOOGLE_API_KEY) {
-                    throw new Error('Google API key required for Vertex AI');
-                }
                 genAI = new GoogleGenAI({
-                    apiKey: process.env.GOOGLE_API_KEY,
+                    apiKey: authToken,
                     vertexai: true,
                     httpOptions: this.baseURL
                         ? {
@@ -279,17 +305,21 @@ export class GeminiProvider {
                 });
                 break;
             case 'oauth': {
+                // For OAuth, create a minimal config-like object if we don't have one
+                const configForOAuth = this.geminiConfig || {
+                    getProxy: () => undefined, // OAuth only needs this from config
+                };
                 // For OAuth, we need to use the code assist server
-                const contentGenerator = await createCodeAssistContentGenerator(httpOptions, AuthType.LOGIN_WITH_GOOGLE, this.config, this.baseURL);
+                const contentGenerator = await createCodeAssistContentGenerator(httpOptions, AuthType.LOGIN_WITH_GOOGLE, configForOAuth, this.baseURL);
                 // Convert messages to Gemini request format
                 // Use config model in OAuth mode to ensure synchronization
                 const oauthModel = this.modelExplicitlySet
                     ? this.currentModel
-                    : this.config?.getModel() || this.currentModel;
+                    : this.geminiConfig?.getModel() || this.currentModel;
                 // Generate systemInstruction using getCoreSystemPrompt
                 // Get user memory from config if available
-                const userMemory = this.config?.getUserMemory
-                    ? this.config.getUserMemory()
+                const userMemory = this.geminiConfig?.getUserMemory
+                    ? this.geminiConfig.getUserMemory()
                     : '';
                 const systemInstruction = await getCoreSystemPromptAsync(userMemory, oauthModel);
                 // Store tools if provided
@@ -314,7 +344,7 @@ export class GeminiProvider {
                     },
                 };
                 // Use the content generator stream
-                const streamResult = await contentGenerator.generateContentStream(request, this.config?.getSessionId() || 'default');
+                const streamResult = await contentGenerator.generateContentStream(request, this.geminiConfig?.getSessionId() || 'default');
                 // Convert the stream to our format
                 for await (const response of streamResult) {
                     // Extract text from the response
@@ -351,34 +381,17 @@ export class GeminiProvider {
                 return;
             }
             case 'none':
-                // For 'none' mode, check what credentials are available
-                if (this.hasGeminiAPIKey()) {
-                    genAI = new GoogleGenAI({
-                        apiKey: this.apiKey || process.env.GEMINI_API_KEY,
-                        httpOptions: this.baseURL
-                            ? {
-                                ...httpOptions,
-                                baseUrl: this.baseURL,
-                            }
-                            : httpOptions,
-                    });
-                }
-                else if (this.hasVertexAICredentials()) {
-                    this.setupVertexAIAuth();
-                    genAI = new GoogleGenAI({
-                        apiKey: process.env.GOOGLE_API_KEY,
-                        vertexai: true,
-                        httpOptions: this.baseURL
-                            ? {
-                                ...httpOptions,
-                                baseUrl: this.baseURL,
-                            }
-                            : httpOptions,
-                    });
-                }
-                else {
-                    throw new Error('No authentication credentials found. Please use /auth to login with Google OAuth, set GEMINI_API_KEY, or configure Vertex AI credentials.');
-                }
+                // For 'none' mode, use the resolved auth token
+                genAI = new GoogleGenAI({
+                    apiKey: authToken,
+                    vertexai: this.hasVertexAICredentials(),
+                    httpOptions: this.baseURL
+                        ? {
+                            ...httpOptions,
+                            baseUrl: this.baseURL,
+                        }
+                        : httpOptions,
+                });
                 break;
             default:
                 throw new Error(`Unsupported auth mode: ${this.authMode}`);
@@ -399,15 +412,15 @@ export class GeminiProvider {
         // Use explicit model if set, otherwise fall back to config model
         const modelToUse = this.modelExplicitlySet
             ? this.currentModel
-            : this.config?.getModel() || this.currentModel;
+            : this.geminiConfig?.getModel() || this.currentModel;
         // For Flash models, always include tools if available
         if (modelToUse.includes('flash') && !geminiTools && this.toolSchemas) {
             geminiTools = this.toolSchemas;
         }
         // Generate systemInstruction using getCoreSystemPrompt
         // Get user memory from config if available
-        const userMemory = this.config?.getUserMemory
-            ? this.config.getUserMemory()
+        const userMemory = this.geminiConfig?.getUserMemory
+            ? this.geminiConfig.getUserMemory()
             : '';
         const systemInstruction = await getCoreSystemPromptAsync(userMemory, modelToUse);
         const request = {
@@ -696,13 +709,12 @@ export class GeminiProvider {
         return result;
     }
     setApiKey(apiKey) {
-        this.apiKey = apiKey;
+        // Call base provider implementation
+        super.setApiKey?.(apiKey);
         // Set the API key as an environment variable so it can be used by the core library
         process.env.GEMINI_API_KEY = apiKey;
         // Clear auth cache when API key changes
         this.authDetermined = false;
-        // Re-determine auth after API key is set
-        this.determineBestAuth();
     }
     setBaseUrl(baseUrl) {
         // If no baseUrl is provided or it's an empty string, clear to undefined
@@ -733,18 +745,49 @@ export class GeminiProvider {
      * Gets the current model ID
      */
     getCurrentModel() {
-        return this.currentModel;
+        // Try to get from SettingsService first (source of truth)
+        try {
+            const settingsService = getSettingsService();
+            const providerSettings = settingsService.getProviderSettings(this.name);
+            if (providerSettings.model) {
+                return providerSettings.model;
+            }
+        }
+        catch (error) {
+            if (process.env.DEBUG) {
+                console.warn('Failed to get model from SettingsService:', error);
+            }
+        }
+        // Fall back to cached value or default
+        return this.currentModel || this.getDefaultModel();
+    }
+    /**
+     * Gets the default model for Gemini
+     */
+    getDefaultModel() {
+        return 'gemini-2.5-pro';
     }
     /**
      * Sets the current model ID
      */
     setModel(modelId) {
+        // Update SettingsService as the source of truth
+        try {
+            const settingsService = getSettingsService();
+            settingsService.setProviderSetting(this.name, 'model', modelId);
+        }
+        catch (error) {
+            if (process.env.DEBUG) {
+                console.warn('Failed to persist model to SettingsService:', error);
+            }
+        }
+        // Keep local cache for performance
         this.currentModel = modelId;
         this.modelExplicitlySet = true;
         // Always update config if available, not just in OAuth mode
         // This ensures the model is properly synchronized
-        if (this.config) {
-            this.config.setModel(modelId);
+        if (this.geminiConfig) {
+            this.geminiConfig.setModel(modelId);
         }
     }
     /**
@@ -811,13 +854,12 @@ export class GeminiProvider {
                 },
             };
             let genAI;
+            // Get authentication token lazily
+            const authToken = await this.determineBestAuth();
             switch (this.authMode) {
                 case 'gemini-api-key': {
-                    if (!this.apiKey && !process.env.GEMINI_API_KEY) {
-                        throw new Error('Gemini API key required for web search');
-                    }
                     genAI = new GoogleGenAI({
-                        apiKey: this.apiKey || process.env.GEMINI_API_KEY,
+                        apiKey: authToken,
                         httpOptions: this.baseURL
                             ? {
                                 ...httpOptions,
@@ -843,11 +885,8 @@ export class GeminiProvider {
                     return apiKeyResult;
                 }
                 case 'vertex-ai': {
-                    if (!process.env.GOOGLE_API_KEY) {
-                        throw new Error('Google API key required for web search');
-                    }
                     genAI = new GoogleGenAI({
-                        apiKey: process.env.GOOGLE_API_KEY,
+                        apiKey: authToken,
                         vertexai: true,
                         httpOptions: this.baseURL
                             ? {
@@ -875,7 +914,7 @@ export class GeminiProvider {
                 }
                 case 'oauth': {
                     // For OAuth, use the code assist content generator
-                    const oauthContentGenerator = await createCodeAssistContentGenerator(httpOptions, AuthType.LOGIN_WITH_GOOGLE, this.config);
+                    const oauthContentGenerator = await createCodeAssistContentGenerator(httpOptions, AuthType.LOGIN_WITH_GOOGLE, this.geminiConfig);
                     // For web search, always use gemini-2.5-flash regardless of the active model
                     const oauthRequest = {
                         model: 'gemini-2.5-flash',
@@ -889,7 +928,7 @@ export class GeminiProvider {
                             tools: [{ googleSearch: {} }],
                         },
                     };
-                    const result = await oauthContentGenerator.generateContent(oauthRequest, this.config?.getSessionId() || 'default');
+                    const result = await oauthContentGenerator.generateContent(oauthRequest, this.geminiConfig?.getSessionId() || 'default');
                     return result;
                 }
                 default:
@@ -908,13 +947,12 @@ export class GeminiProvider {
                 },
             };
             let genAI;
+            // Get authentication token lazily
+            const authToken = await this.determineBestAuth();
             switch (this.authMode) {
                 case 'gemini-api-key': {
-                    if (!this.apiKey && !process.env.GEMINI_API_KEY) {
-                        throw new Error('Gemini API key required for web fetch');
-                    }
                     genAI = new GoogleGenAI({
-                        apiKey: this.apiKey || process.env.GEMINI_API_KEY,
+                        apiKey: authToken,
                         httpOptions: this.baseURL
                             ? {
                                 ...httpOptions,
@@ -940,11 +978,8 @@ export class GeminiProvider {
                     return apiKeyResult;
                 }
                 case 'vertex-ai': {
-                    if (!process.env.GOOGLE_API_KEY) {
-                        throw new Error('Google API key required for web fetch');
-                    }
                     genAI = new GoogleGenAI({
-                        apiKey: process.env.GOOGLE_API_KEY,
+                        apiKey: authToken,
                         vertexai: true,
                         httpOptions: this.baseURL
                             ? {
@@ -972,7 +1007,7 @@ export class GeminiProvider {
                 }
                 case 'oauth': {
                     // For OAuth, use the code assist content generator
-                    const oauthContentGenerator = await createCodeAssistContentGenerator(httpOptions, AuthType.LOGIN_WITH_GOOGLE, this.config);
+                    const oauthContentGenerator = await createCodeAssistContentGenerator(httpOptions, AuthType.LOGIN_WITH_GOOGLE, this.geminiConfig);
                     // For web fetch, always use gemini-2.5-flash regardless of the active model
                     const oauthRequest = {
                         model: 'gemini-2.5-flash',
@@ -986,7 +1021,7 @@ export class GeminiProvider {
                             tools: [{ urlContext: {} }],
                         },
                     };
-                    const result = await oauthContentGenerator.generateContent(oauthRequest, this.config?.getSessionId() || 'default');
+                    const result = await oauthContentGenerator.generateContent(oauthRequest, this.geminiConfig?.getSessionId() || 'default');
                     return result;
                 }
                 default: