libre-webui 0.21.3 → 0.22.1

package/backend/dist/services/pluginService.js

@@ -23,24 +23,97 @@ import codexOAuthService, { CODEX_OAUTH_PLUGIN_ID, } from './codexOAuthService.j
 import { userModel } from '../models/userModel.js';
 import pluginCredentialsService from './pluginCredentialsService.js';
 import pluginVariablesService from './pluginVariablesService.js';
+import { ensurePluginCacheInvalidationSubscription, publishPluginCacheInvalidation, registerPluginCacheInvalidationListener, } from './pluginCacheInvalidation.js';
 import pluginActivationService from './pluginActivationService.js';
 import { PluginAudioGenerationService } from './pluginAudioGenerationService.js';
 import { PluginCapabilityRegistryService } from './pluginCapabilityRegistryService.js';
 import { PluginEmbeddingService } from './pluginEmbeddingService.js';
 import { PluginImageGenerationService } from './pluginImageGenerationService.js';
+import { PluginSTTService } from './pluginSTTService.js';
 import { PluginTTSService } from './pluginTTSService.js';
 import { PluginVideoGenerationService } from './pluginVideoGenerationService.js';
 import { applyPluginDefinitionPolicy, buildPluginChatPayload, convertProviderResponse, getOpenAICompatibleSamplingParameters, resolvePluginChatParameters, toOpenAICompatibleMessages, } from '../utils/pluginChatAdapter.js';
 import { streamAnthropicResponse, streamOpenAICompatibleResponse, streamOpenAIResponsesResponse, } from '../utils/pluginStreamAdapter.js';
 import { applyModelEndpointTemplate, assertSafePluginEndpoint, buildPluginAuthHeaders, buildPluginModelDiscoveryHeaders, pluginRequiresApiKey, resolvePluginApiConfig, resolvePluginEndpoint, resolvePluginModelsEndpoint, validatePluginModel, } from '../utils/pluginValidation.js';
 import { createLogger } from '../utils/logger.js';
+import { isChatGenerationCancelled, throwIfChatGenerationCancelled, } from '../utils/chatCancellation.js';
 import { resolveBundledPluginsDir } from '../utils/packagePaths.js';
-import { getDatabaseSafe } from '../db.js';
+import { BACKEND_DIRECTORY, PROJECT_DIRECTORY, resolveDataDirectory, resolveLegacyPluginsDirectories, resolvePhysicalPathCandidate, resolvePluginsDirectory, } from '../utils/dataDirectory.js';
+import { getPersistence } from '../persistence/index.js';
 import { createOpenAIResponsesStateScope, createPluginCredentialFingerprint, OPENAI_RESPONSES_INCOMPLETE_REASON_METADATA_KEY, } from '../utils/openAIResponsesAdapter.js';
 import { getPluginConnectionVariableNames } from '../utils/pluginConnectionVariables.js';
 import pluginUsageService from './pluginUsageService.js';
 import { getPluginDefinitionFingerprint, matchesBundledPluginTrustAnchor, } from '../utils/pluginDefinitionTrust.js';
+import { encryptionService } from './encryptionService.js';
 const logger = createLogger('plugins');
+const hasSymlinkPathComponentFromRoot = (root, target) => {
+    const resolvedRoot = path.resolve(root);
+    const resolvedTarget = path.resolve(target);
+    const relative = path.relative(resolvedRoot, resolvedTarget);
+    if (relative === '..' ||
+        relative.startsWith(`..${path.sep}`) ||
+        path.isAbsolute(relative)) {
+        return false;
+    }
+    let current = resolvedRoot;
+    for (const component of relative.split(path.sep)) {
+        if (!component)
+            continue;
+        current = path.join(current, component);
+        try {
+            if (fs.lstatSync(current).isSymbolicLink())
+                return true;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return false;
+            throw error;
+        }
+    }
+    return false;
+};
+const isRegularPluginDirectory = (directory) => {
+    try {
+        const stat = fs.lstatSync(directory);
+        return stat.isDirectory() && !stat.isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+};
+const isRegularPluginDefinition = (filePath) => {
+    try {
+        if (!isRegularPluginDirectory(path.dirname(filePath)))
+            return false;
+        const stat = fs.lstatSync(filePath);
+        return stat.isFile() && !stat.isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+};
+const readRegularPluginDefinition = (filePath) => {
+    if (!isRegularPluginDirectory(path.dirname(filePath))) {
+        throw new Error('Plugin definition directory is not a regular directory');
+    }
+    const namedStat = fs.lstatSync(filePath);
+    if (!namedStat.isFile() || namedStat.isSymbolicLink()) {
+        throw new Error('Plugin definition is not a regular file');
+    }
+    const descriptor = fs.openSync(filePath, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW || 0));
+    try {
+        const openedStat = fs.fstatSync(descriptor);
+        if (!openedStat.isFile() ||
+            openedStat.dev !== namedStat.dev ||
+            openedStat.ino !== namedStat.ino) {
+            throw new Error('Plugin definition changed during inspection');
+        }
+        return fs.readFileSync(descriptor, 'utf8');
+    }
+    finally {
+        fs.closeSync(descriptor);
+    }
+};
 const readPositiveIntEnv = (name, fallback) => {
     const parsed = Number(process.env[name]);
     return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
@@ -84,6 +157,9 @@ function getPluginRoutingAuthProjection(plugin) {
             endpoint: capability.endpoint ?? null,
             models_endpoint: capability.models_endpoint ?? null,
             endpoint_variable: config.endpoint_variable ?? capability.endpoint_variable ?? null,
+            models_endpoint_variable: config.models_endpoint_variable ?? null,
+            voice_clone_endpoint: config.voice_clone_endpoint ?? null,
+            voice_clone_endpoint_variable: config.voice_clone_endpoint_variable ?? null,
         };
     });
     const definitions = new Map((plugin.variables || []).map(definition => [definition.name, definition]));
