@jupyterlite/ai 0.13.0 → 0.14.0

package/lib/agent.d.ts

@@ -317,6 +317,18 @@ export declare class AgentManager {
      * Build an instruction line describing MIME types supported by this session.
      */
     private _getSupportedMimeTypesInstruction;
+    /**
+     * Sanitizes history to ensure it's in a valid state in case of abort or error.
+     */
+    private _sanitizeHistory;
+    /**
+     * Extracts tool call IDs from a message
+     */
+    private _getToolCallIds;
+    /**
+     * Checks if a tool message contains results for all specified tool call IDs
+     */
+    private _matchesAllToolCalls;
     private _settingsModel;
     private _toolRegistry?;
     private _providerRegistry?;

package/lib/agent.js

@@ -33,6 +33,16 @@ export class AgentManagerFactory {
             secretsManager: this._secretsManager
         });
         this._agentManagers.push(agentManager);
+        // New chats can be created before MCP setup finishes.
+        // Reinitialize them with connected MCP tools once it does.
+        this._initQueue
+            .then(() => this.getMCPTools())
+            .then(mcpTools => {
+            if (Object.keys(mcpTools).length > 0) {
+                agentManager.initializeAgent(mcpTools);
+            }
+        })
+            .catch(error => console.warn('Failed to pass MCP tools to new agent:', error));
         return agentManager;
     }
     /**
@@ -406,6 +416,9 @@ export class AgentManager {
                     data: { error: error }
                 });
             }
+            // After an error (including AbortError), sanitize the history
+            // to remove any trailing assistant messages without tool results
+            this._sanitizeHistory();
         }
         finally {
             this._controller = null;
@@ -838,6 +851,81 @@ WEB RETRIEVAL POLICY:
         }
         return `Supported MIME types in this session: ${safeMimeTypes.join(', ')}`;
     }
+    /**
+     * Sanitizes history to ensure it's in a valid state in case of abort or error.
+     */
+    _sanitizeHistory() {
+        if (this._history.length === 0) {
+            return;
+        }
+        const newHistory = [];
+        for (let i = 0; i < this._history.length; i++) {
+            const msg = this._history[i];
+            if (msg.role === 'assistant') {
+                const toolCallIds = this._getToolCallIds(msg);
+                if (toolCallIds.length > 0) {
+                    // Find if there's a following tool message with results for these calls
+                    const nextMsg = this._history[i + 1];
+                    if (nextMsg &&
+                        nextMsg.role === 'tool' &&
+                        this._matchesAllToolCalls(nextMsg, toolCallIds)) {
+                        newHistory.push(msg);
+                    }
+                    else {
+                        // Message has unmatched tool calls drop it and everything after it
+                        break;
+                    }
+                }
+                else {
+                    newHistory.push(msg);
+                }
+            }
+            else if (msg.role === 'tool') {
+                // Tool messages are valid if they were preceded by a valid assistant message
+                newHistory.push(msg);
+            }
+            else {
+                newHistory.push(msg);
+            }
+        }
+        this._history = newHistory;
+    }
+    /**
+     * Extracts tool call IDs from a message
+     */
+    _getToolCallIds(message) {
+        const ids = [];
+        // Check content array for tool-call parts
+        if (Array.isArray(message.content)) {
+            for (const part of message.content) {
+                if (typeof part === 'object' &&
+                    part !== null &&
+                    'type' in part &&
+                    part.type === 'tool-call') {
+                    ids.push(part.toolCallId);
+                }
+            }
+        }
+        return ids;
+    }
+    /**
+     * Checks if a tool message contains results for all specified tool call IDs
+     */
+    _matchesAllToolCalls(message, callIds) {
+        if (message.role !== 'tool' || !Array.isArray(message.content)) {
+            return false;
+        }
+        const resultIds = new Set();
+        for (const part of message.content) {
+            if (typeof part === 'object' &&
+                part !== null &&
+                'type' in part &&
+                part.type === 'tool-result') {
+                resultIds.add(part.toolCallId);
+            }
+        }
+        return callIds.every(id => resultIds.has(id));
+    }
     // Private attributes
     _settingsModel;
     _toolRegistry;

package/lib/index.js

