@vybestack/llxprt-code-core 0.4.8 → 0.5.0-nightly.251102.e5b51aa3

package/dist/src/providers/BaseProvider.js

@@ -3,9 +3,18 @@
  * Copyright 2025 Vybestack LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+/**
+ * Base provider class with authentication precedence logic
+ */
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { DebugLogger } from '../debug/index.js';
 import { AuthPrecedenceResolver, } from '../auth/precedence.js';
+import { peekActiveProviderRuntimeContext, setActiveProviderRuntimeContext, } from '../runtime/providerRuntimeContext.js';
+import { createRuntimeInvocationContext, } from '../runtime/RuntimeInvocationContext.js';
+import { SettingsService } from '../settings/SettingsService.js';
 import { getSettingsService } from '../settings/settingsServiceInstance.js';
+import { MissingProviderRuntimeError } from './errors.js';
+import { resolveRuntimeAuthToken } from './utils/authToken.js';
 /**
  * Abstract base provider class that implements authentication precedence logic
  * This class provides lazy OAuth triggering and proper authentication precedence
@@ -15,32 +24,87 @@ export class BaseProvider {
     authResolver;
     baseProviderConfig;
     providerConfig;
-    globalConfig;
-    cachedAuthToken;
-    authCacheTimestamp;
-    AUTH_CACHE_DURATION = 60000; // 1 minute in milliseconds
+    /**
+     * @plan PLAN-20250218-STATELESSPROVIDER.P05
+     * @requirement REQ-SP-001
+     * @pseudocode provider-invocation.md lines 8-15
+     */
+    defaultSettingsService;
+    defaultConfig;
+    activeCallContext = new AsyncLocalStorage();
     // Callback for tracking throttle wait times (set by LoggingProviderWrapper)
     throttleTracker;
