@jupyterlite/ai 0.14.0 → 0.16.0

package/lib/index.js

@@ -1,29 +1,31 @@
 import { ILabShell, ILayoutRestorer } from '@jupyterlab/application';
 import { ActiveCellManager, AttachmentOpenerRegistry, chatIcon, ChatCommandRegistry, ChatWidget, IChatCommandRegistry, IChatTracker, IInputToolbarRegistryFactory, InputToolbarRegistry, MultiChatPanel } from '@jupyter/chat';
-import { ICommandPalette, IThemeManager, showErrorMessage, WidgetTracker } from '@jupyterlab/apputils';
+import { ICommandPalette, IThemeManager, showDialog, showErrorMessage, WidgetTracker } from '@jupyterlab/apputils';
 import { ICompletionProviderManager } from '@jupyterlab/completer';
 import { IDocumentManager } from '@jupyterlab/docmanager';
+import { FileDialog } from '@jupyterlab/filebrowser';
 import { INotebookTracker } from '@jupyterlab/notebook';
 import { IRenderMimeRegistry } from '@jupyterlab/rendermime';
 import { ISettingRegistry } from '@jupyterlab/settingregistry';
 import { IStatusBar } from '@jupyterlab/statusbar';
 import { PathExt } from '@jupyterlab/coreutils';
 import { ITranslator, nullTranslator } from '@jupyterlab/translation';
-import { settingsIcon, Toolbar, ToolbarButton } from '@jupyterlab/ui-components';
-import { ISecretsManager, SecretsManager } from 'jupyter-secrets-manager';
+import { fileUploadIcon, saveIcon, settingsIcon, Toolbar, ToolbarButton } from '@jupyterlab/ui-components';
 import { PromiseDelegate, UUID } from '@lumino/coreutils';
 import { DisposableSet } from '@lumino/disposable';
+import { IComponentsRendererFactory } from 'jupyter-chat-components';
+import { ISecretsManager, SecretsManager } from 'jupyter-secrets-manager';
 import { AgentManagerFactory } from './agent';
 import { RenderedMessageOutputAreaCompat } from './rendered-message-outputarea';
 import { ClearCommandProvider } from './chat-commands/clear';
 import { SkillsCommandProvider } from './chat-commands/skills';
 import { ProviderRegistry } from './providers/provider-registry';
-import { ApprovalButtons } from './approval-buttons';
+import { SaveComponentWidget } from './components/save-button';
 import { ChatModelHandler } from './chat-model-handler';
-import { CommandIds, IAgentManagerFactory, IProviderRegistry, IToolRegistry, ISkillRegistry, SECRETS_NAMESPACE, IAISettingsModel, IChatModelHandler, IDiffManager } from './tokens';
+import { CommandIds, IAgentManagerFactory, IAISettingsModel, IChatModelHandler, IDiffManager, IProviderRegistry, IToolRegistry, ISkillRegistry, SECRETS_NAMESPACE } from './tokens';
 import { anthropicProvider, googleProvider, mistralProvider, openaiProvider, genericProvider } from './providers/built-in-providers';
 import { AICompletionProvider } from './completion';
-import { clearItem, createModelSelectItem, createToolSelectItem, stopItem, CompletionStatusWidget, TokenUsageWidget } from './components';
+import { clearItem, createModelSelectItem, createToolSelectItem, stopItem, CompletionStatusWidget, UsageWidget } from './components';
 import { AISettingsModel } from './models/settings-model';
 import { loadSkillsFromPaths, SkillRegistry } from './skills';
 import { DiffManager } from './diff-manager';
@@ -198,8 +200,8 @@ const chatModelHandler = {
     ],
     optional: [IProviderRegistry, IToolRegistry, ITranslator],
     provides: IChatModelHandler,