@@ -33,6 +33,45 @@ import { createDiscoverSkillsTool, createLoadSkillTool } from './tools/skills';
 import { createBrowserFetchTool } from './tools/web';
 import { AISettingsWidget } from './widgets/ai-settings';
 import { MainAreaChat } from './widgets/main-area-chat';
+var Private;
+(function (Private) {
+    let aiSecretsToken = null;
+    function setAISecretsToken(token) {
+        aiSecretsToken = token;
+    }
+    Private.setAISecretsToken = setAISecretsToken;
+    function createAISecretsAccess(secretsManager) {
+        return {
+            get isAvailable() {
+                return !!(aiSecretsToken && secretsManager);
+            },
+            async get(id) {
+                if (!aiSecretsToken || !secretsManager) {
+                    return;
+                }
+                const secret = await secretsManager.get(aiSecretsToken, SECRETS_NAMESPACE, id);
+                return secret?.value;
+            },
+            async set(id, value) {
+                if (!aiSecretsToken || !secretsManager) {
+                    return;
+                }
+                await secretsManager.set(aiSecretsToken, SECRETS_NAMESPACE, id, {
+                    namespace: SECRETS_NAMESPACE,
+                    id,
+                    value
+                });
+            },
+            async attach(id, input, callback) {
+                if (!aiSecretsToken || !secretsManager) {
+                    return;
+                }
+                await secretsManager.attach(aiSecretsToken, SECRETS_NAMESPACE, id, input, callback);
+            }
+        };
+    }
+    Private.createAISecretsAccess = createAISecretsAccess;
+})(Private || (Private = {}));
 /**
  * Provider registry plugin
  */