-    constructor(config, providerConfig, globalConfig) {
+    get globalConfig() {
+        return this.defaultConfig;
+    }
+    set globalConfig(config) {
+        this.defaultConfig = config;
+    }
+    constructor(config, providerConfig, globalConfig, settingsService) {
         this.name = config.name;
         this.baseProviderConfig = config;
         this.providerConfig = providerConfig;
-        this.globalConfig = globalConfig;
-        // If an initial apiKey is provided, store it in SettingsService
-        // Only store non-empty API keys to ensure proper precedence fallback
-        if (config.apiKey && config.apiKey.trim() !== '') {
-            const settingsService = getSettingsService();
-            settingsService.set('auth-key', config.apiKey);
-        }
-        // Initialize auth precedence resolver
-        // OAuth enablement will be checked dynamically through the manager
+        this.defaultConfig = globalConfig;
+        let fallbackSettingsService;
+        if (settingsService) {
+            fallbackSettingsService = settingsService;
+        }
+        else {
+            try {
+                fallbackSettingsService = getSettingsService();
+            }
+            catch {
+                fallbackSettingsService = new SettingsService();
+            }
+        }
+        this.defaultSettingsService = fallbackSettingsService;
         const precedenceConfig = {
+            apiKey: config.apiKey,
             envKeyNames: config.envKeyNames || [],
-            isOAuthEnabled: config.isOAuthEnabled ?? false, // Use the config value, which can be updated
+            isOAuthEnabled: config.isOAuthEnabled ?? false,
             supportsOAuth: this.supportsOAuth(),
             oauthProvider: config.oauthProvider,
+            providerId: this.name,
         };
-        this.authResolver = new AuthPrecedenceResolver(precedenceConfig, config.oauthManager);
+        this.authResolver = new AuthPrecedenceResolver(precedenceConfig, config.oauthManager, fallbackSettingsService);
+    }
+    /**
+     * @plan PLAN-20251018-STATELESSPROVIDER2.P06
+     * @plan:PLAN-20251018-STATELESSPROVIDER2.P06
+     * @requirement REQ-SP2-001
+     * @pseudocode base-provider-call-contract.md lines 1-2
+     */
+    setRuntimeSettingsService(settingsService) {
+        if (!settingsService) {
+            return;
+        }
+        this.defaultSettingsService = settingsService;
+        this.authResolver.setSettingsService(settingsService);
+    }
+    /**
+     * @plan PLAN-20251018-STATELESSPROVIDER2.P06
+     * @plan:PLAN-20251023-STATELESS-HARDENING.P05
+     * @requirement REQ-SP2-001
+     * @requirement:REQ-SP4-001
+     * @pseudocode base-provider-call-contract.md lines 1-3
+     */
+    resolveSettingsService() {
+        const activeOptions = this.activeCallContext.getStore();
+        if (activeOptions?.settings) {
+            return activeOptions.settings;
+        }
+        if (this.defaultSettingsService) {
+            return this.defaultSettingsService;
+        }
+        throw new MissingProviderRuntimeError({
+            providerKey: `BaseProvider.${this.name}`,
+            missingFields: ['settings'],
+            stage: 'resolveSettingsService',
+            metadata: {
+                requirement: 'REQ-SP4-001',
+                hint: 'Provider runtime guard expects ProviderManager to set runtime settings.',
+            },
+        });
     }
     /**
      * Set throttle tracking callback (used by LoggingProviderWrapper)
@@ -52,86 +116,95 @@ export class BaseProvider {
         logger.debug(() => `Throttle tracker set for provider`);
     }
     /**
+     * @plan PLAN-20251018-STATELESSPROVIDER2.P06
+     * @requirement REQ-SP2-001
+     * @pseudocode base-provider-call-contract.md lines 2-3
      * Gets the base URL with proper precedence:
      * 1. Ephemeral settings (highest priority - from /baseurl or profile)
-     * 2. Provider config (from IProviderConfig)
-     * 3. Base provider config (initial constructor value)
-     * 4. undefined (use provider default)
+     * 2. Provider-specific settings in SettingsService
+     * 3. Provider config (from IProviderConfig)
+     * 4. Base provider config (initial constructor value)
+     * 5. undefined (use provider default)
      */
     getBaseURL() {
-        const settingsService = getSettingsService();
-        // 1. Check ephemeral settings first (from /baseurl command or profile)
+        const activeOptions = this.activeCallContext.getStore();
+        if (activeOptions) {
+            return activeOptions.resolved.baseURL;
+        }
+        const settingsService = this.resolveSettingsService();
+        return this.computeBaseURL(settingsService);
+    }
+    /**
+     * @plan PLAN-20251018-STATELESSPROVIDER2.P06
+     * @requirement REQ-SP2-001
+     * @pseudocode base-provider-call-contract.md lines 2-3
+     * Gets the current model with proper precedence:
+     * 1. Ephemeral settings (highest priority)
+     * 2. Provider-specific settings in SettingsService
+     * 3. Provider config
+     * 4. Default model
+     */
+    getModel() {
+        const activeOptions = this.activeCallContext.getStore();
+        if (activeOptions) {
+            return activeOptions.resolved.model;
+        }
+        const settingsService = this.resolveSettingsService();
+        return this.computeModel(settingsService);
+    }
+    computeBaseURL(settingsService) {
         const ephemeralBaseUrl = settingsService.get('base-url');
         if (ephemeralBaseUrl && ephemeralBaseUrl !== 'none') {
             return ephemeralBaseUrl;
         }
-        // 2. Check provider config (from IProviderConfig)
+        const providerSettings = settingsService.getProviderSettings(this.name);
+        const providerBaseUrl = providerSettings?.baseUrl;
+        if (providerBaseUrl && providerBaseUrl !== 'none') {
+            return providerBaseUrl;
+        }
         if (this.providerConfig?.baseUrl) {
             return this.providerConfig.baseUrl;
         }
-        // 3. Check base provider config (constructor value)
         if (this.baseProviderConfig.baseURL) {
             return this.baseProviderConfig.baseURL;
         }
-        // 4. Return undefined to use provider's default
         return undefined;
     }
-    /**
-     * Gets the current model with proper precedence:
-     * 1. Ephemeral settings (highest priority)
-     * 2. Provider-specific settings in SettingsService
-     * 3. Provider config
-     * 4. Default model
-     */
-    getModel() {
-        const settingsService = getSettingsService();
-        // 1. Check ephemeral settings first
+    computeModel(settingsService) {
         const ephemeralModel = settingsService.get('model');
         if (ephemeralModel) {
             return ephemeralModel;
         }
-        // 2. Check provider-specific settings
         const providerSettings = settingsService.getProviderSettings(this.name);
         const providerModel = providerSettings?.model;
         if (providerModel) {
             return providerModel;
         }
-        // 3. Check provider config
         if (this.providerConfig?.defaultModel) {
             return this.providerConfig.defaultModel;
         }
-        // 4. Return default
         return this.getDefaultModel();
     }
     /**
+     * @plan PLAN-20251018-STATELESSPROVIDER2.P06
+     * @requirement REQ-SP2-001
+     * @pseudocode base-provider-call-contract.md lines 1-3
      * Gets authentication token using the precedence chain
      * This method implements lazy OAuth triggering - only triggers OAuth when actually making API calls
      * Returns empty string if no auth is available (for local/self-hosted endpoints)
      */
     async getAuthToken() {
-        // Check cache first (short-lived cache to avoid repeated OAuth calls)
-        if (this.cachedAuthToken &&
-            this.authCacheTimestamp &&
-            Date.now() - this.authCacheTimestamp < this.AUTH_CACHE_DURATION) {
-            return this.cachedAuthToken;
-        }
-        // Clear stale cache
-        this.cachedAuthToken = undefined;
-        this.authCacheTimestamp = undefined;
-        // Resolve authentication using precedence chain
-        const token = await this.authResolver.resolveAuthentication();
-        if (!token) {
-            // Return empty string for local/self-hosted endpoints that don't require auth
-            // Individual providers can decide how to handle this
-            return '';
-        }
-        // Cache the token briefly
-        this.cachedAuthToken = token;
-        this.authCacheTimestamp = Date.now();
-        if (process.env.DEBUG) {
-            const authMethod = await this.authResolver.getAuthMethodName();
-            console.log(`[${this.name}] Authentication resolved using: ${authMethod}`);
+        const activeOptions = this.activeCallContext.getStore();
+        if (activeOptions) {
+            const runtimeToken = await resolveRuntimeAuthToken(activeOptions.resolved.authToken);
+            if (runtimeToken) {
+                return runtimeToken;
+            }
         }
+        const settingsService = this.resolveSettingsService();
+        const token = (await this.authResolver.resolveAuthentication({
+            settingsService,
+        })) ?? '';
         return token;
     }
     /**
@@ -153,63 +226,47 @@ export class BaseProvider {
         return false;
     }
     /**
+     * @plan PLAN-20251018-STATELESSPROVIDER2.P06
+     * @requirement REQ-SP2-001
+     * @pseudocode base-provider-call-contract.md lines 1-3
      * Checks if authentication is available without triggering OAuth
      */
     async hasNonOAuthAuthentication() {
-        return this.authResolver.hasNonOAuthAuthentication();
+        return this.authResolver.hasNonOAuthAuthentication({
+            settingsService: this.resolveSettingsService(),
+        });
     }
     /**
+     * @plan PLAN-20251018-STATELESSPROVIDER2.P06
+     * @requirement REQ-SP2-001
+     * @pseudocode base-provider-call-contract.md lines 1-3
      * Checks if OAuth is the only available authentication method
      */
     async isOAuthOnlyAvailable() {
-        return this.authResolver.isOAuthOnlyAvailable();
+        return this.authResolver.isOAuthOnlyAvailable({
+            settingsService: this.resolveSettingsService(),
+        });
     }
     /**
+     * @plan PLAN-20251018-STATELESSPROVIDER2.P06
+     * @requirement REQ-SP2-001
+     * @pseudocode base-provider-call-contract.md lines 1-3
      * Gets the current authentication method name for debugging
      */
     async getAuthMethodName() {
-        return this.authResolver.getAuthMethodName();
-    }
-    /**
-     * Updates the API key (used for CLI --key argument and other sources)
-     */
-    setApiKey(apiKey) {
-        const settingsService = getSettingsService();
-        // CRITICAL FIX: When clearing the key, set to undefined instead of empty string
-        // This ensures the precedence chain properly skips this level
-        if (!apiKey || apiKey.trim() === '') {
-            settingsService.set('auth-key', undefined);
-        }
-        else {
-            settingsService.set('auth-key', apiKey);
-        }
-        this.clearAuthCache();
+        return this.authResolver.getAuthMethodName({
+            settingsService: this.resolveSettingsService(),
+        });
     }
     /**
      * Clears authentication (used when removing keys/keyfiles)
      */
     clearAuth() {
-        const settingsService = getSettingsService();
+        const settingsService = this.resolveSettingsService();
         settingsService.set('auth-key', undefined);
         settingsService.set('auth-keyfile', undefined);
         this.clearAuthCache();
     }
-    /**
-     * Updates the base URL in ephemeral settings
-     */
-    setBaseUrl(baseUrl) {
-        const settingsService = getSettingsService();
-        // Store in ephemeral settings as the highest priority source
-        if (!baseUrl || baseUrl.trim() === '' || baseUrl === 'none') {
-            // Clear the ephemeral setting
-            settingsService.set('base-url', undefined);
-        }
-        else {
-            settingsService.set('base-url', baseUrl);
-        }
-        // Clear auth cache as base URL change might affect auth
-        this.clearAuthCache();
-    }
     /**
      * Updates OAuth configuration
      */
@@ -231,23 +288,300 @@ export class BaseProvider {
      * Clears the authentication token cache
      */
     clearAuthCache() {
-        this.cachedAuthToken = undefined;
-        this.authCacheTimestamp = undefined;
+        // Legacy no-op retained for compatibility with existing logout flows.
     }
     /**
      * Checks if the provider is authenticated using any available method
      */
     async isAuthenticated() {
         try {
-            const token = await this.authResolver.resolveAuthentication();
-            return token !== null;
+            const token = (await this.authResolver.resolveAuthentication({
+                settingsService: this.resolveSettingsService(),
+            })) ?? '';
+            return token !== '';
         }
         catch {
             return false;
         }
     }
+    /**
+     * @plan PLAN-20251018-STATELESSPROVIDER2.P06
+     * @requirement REQ-SP2-001
+     * @pseudocode base-provider-call-contract.md lines 1-5
+     */
+    generateChatCompletion(contentsOrOptions, maybeTools) {
+        const normalizedPromise = this.normalizeGenerateChatOptions(contentsOrOptions, maybeTools);
+        const previousRuntimeContext = peekActiveProviderRuntimeContext();
+        let preparedIteratorPromise = null;
+        let normalizedOptions;
+        let underlyingIterator;
+        const prepareIterator = async () => {
+            if (!preparedIteratorPromise) {
+                preparedIteratorPromise = (async () => {
+                    normalizedOptions = await normalizedPromise;
+                    underlyingIterator = this.invokeWithNormalizedOptions(normalizedOptions, previousRuntimeContext ?? null);
+                })();
+            }
+            await preparedIteratorPromise;
+        };
+        const withContext = (operation) => {
+            if (!normalizedOptions) {
+                throw new Error('Normalized options are not prepared');
+            }
+            return this.activeCallContext.run(normalizedOptions, operation);
+        };
+        const adapter = {
+            next: async (...args) => {
+                await prepareIterator();
+                const iterator = underlyingIterator;
+                if (!iterator) {
+                    throw new Error('Provider iterator not initialised');
+                }
+                return withContext(() => iterator.next(...args));
+            },
+            return: async (value) => {
+                await prepareIterator();
+                const iterator = underlyingIterator;
+                if (!iterator) {
+                    throw new Error('Provider iterator not initialised');
+                }
+                if (iterator.return) {
+                    return withContext(() => iterator.return(value));
+                }
+                return { done: true, value: undefined };
+            },
+            throw: async (error) => {
+                await prepareIterator();
+                const iterator = underlyingIterator;
+                if (!iterator) {
+                    throw new Error('Provider iterator not initialised');
+                }
+                if (iterator.throw) {
+                    return withContext(() => iterator.throw(error));
+                }
+                throw error;
+            },
+            [Symbol.asyncIterator]() {
+                return this;
+            },
+        };
+        return adapter;
+    }
+    /**
+     * @plan PLAN-20251018-STATELESSPROVIDER2.P06
+     * @requirement REQ-SP2-001
+     * @pseudocode base-provider-call-contract.md lines 3-5
+     */
+    invokeWithNormalizedOptions(normalized, previousContext) {
+        const needsContextSwap = !previousContext ||
+            previousContext.settingsService !== normalized.settings ||
+            (normalized.config && previousContext.config !== normalized.config);
+        const mergedMetadata = normalized.runtime
+            ? {
+                ...(normalized.runtime.metadata ?? {}),
+                ...normalized.metadata,
+            }
+            : {
+                ...(previousContext?.metadata ?? {}),
+                ...normalized.metadata,
+            };
+        if (!('source' in mergedMetadata)) {
+            mergedMetadata.source = 'BaseProvider.generateChatCompletion';
+        }
+        const runtimeContext = normalized.runtime
+            ? {
+                ...normalized.runtime,
+                settingsService: normalized.settings,
+                config: normalized.config ?? normalized.runtime.config,
+                metadata: mergedMetadata,
+            }
+            : {
+                settingsService: normalized.settings,
+                config: normalized.config ?? previousContext?.config,
+                runtimeId: previousContext?.runtimeId ?? 'base-provider.normalized-call',
+                metadata: mergedMetadata,
+            };
+        return async function* () {
+            if (needsContextSwap) {
+                setActiveProviderRuntimeContext(runtimeContext);
+            }
+            try {
+                const iterator = this.generateChatCompletionWithOptions(normalized);
+                for await (const chunk of iterator) {
+                    yield chunk;
+                }
+            }
+            finally {
+                if (needsContextSwap) {
+                    setActiveProviderRuntimeContext(previousContext ?? null);
+                }
+                normalized.resolved.authToken = '';
+                this.authResolver.setSettingsService(this.defaultSettingsService);
+            }
+        }.call(this);
+    }
+    /**
+     * @plan PLAN-20251018-STATELESSPROVIDER2.P06
+     * @plan:PLAN-20251023-STATELESS-HARDENING.P05
+     * @requirement REQ-SP2-001
+     * @requirement:REQ-SP4-001
+     * @pseudocode base-provider-call-contract.md lines 1-3
+     */
+    async normalizeGenerateChatOptions(contentsOrOptions, maybeTools) {
+        const providedOptions = Array.isArray(contentsOrOptions)
+            ? { contents: contentsOrOptions, tools: maybeTools }
+            : contentsOrOptions;
+        const settings = providedOptions.settings ?? this.defaultSettingsService ?? null;
+        if (!settings) {
+            throw new MissingProviderRuntimeError({
+                providerKey: `BaseProvider.${this.name}`,
+                missingFields: ['settings'],
+                stage: 'normalizeGenerateChatOptions',
+                metadata: {
+                    hint: 'ProviderManager must supply settings via GenerateChatOptions or setRuntimeSettingsService.',
+                    requirement: 'REQ-SP4-001',
+                },
+            });
+        }
+        const runtimeConfig = providedOptions.runtime?.config ?? null;
+        const configCandidate = providedOptions.config ?? runtimeConfig ?? this.defaultConfig ?? null;
+        const runtimeMetadata = providedOptions.runtime?.metadata ?? {};
+        const metadataFromOptions = providedOptions.metadata ?? {};
+        const metadata = {
+            ...runtimeMetadata,
+            ...metadataFromOptions,
+        };
+        const resolvedModel = this.computeModel(settings);
+        const resolvedBaseURL = this.computeBaseURL(settings);
+        const resolvedAuth = (await this.authResolver.resolveAuthentication({
+            settingsService: settings,
+        })) ?? '';
+        const resolved = {
+            model: resolvedModel,
+            baseURL: resolvedBaseURL,
+            authToken: resolvedAuth,
+            telemetry: providedOptions.resolved?.telemetry,
+        };
+        const guard = this.assertRuntimeContext({
+            providerKey: `BaseProvider.${this.name}`,
+            settings,
+            config: configCandidate,
+            runtime: providedOptions.runtime,
+            metadata,
+            resolved,
+            stage: 'normalizeGenerateChatOptions',
+        });
+        const finalConfig = guard.runtime.config ?? configCandidate ?? undefined;
+        const normalizedRuntime = {
+            ...guard.runtime,
+            metadata: guard.metadata,
+            config: finalConfig,
+        };
+        const invocation = providedOptions.invocation ??
+            createRuntimeInvocationContext({
+                runtime: normalizedRuntime,
+                settings,
+                providerName: this.name,
+                ephemeralsSnapshot: this.buildEphemeralsSnapshot(settings),
+                telemetry: resolved.telemetry,
+                metadata: guard.metadata,
+                userMemory: typeof providedOptions.userMemory === 'string'
+                    ? providedOptions.userMemory
+                    : undefined,
+                fallbackRuntimeId: `${this.name}:normalizeGenerateChatOptions`,
+            });
+        return {
+            ...providedOptions,
+            contents: providedOptions.contents,
+            tools: providedOptions.tools ?? maybeTools,
+            settings,
+            config: finalConfig,
+            runtime: normalizedRuntime,
+            metadata: guard.metadata,
+            resolved,
+            invocation,
+        };
+    }
+    buildEphemeralsSnapshot(settings) {
+        const snapshot = {
+            ...settings.getAllGlobalSettings(),
+        };
+        const providerEphemerals = settings.getProviderSettings(this.name);
+        snapshot[this.name] = { ...providerEphemerals };
+        return snapshot;
+    }
+    /**
+     * @plan:PLAN-20251023-STATELESS-HARDENING.P05
+     * @requirement:REQ-SP4-001
+     * @pseudocode base-provider-fallback-removal.md lines 11-14
+     */
+    assertRuntimeContext(input) {
+        const missing = [];
+        if (!input.settings) {
+            missing.push('settings');
+        }
+        if (!input.config) {
+            missing.push('config');
+        }
+        const resolvedMissing = [];
+        if (!input.resolved) {
+            resolvedMissing.push('resolved');
+        }
+        else {
+            if (typeof input.resolved.model !== 'string' ||
+                input.resolved.model.trim() === '') {
+                resolvedMissing.push('resolved.model');
+            }
+            if (input.resolved.baseURL !== undefined &&
+                input.resolved.baseURL !== null &&
+                typeof input.resolved.baseURL !== 'string') {
+                resolvedMissing.push('resolved.baseURL');
+            }
+            if (input.resolved.authToken === undefined ||
+                input.resolved.authToken === null) {
+                resolvedMissing.push('resolved.authToken');
+            }
+        }
+        const missingFields = [...missing, ...resolvedMissing];
+        if (missingFields.length > 0) {
+            throw new MissingProviderRuntimeError({
+                providerKey: input.providerKey,
+                missingFields,
+                stage: input.stage,
+                metadata: {
+                    ...(input.metadata ?? {}),
+                    requirement: 'REQ-SP4-001',
+                },
+            });
+        }
+        const metadata = {
+            ...(input.runtime?.metadata ?? {}),
+            ...(input.metadata ?? {}),
+            requirement: 'REQ-SP4-001',
+            stage: input.stage,
+        };
+        const runtimeMetadata = metadata;
+        const currentRuntimeId = typeof runtimeMetadata.runtimeId === 'string'
+            ? runtimeMetadata.runtimeId
+            : undefined;
+        const runtime = input.runtime
+            ? {
+                ...input.runtime,
+                settingsService: input.settings,
+                config: input.runtime.config ?? input.config ?? undefined,
+                metadata,
+            }
+            : {
+                settingsService: input.settings,
+                config: input.config ?? undefined,
+                runtimeId: currentRuntimeId && currentRuntimeId.trim()
+                    ? currentRuntimeId
+                    : `${input.providerKey}:${input.stage}`,
+                metadata,
+            };
+        return { runtime, metadata };
+    }
     // Optional methods with default implementations
-    setModel(_modelId) { }
     getCurrentModel() {
         // Use the same logic as getModel() to check ephemeral settings
         return this.getModel();
@@ -255,7 +589,6 @@ export class BaseProvider {
     getToolFormat() {
         return 'default';
     }
-    setToolFormatOverride(_format) { }
     isPaidMode() {
         return false;
     }
@@ -269,7 +602,7 @@ export class BaseProvider {
         const maybeConfig = config;
         if (typeof maybeConfig.getUserMemory === 'function' &&
             typeof maybeConfig.getModel === 'function') {
-            this.globalConfig = config;
+            this.defaultConfig = config;
             return;
         }
         this.providerConfig = config;
@@ -280,7 +613,6 @@ export class BaseProvider {
     async invokeServerTool(toolName, _params, _config, _signal) {
         throw new Error(`Server tool '${toolName}' not supported by ${this.name} provider`);
     }
-    setModelParams(_params) { }
     getModelParams() {
         return undefined;
     }
@@ -288,7 +620,7 @@ export class BaseProvider {
      * Get setting value from SettingsService
      */
     async getProviderSetting(key, fallback) {
-        const settingsService = getSettingsService();
+        const settingsService = this.resolveSettingsService();
         try {
             const settings = await settingsService.getSettings(this.name);
             return settings[key] || fallback;
@@ -304,11 +636,15 @@ export class BaseProvider {
      * Set setting value in SettingsService
      */
     async setProviderSetting(key, value) {
-        const settingsService = getSettingsService();
+        const settingsService = this.resolveSettingsService();
         try {
             await settingsService.updateSettings(this.name, {
                 [key]: value,
             });
+            const updatedSettings = await settingsService.getSettings(this.name);
+            if (updatedSettings[key] !== value) {
+                settingsService.set(`providers.${this.name}.${String(key)}`, value);
+            }
         }
         catch (error) {
             if (process.env.DEBUG) {
@@ -356,11 +692,11 @@ export class BaseProvider {
      * Get model parameters from SettingsService
      */
     async getModelParamsFromSettings() {
-        const settingsService = getSettingsService();
+        const settingsService = this.resolveSettingsService();
         try {
             const settings = await settingsService.getSettings(this.name);
             // Extract model parameters from settings, excluding standard fields
-            const { enabled: _enabled, apiKey: _apiKey, baseUrl: _baseUrl, model: _model, maxTokens, temperature, ...modelParams } = settings;
+            const { enabled: _enabled, apiKey: _apiKey, baseUrl: _baseUrl, model: _model, maxTokens, temperature, ...additionalSettings } = settings;
             // Include temperature and maxTokens as model params if they exist
             const params = {};
             if (temperature !== undefined)
@@ -368,8 +704,8 @@ export class BaseProvider {
             if (maxTokens !== undefined)
                 params.max_tokens = maxTokens;
             return Object.keys(params).length > 0 ||
-                Object.keys(modelParams).length > 0
-                ? { ...params, ...modelParams }
+                Object.keys(additionalSettings).length > 0
+                ? { ...params, ...additionalSettings }
                 : undefined;
         }
         catch (error) {
@@ -383,7 +719,7 @@ export class BaseProvider {
      * Set model parameters in SettingsService
      */
     async setModelParamsInSettings(params) {
-        const settingsService = getSettingsService();
+        const settingsService = this.resolveSettingsService();
         try {
             if (params === undefined) {
                 // Clear model parameters by setting them to undefined