-    activate: (app, settingsModel, agentManagerFactory, docManager, rmRegistry, providerRegistry, toolRegistry, translator) => {
-        const trans = (translator ?? nullTranslator).load('jupyterlite_ai');
+    activate: async (app, settingsModel, agentManagerFactory, docManager, rmRegistry, providerRegistry, toolRegistry) => {
+        await app.serviceManager.ready;
         return new ChatModelHandler({
             settingsModel,
             agentManagerFactory,
@@ -207,7 +209,7 @@ const chatModelHandler = {
             rmRegistry,
             providerRegistry,
             toolRegistry,
-            trans
+            contentsManager: app.serviceManager.contents
         });
     }
 };
@@ -231,9 +233,12 @@ const plugin = {
         ILayoutRestorer,
         ILabShell,
         INotebookTracker,
-        ITranslator
+        ITranslator,
+        IComponentsRendererFactory,
+        ICommandPalette,
+        IDocumentManager
     ],
-    activate: (app, rmRegistry, inputToolbarFactory, modelHandler, settingsModel, chatCommandRegistry, themeManager, restorer, labShell, notebookTracker, translator) => {
+    activate: (app, rmRegistry, inputToolbarFactory, modelHandler, settingsModel, chatCommandRegistry, themeManager, restorer, labShell, notebookTracker, translator, chatComponentsFactory, palette, documentManager) => {
         const trans = (translator ?? nullTranslator).load('jupyterlite_ai');
         // Create attachment opener registry to handle file attachments
         const attachmentOpenerRegistry = new AttachmentOpenerRegistry();
@@ -286,7 +291,10 @@ const plugin = {
                     name = `${modelName}-${i}`;
                     i += 1;
                 }
-                const model = modelHandler.createModel(name, provider);
+                const model = modelHandler.createModel({
+                    name,
+                    activeProvider: provider
+                });
                 return { model };
             },
             getChatNames: async () => {
@@ -330,7 +338,7 @@ const plugin = {
             app.commands.commandChanged.connect(onCommandChanged);
             chatPanel.disposed.connect(disconnectSettingsButtonListener);
         }
-        let tokenUsageWidget = null;
+        let usageWidget = null;
         chatPanel.chatOpened.connect((_, widget) => {
             const model = widget.model;
             // Add the widget to the tracker.
@@ -343,14 +351,21 @@ const plugin = {
             // Update the tracker if the active provider changed.
             model.agentManager.activeProviderChanged.connect(saveTracker);
             // Update the token usage widget.
-            tokenUsageWidget?.dispose();
-            tokenUsageWidget = new TokenUsageWidget({
+            usageWidget?.dispose();
+            usageWidget = new UsageWidget({
                 tokenUsageChanged: model.tokenUsageChanged,
                 settingsModel,
                 initialTokenUsage: model.agentManager.tokenUsage,
                 translator: trans
             });
-            chatPanel.current?.toolbar.insertBefore('markRead', 'token-usage', tokenUsageWidget);
+            chatPanel.current?.toolbar.insertBefore('markRead', 'usage', usageWidget);
+            if (model.saveAvailable) {
+                const saveChatButton = new SaveComponentWidget({
+                    model,
+                    translator: trans
+                });
+                chatPanel.current?.toolbar.insertAfter('markRead', 'saveChat', saveChatButton);
+            }
             // Listen for writers change to display the stop button.
             function writersChanged(_, writers) {
                 // Check if AI is currently writing (streaming)
@@ -365,11 +380,6 @@ const plugin = {
                 }
             }
             model.writersChanged?.connect(writersChanged);
-            // Associate an approval buttons object to the chat.
-            const approvalButton = new ApprovalButtons({
-                chatPanel: widget,
-                agentManager: model.agentManager
-            });
             // Temporary compat: keep output-area CSS context for MIME renderers
             // until jupyter-chat provides it natively.
             const outputAreaCompat = new RenderedMessageOutputAreaCompat({
@@ -380,10 +390,15 @@ const plugin = {
                 model.agentManager.activeProviderChanged.disconnect(saveTracker);
                 model.writersChanged?.disconnect(writersChanged);
                 // Dispose of the approval buttons widget when the chat is disposed.
-                approvalButton.dispose();
                 outputAreaCompat.dispose();
             });
         });
+        /**
+         * Update the available chat list when settings config changed.
+         */
+        settingsModel.stateChanged.connect(() => {
+            chatPanel.updateChatList();
+        });
         app.shell.add(chatPanel, 'left', { rank: 1000 });
         if (restorer) {
             restorer.add(chatPanel, chatPanel.id);
@@ -406,11 +421,26 @@ const plugin = {
                 app.commands.execute(CommandIds.openChat);
             }
         });
-        registerCommands(app, rmRegistry, chatPanel, attachmentOpenerRegistry, inputToolbarFactory, settingsModel, chatCommandRegistry, tracker, modelHandler, trans, themeManager, labShell);
+        registerCommands(app, rmRegistry, chatPanel, attachmentOpenerRegistry, inputToolbarFactory, settingsModel, chatCommandRegistry, tracker, modelHandler, trans, themeManager, labShell, palette, documentManager);
+        /**
+         * The callback to approve or reject a tool.
+         */
+        function toolCallApproval(targetId, approvalId, isApproved) {
+            const model = tracker.find(chat => chat.model.name === targetId)?.model;
+            if (!model) {
+                return;
+            }
+            isApproved
+                ? model.agentManager.approveToolCall(approvalId)
+                : model.agentManager.rejectToolCall(approvalId);
+        }
+        if (chatComponentsFactory) {
+            chatComponentsFactory.toolCallApproval = toolCallApproval;
+        }
         return tracker;
     }
 };
-function registerCommands(app, rmRegistry, chatPanel, attachmentOpenerRegistry, inputToolbarFactory, settingsModel, chatCommandRegistry, tracker, modelRegistry, trans, themeManager, labShell) {
+function registerCommands(app, rmRegistry, chatPanel, attachmentOpenerRegistry, inputToolbarFactory, settingsModel, chatCommandRegistry, tracker, modelRegistry, trans, themeManager, labShell, palette, documentManager) {
     const { commands } = app;
     if (labShell) {
         commands.addCommand(CommandIds.reposition, {
@@ -506,7 +536,10 @@ function registerCommands(app, rmRegistry, chatPanel, attachmentOpenerRegistry,
                 if (!name) {
                     name = providerConfig.name;
                 }
-                const model = modelRegistry.createModel(name, provider);
+                const model = modelRegistry.createModel({
+                    name,
+                    activeProvider: provider
+                });
                 if (!model) {
                     return false;
                 }
@@ -577,9 +610,12 @@ function registerCommands(app, rmRegistry, chatPanel, attachmentOpenerRegistry,
                 // model. The previous is intended to be disposed anyway.
                 previousModel.name = UUID.uuid4();
                 // Create a new model by duplicating the previous model attributes.
-                const model = modelRegistry.createModel(args.name, previousModel.agentManager.activeProvider, previousModel.agentManager.tokenUsage);
-                previousModel?.messages.forEach(message => {
-                    model?.messageAdded({ ...message.content });
+                const model = modelRegistry.createModel({
+                    name: args.name,
+                    activeProvider: previousModel.agentManager.activeProvider,
+                    tokenUsage: previousModel.agentManager.tokenUsage,
+                    messages: previousModel.messages,
+                    autosave: previousModel.autosave
                 });
                 // Wait (with timeout) for the tracker to have updated the previous widget.
                 const status = await Promise.any([
@@ -620,6 +656,128 @@ function registerCommands(app, rmRegistry, chatPanel, attachmentOpenerRegistry,
                 }
             }
         });
+        commands.addCommand(CommandIds.saveChat, {
+            label: args => (args.isPalette ? trans.__('Save chat') : ''),
+            caption: trans.__('Save the chat as local file'),
+            icon: saveIcon,
+            execute: async (args) => {
+                let model = null;
+                if (args.name) {
+                    tracker.forEach(widget => {
+                        if (widget.model.name === args.name) {
+                            model = widget.model;
+                        }
+                    });
+                }
+                else {
+                    model = tracker.currentWidget?.model ?? null;
+                }
+                if (model === null) {
+                    console.log('No chat to save');
+                    return false;
+                }
+                model.save();
+                return true;
+            },
+            describedBy: {
+                args: {
+                    type: 'object',
+                    properties: {
+                        isPalette: {
+                            type: 'boolean',
+                            description: trans.__('Whether the command is in palette')
+                        },
+                        name: {
+                            type: 'string',
+                            description: trans.__('The name of the chat to save')
+                        }
+                    }
+                }
+            }
+        });
+        commands.addCommand(CommandIds.restoreChat, {
+            label: args => (args.isPalette ? trans.__('Restore chat') : ''),
+            caption: trans.__('Restore the chat from a local file'),
+            icon: fileUploadIcon,
+            isVisible: () => !!documentManager,
+            execute: async (args) => {
+                if (!documentManager) {
+                    console.warn('The restoration is not possible');
+                    return false;
+                }
+                let model = null;
+                if (args.name) {
+                    tracker.forEach(widget => {
+                        if (widget.model.name === args.name) {
+                            model = widget.model;
+                        }
+                    });
+                }
+                else {
+                    model = tracker.currentWidget?.model ?? null;
+                }
+                if (model === null) {
+                    console.warn('There is no chat to restore');
+                    return false;
+                }
+                let backupDirExists = false;
+                await app.serviceManager.contents
+                    .get(settingsModel.config.chatBackupDirectory, { content: false })
+                    .then(() => (backupDirExists = true))
+                    .catch(() => (backupDirExists = false));
+                const selection = await FileDialog.getOpenFiles({
+                    title: trans.__('Select files to attach'),
+                    manager: documentManager,
+                    defaultPath: backupDirExists
+                        ? settingsModel.config.chatBackupDirectory
+                        : ''
+                });
+                const filepath = selection.value?.[0].path;
+                if (!filepath) {
+                    return false;
+                }
+                if (model.messages.length) {
+                    const result = await showDialog({
+                        body: trans.__('All the message will be deleted')
+                    });
+                    if (!result.button.accept) {
+                        return false;
+                    }
+                }
+                return model.restore(filepath);
+            },
+            describedBy: {
+                args: {
+                    type: 'object',
+                    properties: {
+                        isPalette: {
+                            type: 'boolean',
+                            description: trans.__('Whether the command is in palette')
+                        },
+                        name: {
+                            type: 'string',
+                            description: trans.__('The name of the chat to save')
+                        }
+                    }
+                }
+            }
+        });
+        if (palette) {
+            palette.addItem({
+                category: trans.__('AI Assistant'),
+                command: CommandIds.saveChat,
+                args: {
+                    isPalette: true
+                }
+            });
+            palette.addItem({
+                category: trans.__('AI Assistant'),
+                command: CommandIds.restoreChat,
+                args: {
+                    isPalette: true
+                }
+            });
+        }
     }
 }
 /**

package/lib/models/settings-model.d.ts

@@ -1,61 +1,14 @@
 import { VDomModel } from '@jupyterlab/ui-components';
 import { ISettingRegistry } from '@jupyterlab/settingregistry';
-export interface IProviderParameters {
-    temperature?: number;
-    maxOutputTokens?: number;
-    maxTurns?: number;
-    supportsFillInMiddle?: boolean;
-    useFilterText?: boolean;
-}
-export interface IProviderConfig {
-    id: string;
-    name: string;
-    provider: string;
-    model: string;
-    apiKey?: string;
-    baseURL?: string;
-    headers?: Record<string, string>;
-    parameters?: IProviderParameters;
-    customSettings?: Record<string, any>;
-    [key: string]: any;
-}
-export interface IMCPServerConfig {
-    id: string;
-    name: string;
-    url: string;
-    enabled: boolean;
-    [key: string]: any;
-}
-export interface IAIConfig {
-    useSecretsManager: boolean;
-    providers: IProviderConfig[];
-    defaultProvider: string;
-    activeCompleterProvider?: string;
-    useSameProviderForChatAndCompleter: boolean;
-    mcpServers: IMCPServerConfig[];
-    contextAwareness: boolean;
-    codeExecution: boolean;
-    systemPrompt: string;
-    completionSystemPrompt: string;
-    toolsEnabled: boolean;
-    sendWithShiftEnter: boolean;
-    showTokenUsage: boolean;
-    commandsRequiringApproval: string[];
-    commandsAutoRenderMimeBundles: string[];
-    trustedMimeTypesForAutoRender: string[];
-    showCellDiff: boolean;
-    showFileDiff: boolean;
-    diffDisplayMode: 'split' | 'unified';
-    skillsPaths: string[];
-}
-export declare class AISettingsModel extends VDomModel {
+import { IAIConfig, IAISettingsModel, IMCPServerConfig, IProviderConfig } from '../tokens';
+export declare class AISettingsModel extends VDomModel implements IAISettingsModel {
     private _config;
     private _settingRegistry;
     private _settings;
     constructor(options: AISettingsModel.IOptions);
-    private initializeSettings;
-    private onSettingsChanged;
-    private loadFromSettings;
+    private _initializeSettings;
+    private _onSettingsChanged;
+    private _loadFromSettings;
     get config(): IAIConfig;
     get providers(): IProviderConfig[];
     getProvider(id: string): IProviderConfig | undefined;
@@ -72,8 +25,13 @@ export declare class AISettingsModel extends VDomModel {
     removeMCPServer(id: string): Promise<void>;
     updateMCPServer(id: string, updates: Partial<IMCPServerConfig>): Promise<void>;
     updateConfig(updates: Partial<IAIConfig>): Promise<void>;
+    /**
+     * Get the API key saved in the settings file for a given provider.
+     *
+     * @param id - the id of the provider.
+     */
     getApiKey(id: string): string;
-    private saveSetting;
+    private _saveSetting;
 }
 export declare namespace AISettingsModel {
     interface IOptions {

package/lib/models/settings-model.js

@@ -13,10 +13,12 @@ export class AISettingsModel extends VDomModel {
         toolsEnabled: true,
         sendWithShiftEnter: false,
         showTokenUsage: false,
+        showContextUsage: false,
         showCellDiff: true,
         showFileDiff: true,
         diffDisplayMode: 'split',
         skillsPaths: ['.agents/skills', '_agents/skills'],
+        chatBackupDirectory: '',
         commandsRequiringApproval: [
             'notebook:restart-run-all',
             'notebook:run-cell',
@@ -98,6 +100,15 @@ When asked to run code or perform computations, choose the most appropriate appr
 
 This means if the user asks you to "calculate the factorial of 100" or "check what library version is installed", run that directly with the jupyterlab-ai-commands kernel execution command rather than creating a new notebook file.
 
+## Notebook State and Cell Identity
+When working with an existing notebook, use the notebook's current structure and kernel state as the source of truth.
+- Before changing notebook content or structure, inspect the notebook and any target cells with the relevant notebook commands you have discovered.
+- If the user may have edited the notebook, or if a previous command could have changed it, refresh your view before continuing rather than relying on earlier results.
+- Treat variables from previously executed cells as part of the active kernel state. When the user asks you to work with existing data or variables, use them by name instead of recreating them unless the user asks you to redefine them or the kernel state is unavailable.
+- Be explicit about the kind of cell reference you are using. A visible execution count (for example In [6]), a notebook position, and an internal cell ID or UUID are different identifiers and may not match.
+- When the user identifies a cell by execution count, relative position, or content, verify the target cell from the current notebook contents before editing it or inserting cells relative to it.
+- For relative insertions, anchor the change to the confirmed target cell rather than to empty placeholder or trailing cells unless the user explicitly refers to those cells.
+
 ## Your Approach
 - **Context-aware**: You understand the user is working in a data science/research environment
 - **Practical**: You focus on actionable solutions that work in the user's current setup
@@ -141,7 +152,7 @@ Guidelines:
 
 ## Multi-Step Task Handling
 When users request complex tasks, you use the command system to accomplish them:
-- For file and notebook operations, use discover_commands with query 'jupyterlab-ai-commands' to find the curated set of AI commands (~17 commands)
+- For file and notebook operations, use discover_commands with query 'jupyterlab-ai-commands' to find the curated set of AI commands (~22 commands)
 - For other JupyterLab operations (terminal, launcher, UI), use specific keywords like 'terminal', 'launcher', etc.
 - IMPORTANT: Always use 'jupyterlab-ai-commands' as the query for file/notebook tasks - this returns a focused set instead of 100+ generic commands
 - For example, to create a notebook with cells:
@@ -181,14 +192,14 @@ Rules:
     constructor(options) {
         super();
         this._settingRegistry = options.settingRegistry;
-        this.initializeSettings();
+        this._initializeSettings();
     }
-    async initializeSettings() {
+    async _initializeSettings() {
         try {
             this._settings = await this._settingRegistry.load(PLUGIN_ID);
-            this.loadFromSettings();
+            this._loadFromSettings();
             // Listen for settings changes
-            this._settings.changed.connect(this.onSettingsChanged, this);
+            this._settings.changed.connect(this._onSettingsChanged, this);
             this.stateChanged.emit(void 0);
         }
         catch (error) {
@@ -196,11 +207,11 @@ Rules:
             this.stateChanged.emit(void 0);
         }
     }
-    onSettingsChanged() {
-        this.loadFromSettings();
+    _onSettingsChanged() {
+        this._loadFromSettings();
         this.stateChanged.emit(void 0);
     }
-    loadFromSettings() {
+    _loadFromSettings() {
         if (!this._settings) {
             return;
         }
@@ -248,13 +259,13 @@ Rules:
         // If this is the first provider, make it active
         if (this._config.providers.length === 1) {
             // Save both providers and defaultProvider
-            await this.saveSetting('providers', this._config.providers);
+            await this._saveSetting('providers', this._config.providers);
             this._config.defaultProvider = id;
-            await this.saveSetting('defaultProvider', this._config.defaultProvider);
+            await this._saveSetting('defaultProvider', this._config.defaultProvider);
         }
         else {
             // Only save providers
-            await this.saveSetting('providers', this._config.providers);
+            await this._saveSetting('providers', this._config.providers);
         }
         return id;
     }
@@ -264,16 +275,16 @@ Rules:
             return;
         }
         this._config.providers.splice(index, 1);
-        await this.saveSetting('providers', this._config.providers);
+        await this._saveSetting('providers', this._config.providers);
         // If this was the active provider, select a new one
         if (this._config.defaultProvider === id) {
             this._config.defaultProvider =
                 this._config.providers.length > 0 ? this._config.providers[0].id : '';
-            await this.saveSetting('defaultProvider', this._config.defaultProvider);
+            await this._saveSetting('defaultProvider', this._config.defaultProvider);
         }
         if (this._config.activeCompleterProvider === id) {
             this._config.activeCompleterProvider = undefined;
-            await this.saveSetting('activeCompleterProvider', this._config.activeCompleterProvider);
+            await this._saveSetting('activeCompleterProvider', this._config.activeCompleterProvider);
         }
     }
     async updateProvider(id, updates) {
@@ -287,17 +298,17 @@ Rules:
                 delete provider[key];
             }
         });
-        await this.saveSetting('providers', this._config.providers);
+        await this._saveSetting('providers', this._config.providers);
     }
     async setActiveProvider(id) {
         if (this.getProvider(id)) {
             this._config.defaultProvider = id;
-            await this.saveSetting('defaultProvider', this._config.defaultProvider);
+            await this._saveSetting('defaultProvider', this._config.defaultProvider);
         }
     }
     async setActiveCompleterProvider(id) {
         this._config.activeCompleterProvider = id;
-        await this.saveSetting('activeCompleterProvider', this._config.activeCompleterProvider);
+        await this._saveSetting('activeCompleterProvider', this._config.activeCompleterProvider);
     }
     get mcpServers() {
         return [...this._config.mcpServers];
@@ -314,7 +325,7 @@ Rules:
             enabled: serverConfig.enabled
         };
         this._config.mcpServers.push(newServer);
-        await this.saveSetting('mcpServers', this._config.mcpServers);
+        await this._saveSetting('mcpServers', this._config.mcpServers);
         return id;
     }
     async removeMCPServer(id) {
@@ -323,7 +334,7 @@ Rules:
             return;
         }
         this._config.mcpServers.splice(index, 1);
-        await this.saveSetting('mcpServers', this._config.mcpServers);
+        await this._saveSetting('mcpServers', this._config.mcpServers);
     }
     async updateMCPServer(id, updates) {
         const server = this.getMCPServer(id);
@@ -331,7 +342,7 @@ Rules:
             return;
         }
         Object.assign(server, updates);
-        await this.saveSetting('mcpServers', this._config.mcpServers);
+        await this._saveSetting('mcpServers', this._config.mcpServers);
     }
     async updateConfig(updates) {
         // Update config and save only changed settings
@@ -340,12 +351,17 @@ Rules:
             if (key in this._config &&
                 this._config[key] !== value) {
                 this._config[key] = value;
-                promises.push(this.saveSetting(key, value));
+                promises.push(this._saveSetting(key, value));
             }
         }
         // Wait for all settings to be saved
         await Promise.all(promises);
     }
+    /**
+     * Get the API key saved in the settings file for a given provider.
+     *
+     * @param id - the id of the provider.
+     */
     getApiKey(id) {
         // First check the active completer provider
         const activeCompleterProvider = this.getCompleterProvider();
@@ -359,7 +375,7 @@ Rules:
         }
         return '';
     }
-    async saveSetting(key, value) {
+    async _saveSetting(key, value) {
         try {
             if (this._settings) {
                 // Only save the specific setting that changed