@@ -204,6 +243,11 @@ const plugin = {
         attachmentOpenerRegistry.set('notebook', attachment => {
             app.commands.execute('docmanager:open', { path: attachment.value });
         });
+        const openSettings = () => {
+            if (app.commands.hasCommand(CommandIds.openSettings)) {
+                void app.commands.execute(CommandIds.openSettings);
+            }
+        };
         // Create ActiveCellManager if notebook tracker is available, and add it to the
         // model registry.
         let activeCellManager;
@@ -229,7 +273,7 @@ const plugin = {
                     provider = settingsModel.getDefaultProvider()?.id;
                     if (!provider) {
                         showErrorMessage('Error creating chat', 'Please set up a provider');
-                        app.commands.execute('@jupyterlite/ai:open-settings');
+                        openSettings();
                         return {};
                     }
                 }
@@ -262,13 +306,30 @@ const plugin = {
         chatPanel.title.icon = chatIcon;
         chatPanel.title.caption = trans.__('Chat with AI assistant');
         chatPanel.toolbar.addItem('spacer', Toolbar.createSpacerItem());
-        chatPanel.toolbar.addItem('settings', new ToolbarButton({
-            icon: settingsIcon,
-            onClick: () => {
-                app.commands.execute('@jupyterlite/ai:open-settings');
-            },
-            tooltip: trans.__('Open AI Settings')
-        }));
+        const addSettingsButton = () => {
+            chatPanel.toolbar.addItem('settings', new ToolbarButton({
+                icon: settingsIcon,
+                onClick: openSettings,
+                tooltip: trans.__('Open AI Settings')
+            }));
+        };
+        if (app.commands.hasCommand(CommandIds.openSettings)) {
+            addSettingsButton();
+        }
+        else {
+            const disconnectSettingsButtonListener = () => {
+                app.commands.commandChanged.disconnect(onCommandChanged);
+                chatPanel.disposed.disconnect(disconnectSettingsButtonListener);
+            };
+            const onCommandChanged = (_, args) => {
+                if (args.id === CommandIds.openSettings && args.type === 'added') {
+                    disconnectSettingsButtonListener();
+                    addSettingsButton();
+                }
+            };
+            app.commands.commandChanged.connect(onCommandChanged);
+            chatPanel.disposed.connect(disconnectSettingsButtonListener);
+        }
         let tokenUsageWidget = null;
         chatPanel.chatOpened.connect((_, widget) => {
             const model = widget.model;
@@ -562,59 +623,78 @@ function registerCommands(app, rmRegistry, chatPanel, attachmentOpenerRegistry,
     }
 }
 /**
- * A plugin to provide the agent manager factory, the completion provider and
- * the settings model.
- * All these objects require the secrets manager token with the same namespace.
+ * A plugin to provide the agent manager factory and completion provider.
+ * These objects require the secrets manager token with the same namespace.
  */
-const agentManagerFactory = SecretsManager.sign(SECRETS_NAMESPACE, token => ({
-    id: SECRETS_NAMESPACE,
-    description: 'Provide the AI agent manager',
+const agentManagerFactory = SecretsManager.sign(SECRETS_NAMESPACE, token => {
+    Private.setAISecretsToken(token);
+    return {
+        id: SECRETS_NAMESPACE,
+        description: 'Provide the AI agent manager',
+        autoStart: true,
+        provides: IAgentManagerFactory,
+        requires: [IAISettingsModel, IProviderRegistry],
+        optional: [ISkillRegistry, ICompletionProviderManager, ISecretsManager],
+        activate: (app, settingsModel, providerRegistry, skillRegistry, completionManager, secretsManager) => {
+            const agentManagerFactory = new AgentManagerFactory({
+                settingsModel,
+                skillRegistry,
+                secretsManager,
+                token
+            });
+            // Build the completion provider
+            if (completionManager) {
+                const completionProvider = new AICompletionProvider({
+                    settingsModel,
+                    providerRegistry,
+                    secretsManager,
+                    token
+                });
+                completionManager.registerInlineProvider(completionProvider);
+            }
+            else {
+                console.info('Completion provider manager not available, skipping AI completion setup');
+            }
+            return agentManagerFactory;
+        }
+    };
+});
+/**
+ * AI settings panel plugin.
+ */
+const settingsPanelPlugin = {
+    id: '@jupyterlite/ai:settings-panel',
+    description: 'Provide the AI settings panel',
     autoStart: true,
-    provides: IAgentManagerFactory,
-    requires: [IAISettingsModel, IProviderRegistry],
+    requires: [IAISettingsModel, IAgentManagerFactory, IProviderRegistry],
     optional: [
-        ISkillRegistry,
         ICommandPalette,
-        ICompletionProviderManager,
         ILayoutRestorer,
         ISecretsManager,
         IThemeManager,
         ITranslator
     ],
-    activate: (app, settingsModel, providerRegistry, skillRegistry, palette, completionManager, restorer, secretsManager, themeManager, translator) => {
+    activate: (app, settingsModel, agentManagerFactory, providerRegistry, palette, restorer, secretsManager, themeManager, translator) => {
         const trans = (translator ?? nullTranslator).load('jupyterlite_ai');
-        const agentManagerFactory = new AgentManagerFactory({
-            settingsModel,
-            skillRegistry,
-            secretsManager,
-            token
-        });
-        // Build the settings panel
+        const secretsAccess = Private.createAISecretsAccess(secretsManager);
         const settingsWidget = new AISettingsWidget({
             settingsModel,
             agentManagerFactory,
             themeManager,
             providerRegistry,
-            secretsManager,
-            token,
+            secretsAccess,
             trans
         });
-        settingsWidget.id = 'jupyterlite-ai-settings';
         settingsWidget.title.icon = settingsIcon;
         settingsWidget.title.iconClass = 'jp-ai-settings-icon';
-        // Build the completion provider
-        if (completionManager) {
-            const completionProvider = new AICompletionProvider({
-                settingsModel,
-                providerRegistry,
-                secretsManager,
-                token
-            });
-            completionManager.registerInlineProvider(completionProvider);
-        }
-        else {
-            console.info('Completion provider manager not available, skipping AI completion setup');
-        }
+        const open = () => {
+            let widget = Array.from(app.shell.widgets('main')).find(w => w.id === 'jupyterlite-ai-settings');
+            if (!widget) {
+                widget = settingsWidget;
+                app.shell.add(widget, 'main');
+            }
+            app.shell.activateById(widget.id);
+        };
         if (restorer) {
             restorer.add(settingsWidget, settingsWidget.id);
         }
@@ -624,31 +704,20 @@ const agentManagerFactory = SecretsManager.sign(SECRETS_NAMESPACE, token => ({
             icon: settingsIcon,
             iconClass: 'jp-ai-settings-icon',
             execute: () => {
-                // Check if the widget already exists in shell
-                let widget = Array.from(app.shell.widgets('main')).find(w => w.id === 'jupyterlite-ai-settings');
-                if (!widget && settingsWidget) {
-                    // Use the pre-created widget
-                    widget = settingsWidget;
-                    app.shell.add(widget, 'main');
-                }
-                if (widget) {
-                    app.shell.activateById(widget.id);
-                }
+                open();
             },
             describedBy: {
                 args: {}
             }
         });
-        // Add to command palette if available
         if (palette) {
             palette.addItem({
                 command: CommandIds.openSettings,
                 category: trans.__('AI Assistant')
             });
         }
-        return agentManagerFactory;
     }
-}));
+};
 /**
  * Built-in completion providers plugin
  */
@@ -894,6 +963,7 @@ export default [
     plugin,
     toolRegistry,
     agentManagerFactory,
+    settingsPanelPlugin,
     inputToolbarFactory,
     completionStatus,
     skillsPlugin

package/lib/providers/built-in-providers.js

@@ -12,6 +12,7 @@ export const anthropicProvider = {
     apiKeyRequirement: 'required',
     defaultModels: [
         'claude-opus-4-6',
+        'claude-sonnet-4-6',
         'claude-opus-4-5',
         'claude-opus-4-5-20251101',
         'claude-sonnet-4-5',
@@ -24,10 +25,6 @@ export const anthropicProvider = {
         'claude-opus-4-20250514',
         'claude-sonnet-4-0',
         'claude-sonnet-4-20250514',
-        'claude-3-7-sonnet-latest',
-        'claude-3-7-sonnet-20250219',
-        'claude-3-5-haiku-latest',
-        'claude-3-5-haiku-20241022',
         'claude-3-haiku-20240307'
     ],
     supportsBaseURL: true,
@@ -60,6 +57,9 @@ export const googleProvider = {
     name: 'Google Generative AI',
     apiKeyRequirement: 'required',
     defaultModels: [
+        'gemini-3.1-pro-preview',
+        'gemini-3.1-pro-preview-customtools',
+        'gemini-3.1-flash-image-preview',
         'gemini-3-pro-preview',
         'gemini-3-pro-image-preview',
         'gemini-3-flash-preview',
@@ -68,33 +68,21 @@ export const googleProvider = {
         'gemini-2.5-flash-image',
         'gemini-2.5-flash-lite',
         'gemini-2.5-flash-lite-preview-09-2025',
-        'gemini-2.5-flash-preview-04-17',
-        'gemini-2.5-flash-preview-09-2025',
-        'gemini-2.5-pro-exp-03-25',
+        'gemini-2.5-computer-use-preview-10-2025',
         'gemini-2.0-flash',
         'gemini-2.0-flash-001',
-        'gemini-2.0-flash-live-001',
         'gemini-2.0-flash-lite',
-        'gemini-2.0-pro-exp-02-05',
-        'gemini-2.0-flash-thinking-exp-01-21',
-        'gemini-2.0-flash-exp',
-        'gemini-1.5-flash',
-        'gemini-1.5-flash-latest',
-        'gemini-1.5-flash-001',
-        'gemini-1.5-flash-002',
-        'gemini-1.5-flash-8b',
-        'gemini-1.5-flash-8b-latest',
-        'gemini-1.5-flash-8b-001',
-        'gemini-1.5-pro',
-        'gemini-1.5-pro-latest',
-        'gemini-1.5-pro-001',
-        'gemini-1.5-pro-002',
+        'gemini-2.0-flash-lite-001',
         'gemini-pro-latest',
         'gemini-flash-latest',
         'gemini-flash-lite-latest',
-        'gemini-exp-1206',
+        'deep-research-pro-preview-12-2025',
+        'gemma-3-27b-it',
         'gemma-3-12b-it',
-        'gemma-3-27b-it'
+        'gemma-3-4b-it',
+        'gemma-3-1b-it',
+        'gemma-3n-e4b-it',
+        'gemma-3n-e2b-it'
     ],
     supportsBaseURL: true,
     factory: (options) => {
@@ -157,10 +145,13 @@ export const openaiProvider = {
     apiKeyRequirement: 'required',
     defaultModels: [
         'gpt-5.2',
+        'gpt-5.2-2025-12-11',
         'gpt-5.2-chat-latest',
         'gpt-5.2-pro',
+        'gpt-5.2-pro-2025-12-11',
         'gpt-5.2-codex',
         'gpt-5.1',
+        'gpt-5.1-2025-11-13',
         'gpt-5.1-chat-latest',
         'gpt-5',
         'gpt-5-2025-08-07',
@@ -177,8 +168,6 @@ export const openaiProvider = {
         'o3-mini-2025-01-31',
         'o1',
         'o1-2024-12-17',
-        'gpt-4.5-preview',
-        'gpt-4.5-preview-2025-02-27',
         'gpt-4.1',
         'gpt-4.1-2025-04-14',
         'gpt-4.1-mini',
@@ -189,16 +178,21 @@ export const openaiProvider = {
         'gpt-4o-2024-05-13',
         'gpt-4o-2024-08-06',
         'gpt-4o-2024-11-20',
+        'gpt-4o-audio-preview',
+        'gpt-4o-audio-preview-2024-12-17',
+        'gpt-4o-audio-preview-2025-06-03',
         'gpt-4o-mini',
         'gpt-4o-mini-2024-07-18',
-        'chatgpt-4o-latest',
-        'gpt-4-turbo',
-        'gpt-4-turbo-2024-04-09',
-        'gpt-4',
-        'gpt-4-0613',
+        'gpt-4o-mini-audio-preview',
+        'gpt-4o-mini-audio-preview-2024-12-17',
+        'gpt-4o-search-preview',
+        'gpt-4o-search-preview-2025-03-11',
+        'gpt-4o-mini-search-preview',
+        'gpt-4o-mini-search-preview-2025-03-11',
         'gpt-3.5-turbo',
         'gpt-3.5-turbo-0125',
-        'gpt-3.5-turbo-1106'
+        'gpt-3.5-turbo-1106',
+        'gpt-3.5-turbo-16k'
     ],
     supportsBaseURL: true,
     supportsHeaders: true,

package/lib/tokens.d.ts

@@ -253,6 +253,27 @@ export interface IProviderRegistry {
  * Token for the AI settings model.
  */
 export declare const IAISettingsModel: Token<AISettingsModel>;
+/**
+ * Internal interface for AI provider secret access within the shared namespace.
+ */
+export interface IAISecretsAccess {
+    /**
+     * Whether secrets access is currently available.
+     */
+    readonly isAvailable: boolean;
+    /**
+     * Get a secret value by ID.
+     */
+    get(id: string): Promise<string | undefined>;
+    /**
+     * Set a secret value by ID.
+     */
+    set(id: string, value: string): Promise<void>;
+    /**
+     * Attach an input field to a secret ID.
+     */
+    attach(id: string, input: HTMLInputElement, callback?: (value: string) => void): Promise<void>;
+}
 /**
  * Token for the agent manager.
  */

package/lib/tools/commands.js

@@ -1,6 +1,56 @@
 import { Widget } from '@lumino/widgets';
 import { tool } from 'ai';
 import { z } from 'zod';
+/**
+ * Search commands using case-insensitive term matching across command metadata.
+ *
+ * Multi-word queries are split into individual terms, and every term must be
+ * contained in at least one searchable field. Results are ranked by stronger
+ * field matches while keeping a stable fallback order.
+ */
+function searchCommands(commands, query) {
+    const normalizedQuery = query.trim().toLowerCase();
+    if (!normalizedQuery) {
+        return commands;
+    }
+    const terms = normalizedQuery.split(/\s+/).filter(Boolean);
+    return commands
+        .map((command, index) => {
+        const fields = [
+            { value: command.label, weight: 4 },
+            { value: command.caption, weight: 3 },
+            { value: command.id, weight: 2 },
+            { value: command.description, weight: 1 }
+        ];
+        const normalizedFields = fields.map(field => ({
+            normalizedValue: field.value?.toLowerCase() ?? '',
+            weight: field.weight
+        }));
+        const matchesAllTerms = terms.every(term => normalizedFields.some(field => field.normalizedValue.includes(term)));
+        if (!matchesAllTerms) {
+            return null;
+        }
+        const score = normalizedFields.reduce((total, field) => {
+            if (!field.normalizedValue) {
+                return total;
+            }
+            let fieldScore = 0;
+            if (field.normalizedValue.includes(normalizedQuery)) {
+                fieldScore += field.weight * 4;
+            }
+            else {
+                fieldScore +=
+                    terms.filter(term => field.normalizedValue.includes(term)).length *
+                        field.weight;
+            }
+            return total + fieldScore;
+        }, 0);
+        return { command, index, score };
+    })
+        .filter((result) => result !== null)
+        .sort((a, b) => b.score - a.score || a.index - b.index)
+        .map(result => result.command);
+}
 /**
  * Create a tool to discover all available commands and their metadata
  */
@@ -13,41 +63,29 @@ export function createDiscoverCommandsTool(commands) {
                 .string()
                 .optional()
                 .nullable()
-                .describe("Optional search query to filter commands. It doesn't need to be provided to list all commands")
+                .describe('Optional search query to filter commands. Supports multi-word queries (whitespace-separated) by requiring each word to be contained in the command id, label, caption, or description. Leave empty to list all commands.')
         }),
         execute: async (input) => {
             const { query } = input;
-            const commandList = [];
-            // Get all command IDs
+            // Build the full command list first.
             const commandIds = commands.listCommands();
+            const allCommands = [];
             for (const id of commandIds) {
-                // Get command metadata using various CommandRegistry methods
                 const description = await commands.describedBy(id);
                 const label = commands.label(id);
                 const caption = commands.caption(id);
                 const usage = commands.usage(id);
-                const command = {
+                allCommands.push({
                     id,
                     label: label || undefined,
                     caption: caption || undefined,
                     description: usage || undefined,
                     args: description?.args || undefined
-                };
-                // Filter by query if provided
-                if (query) {
-                    const searchTerm = query.toLowerCase();
-                    const matchesQuery = id.toLowerCase().includes(searchTerm) ||
-                        label?.toLowerCase().includes(searchTerm) ||
-                        caption?.toLowerCase().includes(searchTerm) ||
-                        usage?.toLowerCase().includes(searchTerm);
-                    if (matchesQuery) {
-                        commandList.push(command);
-                    }
-                }
-                else {
-                    commandList.push(command);
-                }
+                });
             }
+            const commandList = query
+                ? searchCommands(allCommands, query)
+                : allCommands;
             return {
                 success: true,
                 commandCount: commandList.length,

package/lib/widgets/ai-settings.d.ts

@@ -1,11 +1,10 @@
 import { IThemeManager } from '@jupyterlab/apputils';
 import { ReactWidget } from '@jupyterlab/ui-components';
 import type { TranslationBundle } from '@jupyterlab/translation';
-import { ISecretsManager } from 'jupyter-secrets-manager';
 import React from 'react';
 import { AgentManagerFactory } from '../agent';
 import { AISettingsModel } from '../models/settings-model';
-import { type IProviderRegistry } from '../tokens';
+import { type IAISecretsAccess, type IProviderRegistry } from '../tokens';
 /**
  * A JupyterLab widget for AI settings configuration
  */
@@ -24,7 +23,7 @@ export declare class AISettingsWidget extends ReactWidget {
     private _agentManagerFactory?;
     private _themeManager?;
     private _providerRegistry;
-    private _secretsManager?;
+    private _secretsAccess?;
     private _trans;
 }
 /**
@@ -40,13 +39,9 @@ export declare namespace AISettingsWidget {
         themeManager?: IThemeManager;
         providerRegistry: IProviderRegistry;
         /**
-         * The secrets manager.
+         * Access to provider secrets in the shared namespace.
          */
-        secretsManager?: ISecretsManager;
-        /**
-         * The token used to request the secrets manager.
-         */
-        token: symbol | null;
+        secretsAccess: IAISecretsAccess;
         /**
          * The application language translation bundle.
          */