@@ -119,7 +195,7 @@ function getPluginRoutingAuthProjection(plugin) {
     });
 }
 export class PluginService {
-    constructor() {
+    constructor(options = {}) {
         this.discoveredModelsCache = new Map();
         this.discoveredModelsUpdatedAt = new Map();
         this.discoveryAttemptedAt = new Map();
@@ -128,84 +204,229 @@ export class PluginService {
         this.discoveredCapabilityModelsUpdatedAt = new Map();
         this.capabilityDiscoveryAttemptedAt = new Map();
         this.inflightCapabilityDiscovery = new Map();
+        this.discoveryCacheRevisions = new Map();
+        this.capabilityDiscoveryCacheRevisions = new Map();
         this.bundledRoutingProjectionCache = new Map();
+        this.sharedDefinitionIds = new Set();
+        this.sharedPluginDefinitions =
+            getPersistence(encryptionService).dialect === 'postgres';
         this.bundledPluginsDir = resolveBundledPluginsDir(import.meta.url);
-        this.legacyPluginsDir = path.join(process.cwd(), 'plugins');
-        this.pluginsDir =
-            process.env.PLUGINS_DIR ||
-                (process.env.DATA_DIR
-                    ? path.join(process.env.DATA_DIR, 'plugins')
-                    : this.legacyPluginsDir);
-        this.pluginReadDirs = Array.from(new Set([this.bundledPluginsDir, this.legacyPluginsDir, this.pluginsDir]));
-        this.ensurePluginsDirectory();
-        pluginActivationService.migrateLegacyStatus([this.pluginsDir, this.legacyPluginsDir], pluginId => this.canMigrateLegacyActivation(pluginId));
+        this.pluginsDir = resolvePluginsDirectory();
+        this.legacyPluginsDirs =
+            options.legacyPluginsDirectories ?? resolveLegacyPluginsDirectories();
+        const activePluginDirectories = new Set([this.bundledPluginsDir, this.pluginsDir, ...this.legacyPluginsDirs].map(directory => resolvePhysicalPathCandidate(directory)));
+        this.historicalPluginConflictDirs = options.legacyPluginsDirectories
+            ? []
+            : resolveLegacyPluginsDirectories(process.env, {
+                historicalWorkingDirectory: process.cwd(),
+            }).filter(directory => !activePluginDirectories.has(resolvePhysicalPathCandidate(directory)));
+        this.pluginReadDirs = this.sharedPluginDefinitions
+            ? [this.bundledPluginsDir]
+            : Array.from(new Set([
+                this.bundledPluginsDir,
+                ...this.legacyPluginsDirs,
+                this.pluginsDir,
+            ]));
+        if (this.sharedPluginDefinitions) {
+            this.assertNoLocalCustomDefinitions();
+        }
+        else {
+            this.ensurePluginsDirectory();
+        }
         this.embeddingService = new PluginEmbeddingService({
-            getAllPlugins: userId => this.getActivePlugins(userId),
+            getAllPlugins: userId => this.getActivePluginsUnchecked(userId),
             getApiKey: (plugin, userId) => this.getApiKey(plugin, userId),
             getPluginVariables: (plugin, userId) => this.getPluginVariables(plugin, userId),
             validateEndpointUrl: endpoint => this.validateEndpointUrl(endpoint),
             recordUsage: usage => pluginUsageService.record(usage),
         });
         this.ttsService = new PluginTTSService({
-            getAllPlugins: userId => this.getActivePlugins(userId),
-            getPlugin: (id, userId) => this.getPlugin(id, userId),
+            getAllPlugins: userId => this.getActivePluginsUnchecked(userId),
+            getPlugin: (id, userId) => this.getPluginUnchecked(id, userId),
+            getApiKey: (plugin, userId) => this.getApiKey(plugin, userId),
+            getPluginVariables: (plugin, userId) => this.getPluginVariables(plugin, userId),
+            validateEndpointUrl: endpoint => this.validateEndpointUrl(endpoint),
+            recordUsage: usage => pluginUsageService.record(usage),
+        });
+        this.sttService = new PluginSTTService({
+            getAllPlugins: userId => this.getActivePluginsUnchecked(userId),
+            getPlugin: (id, userId) => this.getPluginUnchecked(id, userId),
             getApiKey: (plugin, userId) => this.getApiKey(plugin, userId),
             getPluginVariables: (plugin, userId) => this.getPluginVariables(plugin, userId),
             validateEndpointUrl: endpoint => this.validateEndpointUrl(endpoint),
             recordUsage: usage => pluginUsageService.record(usage),
         });
         this.imageGenerationService = new PluginImageGenerationService({
-            getAllPlugins: userId => this.getActivePlugins(userId),
-            getPlugin: (id, userId) => this.getPlugin(id, userId),
+            getAllPlugins: userId => this.getActivePluginsUnchecked(userId),
+            getPlugin: (id, userId) => this.getPluginUnchecked(id, userId),
             getApiKey: (plugin, userId) => this.getApiKey(plugin, userId),
             getPluginVariables: (plugin, userId) => this.getPluginVariables(plugin, userId),
             validateEndpointUrl: endpoint => this.validateEndpointUrl(endpoint),
             recordUsage: usage => pluginUsageService.record(usage),
         });
         this.audioGenerationService = new PluginAudioGenerationService({
-            getAllPlugins: userId => this.getActivePlugins(userId),
-            getPlugin: (id, userId) => this.getPlugin(id, userId),
+            getAllPlugins: userId => this.getActivePluginsUnchecked(userId),
+            getPlugin: (id, userId) => this.getPluginUnchecked(id, userId),
             getApiKey: (plugin, userId) => this.getApiKey(plugin, userId),
             getPluginVariables: (plugin, userId) => this.getPluginVariables(plugin, userId),
             validateEndpointUrl: endpoint => this.validateEndpointUrl(endpoint),
             recordUsage: usage => pluginUsageService.record(usage),
         });
         this.videoGenerationService = new PluginVideoGenerationService({
-            getAllPlugins: userId => this.getActivePlugins(userId),
-            getPlugin: (id, userId) => this.getPlugin(id, userId),
+            getAllPlugins: userId => this.getActivePluginsUnchecked(userId),
+            getPlugin: (id, userId) => this.getPluginUnchecked(id, userId),
             getApiKey: (plugin, userId) => this.getApiKey(plugin, userId),
             getPluginVariables: (plugin, userId) => this.getPluginVariables(plugin, userId),
             validateEndpointUrl: endpoint => this.validateEndpointUrl(endpoint),
             recordUsage: usage => pluginUsageService.record(usage),
         });
         this.capabilityRegistryService = new PluginCapabilityRegistryService({
-            getAllPlugins: userId => this.getActivePlugins(userId),
+            getAllPlugins: userId => this.getActivePluginsUnchecked(userId),
             getApiKey: (plugin, userId) => this.getApiKey(plugin, userId),
         });
     }
+    repositories() {
+        return getPersistence(encryptionService).repositories.extensions;
+    }
+    async ensureCacheInvalidation() {
+        this.removeCacheInvalidationListener ?? (this.removeCacheInvalidationListener = registerPluginCacheInvalidationListener(invalidation => this.invalidateRuntimeCaches(invalidation)));
+        await ensurePluginCacheInvalidationSubscription();
+    }
+    bumpDiscoveryRevision(key) {
+        this.discoveryCacheRevisions.set(key, (this.discoveryCacheRevisions.get(key) ?? 0) + 1);
+    }
+    bumpCapabilityDiscoveryRevision(key) {
+        this.capabilityDiscoveryCacheRevisions.set(key, (this.capabilityDiscoveryCacheRevisions.get(key) ?? 0) + 1);
+    }
+    invalidateRuntimeCaches(invalidation) {
+        const completionKeys = new Set([
+            ...this.discoveredModelsCache.keys(),
+            ...this.discoveredModelsUpdatedAt.keys(),
+            ...this.discoveryAttemptedAt.keys(),
+            ...this.inflightDiscovery.keys(),
+            ...this.discoveryCacheRevisions.keys(),
+        ]);
+        const capabilityKeys = new Set([
+            ...this.discoveredCapabilityModelsCache.keys(),
+            ...this.discoveredCapabilityModelsUpdatedAt.keys(),
+            ...this.capabilityDiscoveryAttemptedAt.keys(),
+            ...this.inflightCapabilityDiscovery.keys(),
+            ...this.capabilityDiscoveryCacheRevisions.keys(),
+        ]);
+        const completionMatches = (key) => {
+            if (invalidation.scope === 'plugin-user') {
+                return (key ===
+                    this.discoveredModelsCacheKey(invalidation.pluginId, invalidation.userId));
+            }
+            if (invalidation.scope === 'plugin') {
+                return key.endsWith(`:${invalidation.pluginId}`);
+            }
+            return key.startsWith(`${invalidation.userId}:`);
+        };
+        const capabilityMatches = (key) => {
+            if (invalidation.scope === 'plugin-user') {
+                return key.startsWith(`${invalidation.userId}:${invalidation.pluginId}:`);
+            }
+            if (invalidation.scope === 'plugin') {
+                return key.includes(`:${invalidation.pluginId}:`);
+            }
+            return key.startsWith(`${invalidation.userId}:`);
+        };
+        for (const key of completionKeys) {
+            if (!completionMatches(key))
+                continue;
+            this.discoveredModelsCache.delete(key);
+            this.discoveredModelsUpdatedAt.delete(key);
+            this.discoveryAttemptedAt.delete(key);
+            this.inflightDiscovery.delete(key);
+            this.bumpDiscoveryRevision(key);
+        }
+        for (const key of capabilityKeys) {
+            if (!capabilityMatches(key))
+                continue;
+            this.discoveredCapabilityModelsCache.delete(key);
+            this.discoveredCapabilityModelsUpdatedAt.delete(key);
+            this.capabilityDiscoveryAttemptedAt.delete(key);
+            this.inflightCapabilityDiscovery.delete(key);
+            this.bumpCapabilityDiscoveryRevision(key);
+        }
+    }
+    ensureLegacyActivationMigration() {
+        if (this.sharedPluginDefinitions)
+            return Promise.resolve();
+        this.legacyActivationMigration ?? (this.legacyActivationMigration = pluginActivationService.migrateLegacyStatus([...this.pluginReadDirs]
+            .reverse()
+            .filter(pluginsDir => path.resolve(pluginsDir) !== path.resolve(this.bundledPluginsDir)), pluginId => this.canMigrateLegacyActivation(pluginId)));
+        return this.legacyActivationMigration;
+    }
+    /**
+     * Team replicas must never pick a provider definition from node-local disk.
+     * Refuse startup when an old writable definition is present so an operator
+     * has to migrate it deliberately instead of getting replica-dependent
+     * routing, credentials, or activation state.
+     */
+    assertNoLocalCustomDefinitions() {
+        const bundledDirectory = path.resolve(this.bundledPluginsDir);
+        const directories = new Set([
+            this.pluginsDir,
+            ...this.legacyPluginsDirs,
+            ...this.historicalPluginConflictDirs,
+        ]);
+        for (const directory of directories) {
+            if (path.resolve(directory) === bundledDirectory)
+                continue;
+            let entries;
+            try {
+                const stat = fs.lstatSync(directory);
+                if (!stat.isDirectory() || stat.isSymbolicLink()) {
+                    throw new Error(`Plugin definition path ${directory} is not a physical directory`);
+                }
+                entries = fs.readdirSync(directory, { withFileTypes: true });
+            }
+            catch (error) {
+                if (error.code === 'ENOENT')
+                    continue;
+                throw error;
+            }
+            if (entries.some(entry => entry.name.endsWith('.json'))) {
+                throw new Error(`Local custom plugin definitions exist at ${directory}. PostgreSQL mode requires definitions in the shared database; run the SQLite-to-PostgreSQL migration with the plugin directory before starting any replica.`);
+            }
+        }
+    }
+    parseSharedPluginDefinition(row) {
+        this.sharedDefinitionIds.add(row.plugin_id);
+        if (row.approved_by_user_id === null || row.approved_at === null) {
+            return null;
+        }
+        try {
+            const plugin = JSON.parse(row.definition_json);
+            if (!this.validatePlugin(plugin) ||
+                plugin.id !== row.plugin_id ||
+                getPluginDefinitionFingerprint(plugin) !== row.definition_fingerprint) {
+                return null;
+            }
+            return applyPluginDefinitionPolicy(plugin);
+        }
+        catch {
+            return null;
+        }
+    }
     discoveredModelsCacheKey(pluginId, userId) {
         return `${userId}:${pluginId}`;
     }
     discoveredCapabilityModelsCacheKey(pluginId, capability, userId) {
         return `${userId}:${pluginId}:${capability}`;
     }
-    getDiscoveredCapabilityModels(pluginId, capability, userId) {
+    async getDiscoveredCapabilityModels(pluginId, capability, userId) {
+        await this.ensureCacheInvalidation();
         const effectiveUserId = userId || 'default';
         const cacheKey = this.discoveredCapabilityModelsCacheKey(pluginId, capability, effectiveUserId);
-        if (this.discoveredCapabilityModelsCache.has(cacheKey)) {
+        if (!this.sharedPluginDefinitions &&
+            this.discoveredCapabilityModelsCache.has(cacheKey)) {
             return this.discoveredCapabilityModelsCache.get(cacheKey) || undefined;
         }
-        const db = getDatabaseSafe();
-        if (!db) {
-            this.discoveredCapabilityModelsCache.set(cacheKey, null);
-            return undefined;
-        }
         try {
-            const row = db
-                .prepare(`SELECT models_json, updated_at
-           FROM plugin_discovered_capability_models
-           WHERE user_id = ? AND plugin_id = ? AND capability = ?`)
-                .get(effectiveUserId, pluginId, capability);
+            const row = await this.repositories().pluginDiscovery.getCapability(pluginId, capability, effectiveUserId);
             if (!row) {
                 this.discoveredCapabilityModelsCache.set(cacheKey, null);
                 return undefined;
@@ -228,38 +449,38 @@ export class PluginService {
             return undefined;
         }
     }
-    storeDiscoveredCapabilityModels(pluginId, capability, models, userId) {
+    async storeDiscoveredCapabilityModels(pluginId, capability, models, userId) {
+        await this.ensureCacheInvalidation();
         const effectiveUserId = userId || 'default';
         const uniqueModels = Array.from(new Set(models));
         const cacheKey = this.discoveredCapabilityModelsCacheKey(pluginId, capability, effectiveUserId);
         const discoveredAt = Date.now();
+        await this.repositories().pluginDiscovery.upsertCapability({
+            user_id: effectiveUserId,
+            plugin_id: pluginId,
+            capability,
+            models_json: JSON.stringify(uniqueModels),
+            updated_at: discoveredAt,
+        });
         this.discoveredCapabilityModelsCache.set(cacheKey, uniqueModels);
         this.discoveredCapabilityModelsUpdatedAt.set(cacheKey, discoveredAt);
-        const db = getDatabaseSafe();
-        if (!db)
-            return;
-        db.prepare(`INSERT INTO plugin_discovered_capability_models
-         (user_id, plugin_id, capability, models_json, updated_at)
-       VALUES (?, ?, ?, ?, ?)
-       ON CONFLICT(user_id, plugin_id, capability) DO UPDATE SET
-         models_json = excluded.models_json,
-         updated_at = excluded.updated_at`).run(effectiveUserId, pluginId, capability, JSON.stringify(uniqueModels), discoveredAt);
-    }
-    getDiscoveredModels(pluginId, userId) {
+        await publishPluginCacheInvalidation({
+            version: 1,
+            scope: 'plugin-user',
+            pluginId,
+            userId: effectiveUserId,
+        });
+    }
+    async getDiscoveredModels(pluginId, userId) {
+        await this.ensureCacheInvalidation();
         const effectiveUserId = userId || 'default';
         const cacheKey = this.discoveredModelsCacheKey(pluginId, effectiveUserId);
-        if (this.discoveredModelsCache.has(cacheKey)) {
+        if (!this.sharedPluginDefinitions &&
+            this.discoveredModelsCache.has(cacheKey)) {
             return this.discoveredModelsCache.get(cacheKey) || undefined;
         }
-        const db = getDatabaseSafe();
-        if (!db) {
-            this.discoveredModelsCache.set(cacheKey, null);
-            return undefined;
-        }
         try {
-            const row = db
-                .prepare('SELECT models_json, updated_at FROM plugin_discovered_models WHERE user_id = ? AND plugin_id = ?')
-                .get(effectiveUserId, pluginId);
+            const row = await this.repositories().pluginDiscovery.get(pluginId, effectiveUserId);
             if (!row) {
                 this.discoveredModelsCache.set(cacheKey, null);
                 return undefined;
@@ -284,44 +505,52 @@ export class PluginService {
             return undefined;
         }
     }
-    storeDiscoveredModels(pluginId, models, userId) {
+    async storeDiscoveredModels(pluginId, models, userId) {
+        await this.ensureCacheInvalidation();
         const effectiveUserId = userId || 'default';
         const uniqueModels = Array.from(new Set(models));
         const cacheKey = this.discoveredModelsCacheKey(pluginId, effectiveUserId);
         const discoveredAt = Date.now();
-        this.discoveredModelsCache.set(cacheKey, uniqueModels);
-        this.discoveredModelsUpdatedAt.set(cacheKey, discoveredAt);
-        const db = getDatabaseSafe();
-        if (!db)
-            return;
         try {
-            db.prepare(`INSERT INTO plugin_discovered_models
-          (user_id, plugin_id, models_json, updated_at)
-         VALUES (?, ?, ?, ?)
-         ON CONFLICT(user_id, plugin_id) DO UPDATE SET
-          models_json = excluded.models_json,
-          updated_at = excluded.updated_at`).run(effectiveUserId, pluginId, JSON.stringify(uniqueModels), discoveredAt);
+            await this.repositories().pluginDiscovery.upsert({
+                user_id: effectiveUserId,
+                plugin_id: pluginId,
+                models_json: JSON.stringify(uniqueModels),
+                updated_at: discoveredAt,
+            });
+            this.discoveredModelsCache.set(cacheKey, uniqueModels);
+            this.discoveredModelsUpdatedAt.set(cacheKey, discoveredAt);
+            await publishPluginCacheInvalidation({
+                version: 1,
+                scope: 'plugin-user',
+                pluginId,
+                userId: effectiveUserId,
+            });
         }
         catch (error) {
             logger.warn('Failed to persist discovered models for plugin %s:', pluginId, error);
         }
     }
-    clearDiscoveredModels(pluginId, userId) {
-        this.clearDiscoveredCapabilityModels(pluginId, userId);
-        const db = getDatabaseSafe();
+    async clearDiscoveredModels(pluginId, userId) {
+        await this.ensureCacheInvalidation();
+        await this.clearDiscoveredCapabilityModels(pluginId, userId);
         if (userId) {
             const cacheKey = this.discoveredModelsCacheKey(pluginId, userId);
             this.discoveredModelsCache.set(cacheKey, null);
             this.discoveredModelsUpdatedAt.delete(cacheKey);
             this.discoveryAttemptedAt.delete(cacheKey);
-            if (!db)
-                return;
             try {
-                db.prepare('DELETE FROM plugin_discovered_models WHERE user_id = ? AND plugin_id = ?').run(userId, pluginId);
+                await this.repositories().pluginDiscovery.delete(pluginId, userId);
             }
             catch (error) {
                 logger.warn('Failed to clear discovered models for plugin %s:', pluginId, error);
             }
+            await publishPluginCacheInvalidation({
+                version: 1,
+                scope: 'plugin-user',
+                pluginId,
+                userId,
+            });
             return;
         }
         for (const key of this.discoveredModelsCache.keys()) {
@@ -331,54 +560,65 @@ export class PluginService {
                 this.discoveryAttemptedAt.delete(key);
             }
         }
-        if (!db)
-            return;
         try {
-            db.prepare('DELETE FROM plugin_discovered_models WHERE plugin_id = ?').run(pluginId);
+            await this.repositories().pluginDiscovery.delete(pluginId);
         }
         catch (error) {
             logger.warn('Failed to clear discovered models for plugin %s:', pluginId, error);
         }
+        await publishPluginCacheInvalidation({
+            version: 1,
+            scope: 'plugin',
+            pluginId,
+        });
     }
-    clearDiscoveredCapabilityModels(pluginId, userId) {
-        const db = getDatabaseSafe();
+    async clearDiscoveredCapabilityModels(pluginId, userId) {
         if (userId) {
-            for (const capability of ['image', 'tts', 'audio', 'video']) {
+            for (const capability of [
+                'image',
+                'stt',
+                'tts',
+                'audio',
+                'video',
+            ]) {
                 const key = this.discoveredCapabilityModelsCacheKey(pluginId, capability, userId);
                 this.discoveredCapabilityModelsCache.delete(key);
                 this.discoveredCapabilityModelsUpdatedAt.delete(key);
                 this.capabilityDiscoveryAttemptedAt.delete(key);
             }
-            if (db) {
-                db.prepare(`DELETE FROM plugin_discovered_capability_models
-           WHERE user_id = ? AND plugin_id = ?`).run(userId, pluginId);
-            }
+            // The discovery repository removes both completion and capability rows
+            // atomically, which prevents stale partial catalogs after reset.
+            await this.repositories().pluginDiscovery.delete(pluginId, userId);
             return;
         }
         for (const key of this.discoveredCapabilityModelsCache.keys()) {
-            if (['image', 'tts', 'audio', 'video'].some(capability => key.endsWith(`:${pluginId}:${capability}`))) {
+            if (['image', 'stt', 'tts', 'audio', 'video'].some(capability => key.endsWith(`:${pluginId}:${capability}`))) {
                 this.discoveredCapabilityModelsCache.delete(key);
                 this.discoveredCapabilityModelsUpdatedAt.delete(key);
                 this.capabilityDiscoveryAttemptedAt.delete(key);
             }
         }
-        if (db) {
-            db.prepare('DELETE FROM plugin_discovered_capability_models WHERE plugin_id = ?').run(pluginId);
-        }
+        await this.repositories().pluginDiscovery.delete(pluginId);
     }
-    applyDiscoveredModels(plugin, userId) {
-        if (!this.canUseStoredConnectionOverrides(userId) &&
-            pluginVariablesService.hasStoredConnectionOverride(plugin.id, userId, plugin.variables, getPluginConnectionVariableNames(plugin))) {
+    async applyDiscoveredModels(plugin, userId) {
+        if (!(await this.canUseStoredConnectionOverrides(userId)) &&
+            (await pluginVariablesService.hasStoredConnectionOverride(plugin.id, userId, plugin.variables, getPluginConnectionVariableNames(plugin)))) {
             return plugin;
         }
-        const models = this.getDiscoveredModels(plugin.id, userId);
+        const models = await this.getDiscoveredModels(plugin.id, userId);
         const capabilities = plugin.capabilities
             ? { ...plugin.capabilities }
             : undefined;
         if (capabilities) {
-            for (const capability of ['image', 'tts', 'audio', 'video']) {
+            for (const capability of [
+                'image',
+                'stt',
+                'tts',
+                'audio',
+                'video',
+            ]) {
                 const definition = capabilities[capability];
-                const discovered = this.getDiscoveredCapabilityModels(plugin.id, capability, userId);
+                const discovered = await this.getDiscoveredCapabilityModels(plugin.id, capability, userId);
                 if (definition && discovered) {
                     capabilities[capability] = {
                         ...definition,
@@ -394,8 +634,76 @@ export class PluginService {
         };
     }
     ensurePluginsDirectory() {
-        if (!fs.existsSync(this.pluginsDir)) {
+        const dataDirectory = resolveDataDirectory();
+        const configuredRelativeToData = path.relative(dataDirectory, this.pluginsDir);
+        const configuredPathRoot = configuredRelativeToData === '' ||
+            (configuredRelativeToData !== '..' &&
+                !configuredRelativeToData.startsWith(`..${path.sep}`) &&
+                !path.isAbsolute(configuredRelativeToData))
+            ? dataDirectory
+            : process.env.PLUGINS_DIR?.trim() &&
+                !path.isAbsolute(process.env.PLUGINS_DIR.trim())
+                ? PROJECT_DIRECTORY
+                : path.dirname(this.pluginsDir);
+        try {
+            if (hasSymlinkPathComponentFromRoot(configuredPathRoot, this.pluginsDir)) {
+                throw new Error('PLUGINS_DIR cannot contain a symbolic-link path component');
+            }
+            const pluginsStat = fs.lstatSync(this.pluginsDir);
+            if (!pluginsStat.isDirectory() || pluginsStat.isSymbolicLink()) {
+                throw new Error('PLUGINS_DIR must be a physical directory, not a symlink or special file');
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
             fs.mkdirSync(this.pluginsDir, { recursive: true });
+            const createdStat = fs.lstatSync(this.pluginsDir);
+            if (!createdStat.isDirectory() || createdStat.isSymbolicLink()) {
+                throw new Error('PLUGINS_DIR could not be created safely');
+            }
+        }
+        for (const legacyDirectory of this.legacyPluginsDirs) {
+            const relativeToBackend = path.relative(BACKEND_DIRECTORY, legacyDirectory);
+            const legacyRoot = relativeToBackend === '' ||
+                (relativeToBackend !== '..' &&
+                    !relativeToBackend.startsWith(`..${path.sep}`) &&
+                    !path.isAbsolute(relativeToBackend))
+                ? BACKEND_DIRECTORY
+                : path.dirname(legacyDirectory);
+            if (hasSymlinkPathComponentFromRoot(legacyRoot, legacyDirectory)) {
+                throw new Error('A legacy plugin path contains a symbolic-link component; refusing to follow it');
+            }
+            const legacyStat = (() => {
+                try {
+                    return fs.lstatSync(legacyDirectory);
+                }
+                catch (error) {
+                    if (error.code === 'ENOENT')
+                        return null;
+                    throw error;
+                }
+            })();
+            if (legacyStat &&
+                (!legacyStat.isDirectory() || legacyStat.isSymbolicLink())) {
+                throw new Error('A legacy plugin path is not a physical directory; refusing to follow it');
+            }
+        }
+        for (const historicalDirectory of this.historicalPluginConflictDirs) {
+            let historicalEntries;
+            try {
+                historicalEntries = fs.readdirSync(historicalDirectory, {
+                    withFileTypes: true,
+                });
+            }
+            catch (error) {
+                if (error.code === 'ENOENT')
+                    continue;
+                throw new Error(`Historical plugin directory ${historicalDirectory} cannot be inspected safely`);
+            }
+            if (historicalEntries.some(entry => entry.name.endsWith('.json'))) {
+                throw new Error(`Legacy plugin definitions exist at ${historicalDirectory}, where the relative PLUGINS_DIR previously resolved from the caller working directory. Move them into ${this.pluginsDir} or configure an absolute PLUGINS_DIR; Libre will not silently choose between them.`);
+            }
         }
     }
     bundledPluginPath(id) {
@@ -405,19 +713,12 @@ export class PluginService {
         return (path.resolve(filePath) === this.bundledPluginPath(plugin.id) &&
             matchesBundledPluginTrustAnchor(plugin));
     }
-    isPluginDefinitionApproved(plugin, filePath) {
+    async isPluginDefinitionApproved(plugin, filePath) {
         if (this.isAnchoredBundledDefinition(plugin, filePath)) {
             return true;
         }
-        const db = getDatabaseSafe();
-        if (!db)
-            return false;
         try {
-            const row = db
-                .prepare(`SELECT definition_fingerprint, source_path
-           FROM plugin_definition_approvals
-           WHERE plugin_id = ?`)
-                .get(plugin.id);
+            const row = await this.repositories().pluginApprovals.find(plugin.id);
             return (row?.definition_fingerprint ===
                 getPluginDefinitionFingerprint(plugin) &&
                 row.source_path === path.resolve(filePath));
@@ -427,46 +728,30 @@ export class PluginService {
             return false;
         }
     }
-    approvePluginDefinition(plugin, filePath, userId) {
-        if (!this.canUseStoredConnectionOverrides(userId)) {
+    async approvePluginDefinition(plugin, filePath, userId) {
+        if (!(await this.canUseStoredConnectionOverrides(userId))) {
             throw new Error('Administrator approval is required');
         }
-        const db = getDatabaseSafe();
-        if (!db) {
-            throw new Error('Database not available for plugin approval');
-        }
-        db.prepare(`INSERT INTO plugin_definition_approvals
-         (plugin_id, definition_fingerprint, source_path,
-          approved_by_user_id, approved_at)
-       VALUES (?, ?, ?, ?, ?)
-       ON CONFLICT(plugin_id) DO UPDATE SET
-         definition_fingerprint = excluded.definition_fingerprint,
-         source_path = excluded.source_path,
-         approved_by_user_id = excluded.approved_by_user_id,
-         approved_at = excluded.approved_at`).run(plugin.id, getPluginDefinitionFingerprint(plugin), path.resolve(filePath), userId, Date.now());
-    }
-    removePluginDefinitionApproval(pluginId) {
-        const db = getDatabaseSafe();
-        if (!db)
-            return;
-        db.prepare('DELETE FROM plugin_definition_approvals WHERE plugin_id = ?').run(pluginId);
+        await this.repositories().pluginApprovals.upsert({
+            plugin_id: plugin.id,
+            definition_fingerprint: getPluginDefinitionFingerprint(plugin),
+            source_path: path.resolve(filePath),
+            approved_by_user_id: userId,
+            approved_at: Date.now(),
+        });
     }
-    revokePluginDefinitionConsent(pluginId) {
-        const db = getDatabaseSafe();
-        if (!db) {
-            throw new Error('Database not available for plugin approval');
-        }
-        db.transaction(() => {
-            db.prepare('DELETE FROM plugin_activations WHERE plugin_id = ?').run(pluginId);
-            db.prepare('DELETE FROM plugin_definition_approvals WHERE plugin_id = ?').run(pluginId);
-        })();
+    async removePluginDefinitionApproval(pluginId) {
+        await this.repositories().pluginApprovals.delete(pluginId);
+    }
+    async revokePluginDefinitionConsent(pluginId) {
+        await this.repositories().pluginApprovals.revokeConsent(pluginId);
     }
     canMigrateLegacyActivation(pluginId) {
         const effectivePath = this.resolveEffectivePluginFilePath(pluginId);
         if (!effectivePath)
             return false;
         try {
-            const parsedPlugin = JSON.parse(fs.readFileSync(effectivePath, 'utf8'));
+            const parsedPlugin = JSON.parse(readRegularPluginDefinition(effectivePath));
             return (this.validatePlugin(parsedPlugin) &&
                 parsedPlugin.id === pluginId &&
                 this.isAnchoredBundledDefinition(parsedPlugin, effectivePath));
@@ -482,9 +767,31 @@ export class PluginService {
         for (const pluginsDir of [...this.pluginReadDirs].reverse()) {
             const resolvedDirectory = path.resolve(pluginsDir);
             const candidate = path.resolve(pluginsDir, `${sanitizedId}.json`);
-            if (candidate.startsWith(resolvedDirectory) && fs.existsSync(candidate)) {
+            if (!candidate.startsWith(resolvedDirectory))
+                continue;
+            const directoryStat = (() => {
+                try {
+                    return fs.lstatSync(pluginsDir);
+                }
+                catch {
+                    return null;
+                }
+            })();
+            if (directoryStat &&
+                (!directoryStat.isDirectory() || directoryStat.isSymbolicLink())) {
+                // Preserve precedence while forcing the no-follow reader to reject the
+                // unsafe path instead of falling back to a lower-priority definition.
                 return candidate;
             }
+            try {
+                fs.lstatSync(candidate);
+                // Return invalid named entries too. The strict reader will reject them,
+                // preventing a symlink/special-file shadow from revealing a bundled ID.
+                return candidate;
+            }
+            catch {
+                // Continue to lower-priority sources only when the named entry is absent.
+            }
         }
         return null;
     }
@@ -503,7 +810,7 @@ export class PluginService {
             return null;
         }
         try {
-            const parsedPlugin = JSON.parse(fs.readFileSync(bundledPath, 'utf8'));
+            const parsedPlugin = JSON.parse(readRegularPluginDefinition(bundledPath));
             if (!this.validatePlugin(parsedPlugin) ||
                 parsedPlugin.id !== sanitizedId ||
                 !matchesBundledPluginTrustAnchor(parsedPlugin)) {
@@ -521,6 +828,10 @@ export class PluginService {
         }
     }
     usesTrustedBundledRouting(plugin) {
+        if (this.sharedPluginDefinitions &&
+            this.sharedDefinitionIds.has(plugin.id)) {
+            return false;
+        }
         const effectivePath = this.resolveEffectivePluginFilePath(plugin.id);
         const bundledPath = this.bundledPluginPath(plugin.id);
         if (!effectivePath || effectivePath !== bundledPath)
@@ -529,18 +840,12 @@ export class PluginService {
         return (bundledProjection !== null &&
             getPluginRoutingAuthProjection(plugin) === bundledProjection);
     }
-    isPluginActive(pluginId, userId) {
-        return pluginActivationService.getActivePluginIds(userId).has(pluginId);
+    async isPluginActive(pluginId, userId) {
+        return (await pluginActivationService.getActivePluginIds(userId)).has(pluginId);
     }
-    canUseStoredConnectionOverrides(userId) {
-        const db = getDatabaseSafe();
-        if (!db)
-            return false;
+    async canUseStoredConnectionOverrides(userId) {
         try {
-            const row = db
-                .prepare('SELECT role FROM users WHERE id = ?')
-                .get(userId || 'default');
-            return row?.role === 'admin';
+            return ((await userModel.getUserById(userId || 'default'))?.role === 'admin');
         }
         catch (error) {
             logger.warn('Failed to resolve plugin routing permission:', error);
@@ -553,7 +858,7 @@ export class PluginService {
      * @param userId Optional user ID for per-user credentials
      * @returns The API key or null if not found
      */
-    getApiKey(plugin, userId) {
+    async getApiKey(plugin, userId) {
         if (plugin.id === CODEX_OAUTH_PLUGIN_ID) {
             // Resolved from the server's Codex CLI sign-in, never user credentials.
             // A writable same-ID definition must never receive the server user's
@@ -563,13 +868,13 @@ export class PluginService {
                 ? codexOAuthService.getCachedAccessToken()
                 : null;
         }
-        const hasHonoredConnectionOverride = this.canUseStoredConnectionOverrides(userId) &&
-            pluginVariablesService.hasStoredConnectionOverride(plugin.id, userId, plugin.variables, getPluginConnectionVariableNames(plugin));
+        const hasHonoredConnectionOverride = (await this.canUseStoredConnectionOverrides(userId)) &&
+            (await pluginVariablesService.hasStoredConnectionOverride(plugin.id, userId, plugin.variables, getPluginConnectionVariableNames(plugin)));
         const usesTrustedBundledRouting = this.usesTrustedBundledRouting(plugin);
         const allowTrustedFallback = usesTrustedBundledRouting && !hasHonoredConnectionOverride;
         return pluginCredentialsService.getApiKey(plugin.id, plugin.auth.key_env, userId, {
             allowEnvironmentFallback: allowTrustedFallback,
-            expectedRoutingAuthFingerprint: this.getCredentialRoutingAuthFingerprint(plugin, userId),
+            expectedRoutingAuthFingerprint: await this.getCredentialRoutingAuthFingerprint(plugin, userId),
             allowLegacyUnboundCredential: allowTrustedFallback,
         });
     }
@@ -577,8 +882,8 @@ export class PluginService {
      * Bind a user credential to the exact routing/authentication contract in
      * effect when they save it. Generation controls are intentionally excluded.
      */
-    getCredentialRoutingAuthFingerprint(plugin, userId) {
-        const variables = this.getPluginVariables(plugin, userId);
+    async getCredentialRoutingAuthFingerprint(plugin, userId) {
+        const variables = await this.getPluginVariables(plugin, userId);
         const effectiveConnectionValues = Array.from(getPluginConnectionVariableNames(plugin), name => {
             const definition = plugin.variables?.find(candidate => candidate.name === name);
             if (!definition)
@@ -588,11 +893,18 @@ export class PluginService {
                 value: variables[name] ?? definition.default ?? '',
             };
         });
-        const effectivePath = this.resolveEffectivePluginFilePath(plugin.id);
+        const sharedDefinition = this.sharedPluginDefinitions
+            ? await this.repositories().pluginDefinitions.find(plugin.id)
+            : null;
+        if (sharedDefinition)
+            this.sharedDefinitionIds.add(plugin.id);
+        const effectivePath = sharedDefinition
+            ? null
+            : this.resolveEffectivePluginFilePath(plugin.id);
         let effectiveDefinitionFingerprint = getPluginDefinitionFingerprint(plugin);
         if (effectivePath) {
             try {
-                const effectiveDefinition = JSON.parse(fs.readFileSync(effectivePath, 'utf8'));
+                const effectiveDefinition = JSON.parse(readRegularPluginDefinition(effectivePath));
                 if (this.validatePlugin(effectiveDefinition) &&
                     effectiveDefinition.id === plugin.id) {
                     effectiveDefinitionFingerprint =
@@ -608,7 +920,11 @@ export class PluginService {
             plugin_id: plugin.id,
             plugin_type: plugin.type,
             trusted_bundled_source: this.usesTrustedBundledRouting(plugin),
-            effective_source_path: effectivePath ? path.resolve(effectivePath) : null,
+            effective_source_path: sharedDefinition
+                ? 'database:plugin_definitions'
+                : effectivePath
+                    ? path.resolve(effectivePath)
+                    : null,
             effective_definition_fingerprint: effectiveDefinitionFingerprint,
             routing_auth_projection: getPluginRoutingAuthProjection(plugin),
             effective_connection_values: effectiveConnectionValues,
@@ -618,12 +934,12 @@ export class PluginService {
     /**
      * Get resolved variable values for a plugin (decrypted, typed).
      */
-    getPluginVariables(plugin, userId) {
+    async getPluginVariables(plugin, userId) {
         if (!plugin.variables || plugin.variables.length === 0) {
             return {};
         }
-        const variables = pluginVariablesService.getResolvedVariables(plugin.id, plugin.variables, userId);
-        if (this.canUseStoredConnectionOverrides(userId))
+        const variables = await pluginVariablesService.getResolvedVariables(plugin.id, plugin.variables, userId);
+        if (await this.canUseStoredConnectionOverrides(userId))
             return variables;
         return Object.fromEntries(Object.entries(variables).map(([name, value]) => {
             if (!getPluginConnectionVariableNames(plugin).has(name)) {
@@ -646,8 +962,8 @@ export class PluginService {
      * boundary ordered prevents a rejected override from ever selecting an
      * environment credential.
      */
-    resolveOperationEndpoint(plugin, userId) {
-        return resolvePluginApiConfig(plugin, this.getPluginVariables(plugin, userId)).endpoint;
+    async resolveOperationEndpoint(plugin, userId) {
+        return resolvePluginApiConfig(plugin, await this.getPluginVariables(plugin, userId)).endpoint;
     }
     /**
      * Attempt to auto-discover available models from a plugin's full API endpoint.
@@ -665,12 +981,16 @@ export class PluginService {
      * is fresh.
      */
     async discoverModelsResult(pluginId, userId) {
+        await this.ensureCacheInvalidation();
         const cacheKey = this.discoveredModelsCacheKey(pluginId, userId || 'default');
         const inflight = this.inflightDiscovery.get(cacheKey);
         if (inflight)
             return inflight;
-        const attempt = this.runModelDiscovery(pluginId, userId).finally(() => {
-            this.inflightDiscovery.delete(cacheKey);
+        const revision = this.discoveryCacheRevisions.get(cacheKey) ?? 0;
+        const attempt = this.runModelDiscovery(pluginId, userId, revision).finally(() => {
+            if (this.inflightDiscovery.get(cacheKey) === attempt) {
+                this.inflightDiscovery.delete(cacheKey);
+            }
         });
         this.inflightDiscovery.set(cacheKey, attempt);
         return attempt;
@@ -680,13 +1000,13 @@ export class PluginService {
      * immediately; stored ones age out after the TTL. Both cases are gated by a
      * per-plugin backoff so a failing provider is not probed on every request.
      */
-    isModelDiscoveryDue(pluginId, userId) {
+    async isModelDiscoveryDue(pluginId, userId) {
         const cacheKey = this.discoveredModelsCacheKey(pluginId, userId || 'default');
         const attemptedAt = this.discoveryAttemptedAt.get(cacheKey);
         if (attemptedAt && Date.now() - attemptedAt < modelDiscoveryRetryMs()) {
             return false;
         }
-        const models = this.getDiscoveredModels(pluginId, userId);
+        const models = await this.getDiscoveredModels(pluginId, userId);
         const updatedAt = this.discoveredModelsUpdatedAt.get(cacheKey);
         if (!models || !updatedAt)
             return true;
@@ -699,8 +1019,13 @@ export class PluginService {
      * the next request.
      */
     async refreshStaleModels(userId) {
-        const due = this.getActivePlugins(userId).filter(plugin => (plugin.type === 'completion' || plugin.type === 'chat') &&
-            this.isModelDiscoveryDue(plugin.id, userId));
+        const due = [];
+        for (const plugin of await this.getActivePlugins(userId)) {
+            if ((plugin.type === 'completion' || plugin.type === 'chat') &&
+                (await this.isModelDiscoveryDue(plugin.id, userId))) {
+                due.push(plugin);
+            }
+        }
         if (due.length === 0)
             return;
         const refreshes = Promise.all(due.map(plugin => this.discoverModels(plugin.id, userId).catch(() => [])));
@@ -710,30 +1035,39 @@ export class PluginService {
         ]);
     }
     async discoverCapabilityModels(pluginId, capability, userId) {
+        await this.ensureCacheInvalidation();
         const cacheKey = this.discoveredCapabilityModelsCacheKey(pluginId, capability, userId || 'default');
         const inflight = this.inflightCapabilityDiscovery.get(cacheKey);
         if (inflight)
             return inflight;
-        const attempt = this.runCapabilityModelDiscovery(pluginId, capability, userId).finally(() => this.inflightCapabilityDiscovery.delete(cacheKey));
+        const revision = this.capabilityDiscoveryCacheRevisions.get(cacheKey) ?? 0;
+        const attempt = this.runCapabilityModelDiscovery(pluginId, capability, userId, revision).finally(() => {
+            if (this.inflightCapabilityDiscovery.get(cacheKey) === attempt) {
+                this.inflightCapabilityDiscovery.delete(cacheKey);
+            }
+        });
         this.inflightCapabilityDiscovery.set(cacheKey, attempt);
         return attempt;
     }
-    isCapabilityModelDiscoveryDue(pluginId, capability, userId) {
+    async isCapabilityModelDiscoveryDue(pluginId, capability, userId) {
         const cacheKey = this.discoveredCapabilityModelsCacheKey(pluginId, capability, userId || 'default');
         const attemptedAt = this.capabilityDiscoveryAttemptedAt.get(cacheKey);
         if (attemptedAt && Date.now() - attemptedAt < modelDiscoveryRetryMs()) {
             return false;
         }
-        const models = this.getDiscoveredCapabilityModels(pluginId, capability, userId);
+        const models = await this.getDiscoveredCapabilityModels(pluginId, capability, userId);
         const updatedAt = this.discoveredCapabilityModelsUpdatedAt.get(cacheKey);
         return (!models || !updatedAt || Date.now() - updatedAt >= modelDiscoveryTtlMs());
     }
     async refreshStaleCapabilityModels(capability, userId) {
-        const due = this.getActivePlugins(userId).filter(plugin => {
+        const due = [];
+        for (const plugin of await this.getActivePlugins(userId)) {
             const definition = plugin.capabilities?.[capability];
-            return (Boolean(definition?.models_endpoint) &&
-                this.isCapabilityModelDiscoveryDue(plugin.id, capability, userId));
-        });
+            if (Boolean(definition?.models_endpoint) &&
+                (await this.isCapabilityModelDiscoveryDue(plugin.id, capability, userId))) {
+                due.push(plugin);
+            }
+        }
         if (due.length === 0)
             return;
         const refreshes = Promise.all(due.map(plugin => this.discoverCapabilityModels(plugin.id, capability, userId).catch(() => undefined)));
@@ -742,8 +1076,8 @@ export class PluginService {
             new Promise(resolve => setTimeout(resolve, modelDiscoveryRefreshDeadlineMs()).unref?.()),
         ]);
     }
-    async runCapabilityModelDiscovery(pluginId, capability, userId) {
-        const plugin = this.getPlugin(pluginId, userId);
+    async runCapabilityModelDiscovery(pluginId, capability, userId, expectedRevision) {
+        const plugin = await this.getPlugin(pluginId, userId);
         const definition = plugin?.capabilities?.[capability];
         if (!plugin || !definition) {
             return {
@@ -757,9 +1091,20 @@ export class PluginService {
         }
         const cacheKey = this.discoveredCapabilityModelsCacheKey(pluginId, capability, userId || 'default');
         this.capabilityDiscoveryAttemptedAt.set(cacheKey, Date.now());
-        const modelsEndpoint = definition.models_endpoint;
+        const config = definition.config && typeof definition.config === 'object'
+            ? definition.config
+            : {};
+        const modelsEndpointVariable = config.models_endpoint_variable;
+        const pluginVariables = await this.getPluginVariables(plugin, userId);
+        const modelsEndpointOverride = typeof modelsEndpointVariable === 'string'
+            ? pluginVariables[modelsEndpointVariable]
+            : undefined;
+        const modelsEndpoint = typeof modelsEndpointOverride === 'string' &&
+            modelsEndpointOverride.trim().length > 0
+            ? this.validateEndpointUrl(modelsEndpointOverride.trim())
+            : definition.models_endpoint;
         assertSafePluginEndpoint(modelsEndpoint, `${capability} model discovery endpoint`);
-        const apiKey = this.getApiKey(plugin, userId);
+        const apiKey = await this.getApiKey(plugin, userId);
         if (pluginRequiresApiKey(plugin) && !apiKey) {
             return {
                 models: definition.model_map,
@@ -787,7 +1132,15 @@ export class PluginService {
                 };
             }
             const previous = definition.model_map;
-            this.storeDiscoveredCapabilityModels(pluginId, capability, models, userId);
+            if ((this.capabilityDiscoveryCacheRevisions.get(cacheKey) ?? 0) !==
+                expectedRevision) {
+                return {
+                    models: previous,
+                    outcome: 'unavailable',
+                    reason: 'Provider configuration changed during discovery',
+                };
+            }
+            await this.storeDiscoveredCapabilityModels(pluginId, capability, models, userId);
             return {
                 models,
                 outcome: JSON.stringify(previous) === JSON.stringify(models)
@@ -816,19 +1169,19 @@ export class PluginService {
         }
         return 'No API key is configured for this provider.';
     }
-    async runModelDiscovery(pluginId, userId) {
-        const plugin = this.getPlugin(pluginId, userId);
+    async runModelDiscovery(pluginId, userId, expectedRevision) {
+        const plugin = await this.getPlugin(pluginId, userId);
         if (!plugin) {
             return { models: [], outcome: 'unavailable', reason: 'Plugin not found' };
         }
         this.discoveryAttemptedAt.set(this.discoveredModelsCacheKey(pluginId, userId || 'default'), Date.now());
-        const pluginVars = this.getPluginVariables(plugin, userId);
+        const pluginVars = await this.getPluginVariables(plugin, userId);
         const { endpoint: effectiveEndpoint } = resolvePluginApiConfig(plugin, pluginVars);
         const modelsEndpoint = resolvePluginModelsEndpoint(effectiveEndpoint, typeof pluginVars.models_endpoint === 'string'
             ? pluginVars.models_endpoint
             : undefined);
         assertSafePluginEndpoint(modelsEndpoint, 'model discovery endpoint');
-        const apiKey = this.getApiKey(plugin, userId);
+        const apiKey = await this.getApiKey(plugin, userId);
         if (pluginRequiresApiKey(plugin) && !apiKey) {
             logger.debug('[Plugin] Model discovery for %s has no usable API key; keeping the existing catalog', pluginId);
             return {
@@ -851,8 +1204,17 @@ export class PluginService {
                 if (models.length > 0) {
                     logger.debug('[Plugin] Auto-discovered %d models for %s:', models.length, pluginId, models);
                     const previousModels = plugin.model_map;
-                    this.storeDiscoveredModels(pluginId, models, userId);
-                    const stored = this.getDiscoveredModels(pluginId, userId) || models;
+                    const cacheKey = this.discoveredModelsCacheKey(pluginId, userId || 'default');
+                    if ((this.discoveryCacheRevisions.get(cacheKey) ?? 0) !==
+                        expectedRevision) {
+                        return {
+                            models: previousModels,
+                            outcome: 'unavailable',
+                            reason: 'Provider configuration changed during discovery',
+                        };
+                    }
+                    await this.storeDiscoveredModels(pluginId, models, userId);
+                    const stored = (await this.getDiscoveredModels(pluginId, userId)) || models;
                     return {
                         models: stored,
                         outcome: JSON.stringify(stored) === JSON.stringify(previousModels)
@@ -874,26 +1236,46 @@ export class PluginService {
         }
     }
     // List all installed plugins
-    getAllPlugins(userId) {
+    async getAllPluginsUnchecked(userId) {
+        await this.ensureLegacyActivationMigration();
         const plugins = new Map();
-        const activePluginIds = pluginActivationService.getActivePluginIds(userId);
+        const activePluginIds = await pluginActivationService.getActivePluginIds(userId);
         for (const pluginsDir of this.pluginReadDirs) {
-            if (!fs.existsSync(pluginsDir)) {
+            const directoryStat = (() => {
+                try {
+                    return fs.lstatSync(pluginsDir);
+                }
+                catch {
+                    return null;
+                }
+            })();
+            if (!directoryStat) {
+                continue;
+            }
+            if (!directoryStat.isDirectory() || directoryStat.isSymbolicLink()) {
+                plugins.clear();
+                logger.error('Ignoring unsafe plugin directory %s and every lower-priority definition', pluginsDir);
                 continue;
             }
             try {
-                const files = fs.readdirSync(pluginsDir);
-                for (const file of files) {
+                const entries = fs.readdirSync(pluginsDir, { withFileTypes: true });
+                for (const entry of entries) {
+                    const file = entry.name;
                     if (file.endsWith('.json') && !file.startsWith('.')) {
                         const filenameId = path.basename(file, '.json');
                         try {
                             const filePath = path.join(pluginsDir, file);
-                            const content = fs.readFileSync(filePath, 'utf8');
+                            if (!entry.isFile() || entry.isSymbolicLink()) {
+                                plugins.delete(filenameId);
+                                logger.error('Ignoring non-regular plugin definition %s', filePath);
+                                continue;
+                            }
+                            const content = readRegularPluginDefinition(filePath);
                             const parsedPlugin = JSON.parse(content);
                             // Validate plugin structure
                             if (this.validatePlugin(parsedPlugin) &&
                                 parsedPlugin.id === filenameId) {
-                                if (!this.isPluginDefinitionApproved(parsedPlugin, filePath)) {
+                                if (!(await this.isPluginDefinitionApproved(parsedPlugin, filePath))) {
                                     // A later writable definition shadows an earlier bundled
                                     // definition even while quarantined.
                                     plugins.delete(parsedPlugin.id);
@@ -901,7 +1283,7 @@ export class PluginService {
                                 }
                                 const plugin = applyPluginDefinitionPolicy(parsedPlugin);
                                 plugin.active = activePluginIds.has(plugin.id);
-                                plugins.set(plugin.id, this.applyDiscoveredModels(plugin, userId));
+                                plugins.set(plugin.id, await this.applyDiscoveredModels(plugin, userId));
                             }
                             else if (parsedPlugin.id !== filenameId) {
                                 plugins.delete(filenameId);
@@ -924,41 +1306,84 @@ export class PluginService {
                 logger.error(`Failed to read plugins directory ${pluginsDir}:`, error);
             }
         }
-        return Array.from(plugins.values()).filter(plugin => this.isPluginVisibleToUser(plugin, userId));
+        if (this.sharedPluginDefinitions) {
+            const definitions = await this.repositories().pluginDefinitions.list();
+            const currentDefinitionIds = new Set(definitions.map(definition => definition.plugin_id));
+            for (const pluginId of this.sharedDefinitionIds) {
+                if (!currentDefinitionIds.has(pluginId)) {
+                    this.sharedDefinitionIds.delete(pluginId);
+                }
+            }
+            for (const definition of definitions) {
+                // The shared row has precedence over bundled release assets even when
+                // corrupt or unapproved, preserving quarantine rather than silently
+                // changing the provider route on another replica.
+                plugins.delete(definition.plugin_id);
+                const plugin = this.parseSharedPluginDefinition(definition);
+                if (!plugin) {
+                    logger.error('Ignoring invalid or unapproved shared plugin definition %s', definition.plugin_id);
+                    continue;
+                }
+                plugin.active = activePluginIds.has(plugin.id);
+                plugins.set(plugin.id, await this.applyDiscoveredModels(plugin, userId));
+            }
+        }
+        return Array.from(plugins.values());
+    }
+    async getAllPlugins(userId) {
+        const plugins = await this.getAllPluginsUnchecked(userId);
+        const visible = [];
+        for (const plugin of plugins) {
+            if (await this.isPluginVisibleToUser(plugin, userId)) {
+                visible.push(plugin);
+            }
+        }
+        return visible;
     }
     /**
      * The codex-oauth plugin rides the server user's ChatGPT sign-in, so it is
      * administrator-only and hidden entirely when no sign-in exists.
      */
-    isPluginVisibleToUser(plugin, userId) {
+    async isPluginVisibleToUser(plugin, userId) {
         if (plugin.id !== CODEX_OAUTH_PLUGIN_ID)
             return true;
         if (!codexOAuthService.isAvailable())
             return false;
         if (!userId)
             return false;
-        return userModel.getUserById(userId)?.role === 'admin';
+        return (await userModel.getUserById(userId))?.role === 'admin';
     }
     // Get a specific plugin by ID
-    getPlugin(id, userId) {
+    async loadPlugin(id, userId) {
+        await this.ensureLegacyActivationMigration();
         // Sanitize the ID to prevent path traversal
         const sanitizedId = sanitize(id);
         if (!sanitizedId || sanitizedId !== id) {
             logger.error('Invalid plugin ID provided:', id);
             return null;
         }
+        if (this.sharedPluginDefinitions) {
+            const definition = await this.repositories().pluginDefinitions.find(sanitizedId);
+            if (definition) {
+                const plugin = this.parseSharedPluginDefinition(definition);
+                if (!plugin)
+                    return null;
+                plugin.active = await this.isPluginActive(plugin.id, userId);
+                return this.applyDiscoveredModels(plugin, userId);
+            }
+            this.sharedDefinitionIds.delete(sanitizedId);
+        }
         const filePath = this.resolveEffectivePluginFilePath(sanitizedId);
         if (!filePath)
             return null;
         try {
-            const content = fs.readFileSync(filePath, 'utf8');
+            const content = readRegularPluginDefinition(filePath);
             const parsedPlugin = JSON.parse(content);
             if (this.validatePlugin(parsedPlugin) &&
                 parsedPlugin.id === sanitizedId &&
-                this.isPluginDefinitionApproved(parsedPlugin, filePath) &&
-                this.isPluginVisibleToUser(parsedPlugin, userId)) {
+                (await this.isPluginDefinitionApproved(parsedPlugin, filePath))) {
                 const plugin = applyPluginDefinitionPolicy(parsedPlugin);
-                plugin.active = this.isPluginActive(plugin.id, userId);
+                plugin.active = await this.isPluginActive(plugin.id, userId);
                 return this.applyDiscoveredModels(plugin, userId);
             }
         }
@@ -967,15 +1392,29 @@ export class PluginService {
         }
         return null;
     }
+    async getPluginUnchecked(id, userId) {
+        if (id === CODEX_OAUTH_PLUGIN_ID)
+            return null;
+        return this.loadPlugin(id, userId);
+    }
+    async getPlugin(id, userId) {
+        const plugin = await this.loadPlugin(id, userId);
+        if (!plugin || !(await this.isPluginVisibleToUser(plugin, userId))) {
+            return null;
+        }
+        return plugin;
+    }
     // Install or update a plugin
-    installPlugin(pluginData, approvedByUserId) {
+    async installPlugin(pluginData, approvedByUserId) {
+        if (!this.sharedPluginDefinitions)
+            this.ensurePluginsDirectory();
         if (!this.validatePlugin(pluginData)) {
             throw new Error('Invalid plugin structure');
         }
         if (pluginData.id === CODEX_OAUTH_PLUGIN_ID) {
             throw new Error('The bundled Codex OAuth plugin ID is reserved');
         }
-        if (!this.canUseStoredConnectionOverrides(approvedByUserId)) {
+        if (!(await this.canUseStoredConnectionOverrides(approvedByUserId))) {
             throw new Error('Administrator approval is required');
         }
         const now = Date.now();
@@ -988,6 +1427,20 @@ export class PluginService {
         const safeId = plugin.id.replace(/[^a-zA-Z0-9_.-]/g, '');
         if (safeId !== plugin.id)
             throw new Error('Invalid plugin ID');
+        if (this.sharedPluginDefinitions) {
+            await this.repositories().pluginDefinitions.replaceApproved({
+                plugin_id: plugin.id,
+                definition_json: JSON.stringify(plugin, null, 2),
+                definition_fingerprint: getPluginDefinitionFingerprint(plugin),
+                approved_by_user_id: approvedByUserId,
+                approved_at: now,
+                created_at: plugin.created_at || now,
+                updated_at: now,
+            });
+            this.sharedDefinitionIds.add(plugin.id);
+            await this.clearDiscoveredModels(plugin.id);
+            return plugin;
+        }
         const filePath = path.resolve(this.pluginsDir, `${safeId}.json`);
         if (!filePath.startsWith(path.resolve(this.pluginsDir))) {
             throw new Error('Path traversal detected');
@@ -995,8 +1448,8 @@ export class PluginService {
         // Revoke definition approval and every user's activation before replacing
         // bytes on disk. Any crash or write failure therefore leaves the provider
         // quarantined and inactive.
-        this.revokePluginDefinitionConsent(plugin.id);
-        this.clearDiscoveredModels(plugin.id);
+        await this.revokePluginDefinitionConsent(plugin.id);
+        await this.clearDiscoveredModels(plugin.id);
         const temporaryPath = path.resolve(this.pluginsDir, `.${safeId}.${process.pid}.${Date.now()}.tmp`);
         try {
             fs.writeFileSync(temporaryPath, JSON.stringify(plugin, null, 2), {
@@ -1010,11 +1463,11 @@ export class PluginService {
             }
             throw error;
         }
-        this.approvePluginDefinition(plugin, filePath, approvedByUserId);
+        await this.approvePluginDefinition(plugin, filePath, approvedByUserId);
         return plugin;
     }
     // Delete a plugin
-    deletePlugin(id) {
+    async deletePlugin(id) {
         // Validate the ID parameter using a strict pattern (allows dots for version numbers like 1.6b)
         const idPattern = /^[a-zA-Z0-9._-]+$/;
         if (!idPattern.test(id)) {
@@ -1027,23 +1480,37 @@ export class PluginService {
             logger.error('Plugin ID failed sanitization:', id);
             return false;
         }
+        if (this.sharedPluginDefinitions) {
+            try {
+                const removed = await this.repositories().pluginDefinitions.deleteWithState(id);
+                if (!removed)
+                    return false;
+                this.sharedDefinitionIds.delete(id);
+                await this.clearDiscoveredModels(id);
+                return true;
+            }
+            catch (error) {
+                logger.error('Failed to delete shared plugin %s:', sanitizedId, error);
+                return false;
+            }
+        }
         const bundledDirectory = path.resolve(this.bundledPluginsDir);
-        const writablePluginDirs = Array.from(new Set([this.pluginsDir, this.legacyPluginsDir])).filter(pluginsDir => path.resolve(pluginsDir) !== bundledDirectory);
+        const writablePluginDirs = Array.from(new Set([this.pluginsDir, ...this.legacyPluginsDirs])).filter(pluginsDir => path.resolve(pluginsDir) !== bundledDirectory);
         const filePath = writablePluginDirs
             .map(pluginsDir => path.resolve(pluginsDir, `${sanitizedId}.json`))
-            .find(candidate => fs.existsSync(candidate));
+            .find(candidate => isRegularPluginDefinition(candidate));
         if (!filePath) {
             logger.error('File path is invalid or does not exist:', filePath);
             return false;
         }
         try {
             fs.unlinkSync(filePath);
-            pluginActivationService.deletePlugin(id);
-            this.removePluginDefinitionApproval(id);
+            await pluginActivationService.deletePlugin(id);
+            await this.removePluginDefinitionApproval(id);
             // Clean up stored variables
-            pluginVariablesService.deletePluginVariables(id);
-            pluginCredentialsService.deleteAllPluginCredentials(id);
-            this.clearDiscoveredModels(id);
+            await pluginVariablesService.deletePluginVariables(id);
+            await pluginCredentialsService.deleteAllPluginCredentials(id);
+            await this.clearDiscoveredModels(id);
             return true;
         }
         catch (error) {
@@ -1053,21 +1520,31 @@ export class PluginService {
     }
     // Activate a plugin
     async activatePlugin(id, userId) {
-        const plugin = this.getPlugin(id, userId);
+        const plugin = await this.getPlugin(id, userId);
         if (!plugin) {
             throw new Error('Plugin not found');
         }
-        if (!pluginActivationService.activate(id, userId)) {
+        if (!(await pluginActivationService.activate(id, userId))) {
             throw new Error('Failed to persist plugin activation');
         }
         // Wait for discovery so the activation response and the UI's first reload
-        // observe the same user-scoped model catalog.
-        await Promise.all([
-            this.discoverModels(id, userId).catch(() => []),
-            ...['image', 'tts', 'audio', 'video']
-                .filter(capability => plugin.capabilities?.[capability]?.models_endpoint)
-                .map(capability => this.discoverCapabilityModels(id, capability, userId).catch(() => undefined)),
-        ]);
+        // observe the same user-scoped model catalog. These writes are deliberately
+        // sequential: each persisted catalog publishes a cross-replica plugin-user
+        // invalidation. Running sibling discoveries concurrently would make the
+        // first completed catalog advance every sibling's configuration revision,
+        // causing the remaining valid results to be discarded as stale.
+        await this.discoverModels(id, userId).catch(() => []);
+        for (const capability of [
+            'image',
+            'stt',
+            'tts',
+            'audio',
+            'video',
+        ]) {
+            if (!plugin.capabilities?.[capability]?.models_endpoint)
+                continue;
+            await this.discoverCapabilityModels(id, capability, userId).catch(() => undefined);
+        }
         return true;
     }
     // Deactivate a specific plugin
@@ -1076,67 +1553,104 @@ export class PluginService {
         return pluginActivationService.deactivate(id, userId);
     }
     // Get the active plugin for a specific model
-    getActivePluginForModel(model, userId, pluginId) {
+    async getActivePluginForModel(model, userId, pluginId) {
         if (pluginId) {
-            const plugin = this.getPlugin(pluginId, userId);
+            let plugin = await this.getPlugin(pluginId, userId);
             if (!plugin) {
                 throw new Error(`Plugin not found: ${pluginId}`);
             }
-            if (!this.isPluginActive(pluginId, userId)) {
+            if (!(await this.isPluginActive(pluginId, userId))) {
                 throw new Error(`Plugin is not active: ${pluginId}`);
             }
             if (!plugin.model_map.includes(model)) {
-                throw new Error(`Model ${model} is not supported by plugin ${pluginId}`);
+                // The UI offers a live-fetched catalog, so a just-released provider
+                // model can be requested before the shared store carries it — and an
+                // external worker resolves from the shared store only. Refresh a due
+                // catalog once before rejecting; the discovery backoff keeps a
+                // mistyped model from probing the provider on every request.
+                if (await this.isModelDiscoveryDue(pluginId, userId)) {
+                    await this.discoverModelsResult(pluginId, userId).catch(() => undefined);
+                    plugin = await this.getPlugin(pluginId, userId);
+                }
+                if (!plugin?.model_map.includes(model)) {
+                    throw new Error(`Model ${model} is not supported by plugin ${pluginId}`);
+                }
             }
-            this.resolveOperationEndpoint(plugin, userId);
-            const apiKey = this.getApiKey(plugin, userId);
+            await this.resolveOperationEndpoint(plugin, userId);
+            const apiKey = await this.getApiKey(plugin, userId);
             if (pluginRequiresApiKey(plugin) && !apiKey) {
                 throw new Error(`API key not found for plugin ${pluginId} (save a provider credential in Settings)`);
             }
             return plugin;
         }
         // Only route through plugins the user explicitly activated.
-        const activePlugins = this.getActivePlugins(userId);
+        const activePlugins = await this.getActivePlugins(userId);
         // Find the active plugin that supports this model
         for (const plugin of activePlugins) {
             if (plugin.model_map.includes(model)) {
                 // Local OpenAI-compatible servers can explicitly opt out of auth by
                 // leaving both auth fields empty.
-                this.resolveOperationEndpoint(plugin, userId);
-                const apiKey = this.getApiKey(plugin, userId);
+                await this.resolveOperationEndpoint(plugin, userId);
+                const apiKey = await this.getApiKey(plugin, userId);
                 if (pluginRequiresApiKey(plugin) && !apiKey) {
                     continue;
                 }
                 return plugin;
             }
         }
+        // Same store-vs-catalog skew guard for sessions without an explicit
+        // provider: refresh every due catalog once, then rescan before giving up.
+        let refreshedAnyCatalog = false;
+        for (const plugin of activePlugins) {
+            if ((plugin.type === 'completion' || plugin.type === 'chat') &&
+                (await this.isModelDiscoveryDue(plugin.id, userId))) {
+                await this.discoverModelsResult(plugin.id, userId).catch(() => undefined);
+                refreshedAnyCatalog = true;
+            }
+        }
+        if (refreshedAnyCatalog) {
+            for (const plugin of await this.getActivePlugins(userId)) {
+                if (plugin.model_map.includes(model)) {
+                    await this.resolveOperationEndpoint(plugin, userId);
+                    const apiKey = await this.getApiKey(plugin, userId);
+                    if (pluginRequiresApiKey(plugin) && !apiKey) {
+                        continue;
+                    }
+                    return plugin;
+                }
+            }
+        }
         return null;
     }
     // Get all currently active plugins
-    getActivePlugins(userId) {
-        const allPlugins = this.getAllPlugins(userId);
+    async getActivePlugins(userId) {
+        const allPlugins = await this.getAllPlugins(userId);
         const activePlugins = allPlugins.filter(plugin => plugin.active);
         return activePlugins;
     }
+    async getActivePluginsUnchecked(userId) {
+        return (await this.getAllPluginsUnchecked(userId)).filter(plugin => plugin.active && plugin.id !== CODEX_OAUTH_PLUGIN_ID);
+    }
     // Legacy method for backward compatibility - returns first active plugin
-    getActivePlugin(userId) {
-        const activePlugins = this.getActivePlugins(userId);
+    async getActivePlugin(userId) {
+        const activePlugins = await this.getActivePlugins(userId);
         return activePlugins.length > 0 ? activePlugins[0] : null;
     }
     // Get plugin status
-    getPluginStatus(userId) {
-        const plugins = this.getAllPlugins(userId);
-        return plugins.map(plugin => ({
+    async getPluginStatus(userId) {
+        const plugins = await this.getAllPlugins(userId);
+        return Promise.all(plugins.map(async (plugin) => ({
             id: plugin.id,
             active: plugin.active || false,
             available: !pluginRequiresApiKey(plugin) ||
-                this.getApiKey(plugin, userId) !== null,
-        }));
+                (await this.getApiKey(plugin, userId)) !== null,
+        })));
     }
     // Execute a chat request through the active plugin
-    async executePluginRequest(model, messages, options = {}, userId, pluginId) {
+    async executePluginRequest(model, messages, options = {}, userId, pluginId, signal) {
+        throwIfChatGenerationCancelled(signal);
         validatePluginModel(model);
-        const activePlugin = this.getActivePluginForModel(model, userId, pluginId);
+        const activePlugin = await this.getActivePluginForModel(model, userId, pluginId);
         if (!activePlugin) {
             throw new Error(`No active plugin found for model: ${model}`);
         }
@@ -1144,11 +1658,11 @@ export class PluginService {
             throw new Error(`Model ${model} is not supported by plugin ${activePlugin.id}`);
         }
         if (activePlugin.id === CODEX_OAUTH_PLUGIN_ID) {
-            await codexOAuthService.ensureFreshToken();
+            await codexOAuthService.ensureFreshToken(signal);
             // The codex endpoint only answers as an SSE stream; aggregate it here
             // so non-streaming callers still get a complete response.
             let aggregated = '';
-            for await (const chunk of this.executePluginStreamRequest(model, messages, options, userId, activePlugin.id)) {
+            for await (const chunk of this.executePluginStreamRequest(model, messages, options, userId, activePlugin.id, signal)) {
                 if (chunk.type === 'content' && chunk.content) {
                     aggregated += chunk.content;
                 }
@@ -1157,11 +1671,11 @@ export class PluginService {
                 choices: [{ message: { role: 'assistant', content: aggregated } }],
             };
         }
-        const pluginVars = this.getPluginVariables(activePlugin, userId);
+        const pluginVars = await this.getPluginVariables(activePlugin, userId);
         const { apiMode, endpoint: effectiveEndpoint } = resolvePluginApiConfig(activePlugin, pluginVars);
         const processedEndpoint = applyModelEndpointTemplate(effectiveEndpoint, model);
         assertSafePluginEndpoint(processedEndpoint, 'endpoint URL constructed');
-        const apiKey = this.getApiKey(activePlugin, userId);
+        const apiKey = await this.getApiKey(activePlugin, userId);
         if (pluginRequiresApiKey(activePlugin) && !apiKey) {
             throw new Error(`API key not found for plugin ${activePlugin.id} (save a provider credential in Settings)`);
         }
@@ -1177,6 +1691,7 @@ export class PluginService {
                 headers,
                 timeout: 60000, // 60 second timeout
                 maxRedirects: 0,
+                signal,
             });
             const normalized = convertProviderResponse(activePlugin, response.data, model, apiMode, providerStateScope);
             pluginUsageService.record({
@@ -1198,16 +1713,22 @@ export class PluginService {
             return normalized;
         }
         catch (error) {
+            const cancelled = isChatGenerationCancelled(error, signal);
             pluginUsageService.record({
                 userId,
                 pluginId: activePlugin.id,
                 pluginName: activePlugin.name,
                 capability: 'chat',
                 model,
-                status: 'error',
+                status: cancelled ? 'cancelled' : 'error',
                 durationMs: Date.now() - startedAt,
             });
-            logger.error(`Plugin request failed for ${activePlugin.id}:`, error);
+            if (!cancelled) {
+                logger.error(`Plugin request failed for ${activePlugin.id}:`, error);
+            }
+            if (cancelled) {
+                throw error;
+            }
             if (error && typeof error === 'object' && 'response' in error) {
                 const axiosError = error;
                 throw new Error(`Plugin API error: ${axiosError.response.status} - ${axiosError.response.data?.error?.message || axiosError.response.statusText}`);
@@ -1226,9 +1747,10 @@ export class PluginService {
      * Returns an async generator that yields SSE delta content strings.
      * Also collects tool_calls from the stream.
      */
-    async *executePluginStreamRequest(model, messages, options = {}, userId, pluginId) {
+    async *executePluginStreamRequest(model, messages, options = {}, userId, pluginId, signal) {
+        throwIfChatGenerationCancelled(signal);
         validatePluginModel(model);
-        const activePlugin = this.getActivePluginForModel(model, userId, pluginId);
+        const activePlugin = await this.getActivePluginForModel(model, userId, pluginId);
         if (!activePlugin) {
             throw new Error(`No active plugin found for model: ${model}`);
         }
@@ -1236,13 +1758,13 @@ export class PluginService {
             throw new Error(`Model ${model} is not supported by plugin ${activePlugin.id}`);
         }
         if (activePlugin.id === CODEX_OAUTH_PLUGIN_ID) {
-            await codexOAuthService.ensureFreshToken();
+            await codexOAuthService.ensureFreshToken(signal);
         }
-        const pluginVars = this.getPluginVariables(activePlugin, userId);
+        const pluginVars = await this.getPluginVariables(activePlugin, userId);
         const { apiMode, endpoint: effectiveEndpoint } = resolvePluginApiConfig(activePlugin, pluginVars);
         const processedEndpoint = applyModelEndpointTemplate(effectiveEndpoint, model);
         assertSafePluginEndpoint(processedEndpoint);
-        const apiKey = this.getApiKey(activePlugin, userId);
+        const apiKey = await this.getApiKey(activePlugin, userId);
         if (pluginRequiresApiKey(activePlugin) && !apiKey) {
             throw new Error(`API key not found for plugin ${activePlugin.id} (save a provider credential in Settings)`);
         }
@@ -1301,6 +1823,7 @@ export class PluginService {
                 headers,
                 body: JSON.stringify(payload),
                 redirect: 'error',
+                signal,
             });
             if (activePlugin.id === 'anthropic') {
                 yield* forward(streamAnthropicResponse(response));
@@ -1377,7 +1900,7 @@ export class PluginService {
             status = 'success';
         }
         catch (error) {
-            status = 'error';
+            status = isChatGenerationCancelled(error, signal) ? 'cancelled' : 'error';
             throw error;
         }
         finally {
@@ -1436,23 +1959,29 @@ export class PluginService {
             pluginRecord.model_map.length > 0);
     }
     // Export plugin to JSON
-    exportPlugin(id, userId) {
+    async exportPlugin(id, userId) {
         return this.getPlugin(id, userId);
     }
     // Import plugin from JSON data
-    importPlugin(pluginData, approvedByUserId) {
+    async importPlugin(pluginData, approvedByUserId) {
         // Validate and clean the plugin data
         if (!this.validatePlugin(pluginData)) {
             throw new Error('Invalid plugin data');
         }
+        if (this.sharedPluginDefinitions) {
+            const existing = await this.repositories().pluginDefinitions.find(pluginData.id);
+            if (existing && this.parseSharedPluginDefinition(existing)) {
+                throw new Error(`Plugin with ID ${pluginData.id} already exists`);
+            }
+        }
         // Check if plugin already exists
         const existingPluginPath = this.resolveEffectivePluginFilePath(pluginData.id);
         if (existingPluginPath) {
             try {
-                const existingPlugin = JSON.parse(fs.readFileSync(existingPluginPath, 'utf8'));
+                const existingPlugin = JSON.parse(readRegularPluginDefinition(existingPluginPath));
                 if (this.validatePlugin(existingPlugin) &&
                     existingPlugin.id === pluginData.id &&
-                    this.isPluginDefinitionApproved(existingPlugin, existingPluginPath)) {
+                    (await this.isPluginDefinitionApproved(existingPlugin, existingPluginPath))) {
                     throw new Error(`Plugin with ID ${pluginData.id} already exists`);
                 }
             }
@@ -1470,59 +1999,88 @@ export class PluginService {
     // ============================================
     // Capability Methods
     // ============================================
-    getPluginForTTS(model, pluginId, userId) {
+    async getPluginForTTS(model, pluginId, userId) {
         return this.ttsService.getPluginForTTS(model, pluginId, userId);
     }
-    getPluginForEmbedding(model, pluginId, userId) {
+    async getPluginForEmbedding(model, pluginId, userId) {
         return this.embeddingService.getPluginForEmbedding(model, pluginId, userId);
     }
-    getAvailableEmbeddingModels(userId) {
+    async getAvailableEmbeddingModels(userId) {
         return this.embeddingService.getAvailableEmbeddingModels(userId);
     }
-    async executeEmbeddingRequest(model, input, pluginId, userId) {
-        return this.embeddingService.executeEmbeddingRequest(model, input, pluginId, userId);
+    async executeEmbeddingRequest(model, input, pluginId, userId, signal) {
+        return this.embeddingService.executeEmbeddingRequest(model, input, pluginId, userId, signal);
     }
-    getAvailableTTSModels(userId) {
+    async getAvailableTTSModels(userId) {
         return this.ttsService.getAvailableTTSModels(userId);
     }
+    async getAvailableSTTModels(userId) {
+        return this.sttService.getAvailableModels(userId);
+    }
+    executeSTTRequest(model, audio, options) {
+        return this.sttService.transcribe(model, audio, options);
+    }
     async executeTTSRequest(model, input, options = {}) {
         return this.ttsService.executeTTSRequest(model, input, options);
     }
-    getTTSConfig(pluginId, userId) {
+    async executeVoiceCloneRequest(model, input, referenceAudio, options = {}) {
+        return this.ttsService.executeVoiceCloneRequest(model, input, referenceAudio, options);
+    }
+    async getTTSConfig(pluginId, userId) {
         return this.ttsService.getTTSConfig(pluginId, userId);
     }
-    getPluginForImageGen(model, pluginId, userId) {
+    async getPluginForImageGen(model, pluginId, userId) {
         return this.imageGenerationService.getPluginForImageGen(model, pluginId, userId);
     }
-    getAvailableImageGenModels(userId) {
+    async getAvailableImageGenModels(userId) {
         return this.imageGenerationService.getAvailableImageGenModels(userId);
     }
     async executeImageGenRequest(model, prompt, options) {
         return this.imageGenerationService.executeImageGenRequest(model, prompt, options);
     }
-    getImageGenConfig(pluginId, userId) {
+    async getImageGenConfig(pluginId, userId) {
         return this.imageGenerationService.getImageGenConfig(pluginId, userId);
     }
-    getPluginsByCapability(capabilityType, userId) {
+    async getPluginsByCapability(capabilityType, userId) {
         return this.capabilityRegistryService.getPluginsByCapability(capabilityType, userId);
     }
-    getAvailableAudioGenModels(userId) {
+    async getAvailableAudioGenModels(userId) {
         return this.audioGenerationService.getAvailableModels(userId);
     }
     executeAudioGenRequest(model, prompt, options) {
         return this.audioGenerationService.generate(model, prompt, options);
     }
-    getAvailableVideoGenModels(userId) {
+    async getAvailableVideoGenModels(userId) {
         return this.videoGenerationService.getAvailableModels(userId);
     }
     submitVideoGenRequest(model, prompt, options) {
         return this.videoGenerationService.submit(model, prompt, options);
     }
-    pollVideoGenRequest(model, providerJobId, pluginId, userId) {
-        return this.videoGenerationService.poll(model, providerJobId, pluginId, userId);
-    }
-    downloadVideoGenResult(model, providerJobId, pluginId, userId) {
-        return this.videoGenerationService.download(model, providerJobId, pluginId, userId);
+    pollVideoGenRequest(model, providerJobId, pluginId, userId, signal) {
+        return this.videoGenerationService.poll(model, providerJobId, pluginId, userId, signal);
+    }
+    downloadVideoGenResult(model, providerJobId, pluginId, userId, signal) {
+        return this.videoGenerationService.download(model, providerJobId, pluginId, userId, signal);
+    }
+    async canCancelVideoGenRequest(model, pluginId, userId) {
+        return this.videoGenerationService.supportsCancellation(model, pluginId, userId);
+    }
+    cancelVideoGenRequest(model, providerJobId, pluginId, userId, signal) {
+        return this.videoGenerationService.cancel(model, providerJobId, pluginId, userId, signal);
+    }
+    async closeCacheInvalidation() {
+        this.removeCacheInvalidationListener?.();
+        this.removeCacheInvalidationListener = undefined;
+        this.discoveredModelsCache.clear();
+        this.discoveredModelsUpdatedAt.clear();
+        this.discoveryAttemptedAt.clear();
+        this.inflightDiscovery.clear();
+        this.discoveredCapabilityModelsCache.clear();
+        this.discoveredCapabilityModelsUpdatedAt.clear();
+        this.capabilityDiscoveryAttemptedAt.clear();
+        this.inflightCapabilityDiscovery.clear();
+        this.discoveryCacheRevisions.clear();
+        this.capabilityDiscoveryCacheRevisions.clear();
     }
 }
 export default new PluginService();