@jupyterlite/ai 0.16.0 → 0.18.0

package/lib/components/clear-button.d.ts

@@ -7,7 +7,7 @@ export interface IClearButtonProps extends InputToolbarRegistry.IToolbarItemProp
     /**
      * The function to clear messages.
      */
-    clearMessages: () => void;
+    clearMessages: () => Promise<void>;
     /**
      * The application language translator.
      */

package/lib/components/clear-button.js

@@ -21,7 +21,7 @@ export function clearItem(translator) {
     return {
         element: (props) => {
             const { model } = props;
-            const clearMessages = () => model.chatContext.clearMessages();
+            const clearMessages = async () => await model.chatContext.clearMessages();
             const clearProps = {
                 ...props,
                 clearMessages,

package/lib/components/save-button.d.ts

@@ -1,7 +1,7 @@
 import { ReactWidget } from '@jupyterlab/ui-components';
 import type { TranslationBundle } from '@jupyterlab/translation';
 import React from 'react';
-import { AIChatModel } from '../chat-model';
+import { IAIChatModel } from '../tokens';
 /**
  * Properties for the SaveButton component.
  */
@@ -9,7 +9,7 @@ export interface ISaveButtonProps {
     /**
      * The chat model, used to listen for message changes for auto-save.
      */
-    model: AIChatModel;
+    model: IAIChatModel;
     /**
      * The application language translator.
      */

package/lib/index.js

@@ -11,7 +11,7 @@ import { IStatusBar } from '@jupyterlab/statusbar';
 import { PathExt } from '@jupyterlab/coreutils';
 import { ITranslator, nullTranslator } from '@jupyterlab/translation';
 import { fileUploadIcon, saveIcon, settingsIcon, Toolbar, ToolbarButton } from '@jupyterlab/ui-components';
-import { PromiseDelegate, UUID } from '@lumino/coreutils';
+import { UUID } from '@lumino/coreutils';
 import { DisposableSet } from '@lumino/disposable';
 import { IComponentsRendererFactory } from 'jupyter-chat-components';
 import { ISecretsManager, SecretsManager } from 'jupyter-secrets-manager';
@@ -213,6 +213,22 @@ const chatModelHandler = {
         });
     }
 };
+/**
+ * The active cell manager plugin, to allow copying code from chat to notebook.
+ */
+const activeCellManager = {
+    id: '@jupyterlite/ai:activeCellManager',
+    description: 'Add the active cell manager to the model handler',
+    autoStart: true,
+    requires: [IChatModelHandler, INotebookTracker],
+    activate: (app, modelHandler, notebookTracker) => {
+        const activeCellManager = new ActiveCellManager({
+            tracker: notebookTracker,
+            shell: app.shell
+        });
+        modelHandler.activeCellManager = activeCellManager;
+    }
+};
 /**
  * Initialization data for the extension.
  */
@@ -232,13 +248,12 @@ const plugin = {
         IThemeManager,
         ILayoutRestorer,
         ILabShell,
-        INotebookTracker,
         ITranslator,
         IComponentsRendererFactory,
         ICommandPalette,
         IDocumentManager
     ],
-    activate: (app, rmRegistry, inputToolbarFactory, modelHandler, settingsModel, chatCommandRegistry, themeManager, restorer, labShell, notebookTracker, translator, chatComponentsFactory, palette, documentManager) => {
+    activate: (app, rmRegistry, inputToolbarFactory, modelHandler, settingsModel, chatCommandRegistry, themeManager, restorer, labShell, translator, chatComponentsFactory, palette, documentManager) => {
         const trans = (translator ?? nullTranslator).load('jupyterlite_ai');
         // Create attachment opener registry to handle file attachments
         const attachmentOpenerRegistry = new AttachmentOpenerRegistry();
@@ -253,16 +268,6 @@ const plugin = {
                 void app.commands.execute(CommandIds.openSettings);
             }
         };
-        // Create ActiveCellManager if notebook tracker is available, and add it to the
-        // model registry.
-        let activeCellManager;
-        if (notebookTracker) {
-            activeCellManager = new ActiveCellManager({
-                tracker: notebookTracker,
-                shell: app.shell
-            });
-        }
-        modelHandler.activeCellManager = activeCellManager;
         // Creating the tracker for the chat widgets
         const namespace = 'ai-chat';
         const tracker = new WidgetTracker({ namespace });
@@ -346,6 +351,16 @@ const plugin = {
             function saveTracker() {
                 tracker.save(widget);
             }
+            function updateToolbarTitleOverlay() {
+                const titleNode = chatPanel.current?.toolbar.node
+                    .getElementsByClassName('jp-chat-sidepanel-widget-title')
+                    .item(0);
+                if (titleNode) {
+                    titleNode.setAttribute('title', model.title ?? model.name);
+                }
+            }
+            model.titleChanged.connect(updateToolbarTitleOverlay);
+            updateToolbarTitleOverlay();
             // Update the tracker if the model name changed.
             model.nameChanged.connect(saveTracker);
             // Update the tracker if the active provider changed.
@@ -371,12 +386,10 @@ const plugin = {
                 // Check if AI is currently writing (streaming)
                 const aiWriting = writers.some(writer => writer.user.username === 'ai-assistant');
                 if (aiWriting) {
-                    widget.inputToolbarRegistry?.hide('send');
                     widget.inputToolbarRegistry?.show('stop');
                 }
                 else {
                     widget.inputToolbarRegistry?.hide('stop');
-                    widget.inputToolbarRegistry?.show('send');
                 }
             }
             model.writersChanged?.connect(writersChanged);
@@ -386,6 +399,7 @@ const plugin = {
                 chatPanel: widget
             });
             widget.disposed.connect(() => {
+                model.titleChanged.disconnect(updateToolbarTitleOverlay);
                 model.nameChanged.disconnect(saveTracker);
                 model.agentManager.activeProviderChanged.disconnect(saveTracker);
                 model.writersChanged?.disconnect(writersChanged);
@@ -423,19 +437,29 @@ const plugin = {
         });
         registerCommands(app, rmRegistry, chatPanel, attachmentOpenerRegistry, inputToolbarFactory, settingsModel, chatCommandRegistry, tracker, modelHandler, trans, themeManager, labShell, palette, documentManager);
         /**
-         * The callback to approve or reject a tool.
+         * The callback for grouped tool calls permission decisions.
          */
-        function toolCallApproval(targetId, approvalId, isApproved) {
-            const model = tracker.find(chat => chat.model.name === targetId)?.model;
+        function toolCallPermissionDecision(sessionId, toolCallId, optionId) {
+            const model = tracker.find(chat => chat.model.name === sessionId)
+                ?.model;
             if (!model) {
                 return;
             }
+            const isApproved = optionId === 'approve';
             isApproved
-                ? model.agentManager.approveToolCall(approvalId)
-                : model.agentManager.rejectToolCall(approvalId);
+                ? model.agentManager.approveToolCall(toolCallId)
+                : model.agentManager.rejectToolCall(toolCallId);
         }
         if (chatComponentsFactory) {
-            chatComponentsFactory.toolCallApproval = toolCallApproval;
+            chatComponentsFactory.toolCallPermissionDecision =
+                toolCallPermissionDecision;
+            chatComponentsFactory.removeQueuedMessage = (targetId, messageId) => {
+                const model = tracker.find(chat => chat.model.name === targetId)?.model;
+                if (!model) {
+                    return;
+                }
+                model.removeQueuedMessage(messageId);
+            };
         }
         return tracker;
     }
@@ -486,11 +510,12 @@ function registerCommands(app, rmRegistry, chatPanel, attachmentOpenerRegistry,
             }
         });
         const openInMain = (model) => {
+            const inputToolbarRegistry = inputToolbarFactory.create();
             const content = new ChatWidget({
                 model,
                 rmRegistry,
                 themeManager: themeManager ?? null,
-                inputToolbarRegistry: inputToolbarFactory.create(),
+                inputToolbarRegistry,
                 attachmentOpenerRegistry,
                 chatCommandRegistry
             });
@@ -514,6 +539,49 @@ function registerCommands(app, rmRegistry, chatPanel, attachmentOpenerRegistry,
                 model.nameChanged.disconnect(saveTracker);
                 model.agentManager.activeProviderChanged.disconnect(saveTracker);
             });
+            return widget;
+        };
+        const focusOnChat = (area, widget) => {
+            if (area === 'main' && widget) {
+                app.shell.activateById(widget.id);
+            }
+            else {
+                app.shell.activateById(chatPanel.id);
+            }
+        };
+        const applyInputArgs = (model, args) => {
+            const input = typeof args.input === 'string' ? args.input : undefined;
+            const autoSend = args.autoSend === true;
+            const shouldFocus = args.focus !== false;
+            if (input !== undefined) {
+                model.input.value = input;
+            }
+            if (autoSend && input !== undefined) {
+                model.input.send(model.input.value);
+            }
+            if (shouldFocus) {
+                model.input.focus();
+            }
+        };
+        const findChatWidget = (name, provider) => {
+            if (!name && !provider) {
+                return;
+            }
+            return tracker.find(widget => {
+                const model = widget.model;
+                return ((!name || widget.model.name === name) &&
+                    (!provider || model.agentManager.activeProvider === provider));
+            });
+        };
+        const disposeSideChatModel = (model) => {
+            const loadedName = chatPanel
+                .getLoadedModelNames()
+                .find(name => chatPanel.getLoadedModel(name) === model);
+            if (!loadedName) {
+                return false;
+            }
+            chatPanel.disposeLoadedModel(loadedName);
+            return true;
         };
         commands.addCommand(CommandIds.openChat, {
             label: trans.__('Open a chat'),
@@ -543,12 +611,18 @@ function registerCommands(app, rmRegistry, chatPanel, attachmentOpenerRegistry,
                 if (!model) {
                     return false;
                 }
+                const shouldFocus = args.focus === true;
+                let widget;
                 if (area === 'main') {
-                    openInMain(model);
+                    widget = openInMain(model);
                 }
                 else {
-                    chatPanel.open({ model });
+                    widget = chatPanel.open({ model });
+                }
+                if (shouldFocus) {
+                    focusOnChat(area, widget);
                 }
+                applyInputArgs(model, { ...args, focus: shouldFocus });
                 return true;
             },
             describedBy: {
@@ -567,6 +641,116 @@ function registerCommands(app, rmRegistry, chatPanel, attachmentOpenerRegistry,
                         provider: {
                             type: 'string',
                             description: trans.__('The provider/model to use with this chat')
+                        },
+                        input: {
+                            type: 'string',
+                            description: trans.__('The input text to prefill in the chat')
+                        },
+                        focus: {
+                            type: 'boolean',
+                            description: trans.__('Whether to focus the chat input after opening it')
+                        },
+                        autoSend: {
+                            type: 'boolean',
+                            description: trans.__('Whether to auto-send the provided input after opening the chat')
+                        }
+                    }
+                }
+            }
+        });
+        commands.addCommand(CommandIds.openOrRevealChat, {
+            label: trans.__('Open or reveal the chat panel'),
+            execute: async (args) => {
+                const area = args.area === 'main' ? 'main' : 'side';
+                const provider = args.provider ?? undefined;
+                const name = args.name ?? undefined;
+                const shouldFocus = args.focus === true;
+                let existingWidget = findChatWidget(name, provider);
+                if (!existingWidget && !name) {
+                    const providerConfig = provider
+                        ? settingsModel.getProvider(provider)
+                        : settingsModel.getDefaultProvider();
+                    existingWidget = findChatWidget(undefined, providerConfig?.id);
+                }
+                // If the side chat model is loaded but not currently displayed, reveal it first.
+                if (!existingWidget && name) {
+                    const loadedModel = chatPanel.getLoadedModel(name);
+                    if (loadedModel) {
+                        existingWidget = chatPanel.open({ model: loadedModel });
+                    }
+                }
+                if (!existingWidget) {
+                    return commands.execute(CommandIds.openChat, {
+                        ...args,
+                        focus: shouldFocus
+                    });
+                }
+                const currentArea = existingWidget instanceof MainAreaChat ? 'main' : 'side';
+                if (currentArea !== area) {
+                    const targetName = existingWidget.model.name;
+                    const moved = (await commands.execute(CommandIds.moveChat, {
+                        name: targetName,
+                        area
+                    }));
+                    if (!moved) {
+                        return false;
+                    }
+                    const movedWidget = findChatWidget(targetName);
+                    if (!movedWidget) {
+                        return false;
+                    }
+                    if (area === 'side') {
+                        chatPanel.open({ model: movedWidget.model });
+                    }
+                    if (shouldFocus) {
+                        focusOnChat(area, movedWidget);
+                    }
+                    applyInputArgs(movedWidget.model, {
+                        ...args,
+                        focus: shouldFocus
+                    });
+                    return true;
+                }
+                if (area === 'side') {
+                    chatPanel.open({ model: existingWidget.model });
+                }
+                if (shouldFocus) {
+                    focusOnChat(area, existingWidget);
+                }
+                applyInputArgs(existingWidget.model, {
+                    ...args,
+                    focus: shouldFocus
+                });
+                return true;
+            },
+            describedBy: {
+                args: {
+                    type: 'object',
+                    properties: {
+                        area: {
+                            type: 'string',
+                            enum: ['main', 'side'],
+                            description: trans.__('The name of the area to open or reveal the chat in')
+                        },
+                        name: {
+                            type: 'string',
+                            description: trans.__('The name of the chat')
+                        },
+                        provider: {
+                            type: 'string',
+                            description: trans.__('The provider/model to use with this chat')
+                        },
+                        input: {
+                            type: 'string',
+                            description: trans.__('The input text to prefill in the chat')
+                        },
+                        focus: {
+                            type: 'boolean',
+                            description: trans.__('Whether to focus the chat input after opening it')
+                        },
+                        autoSend: {
+                            type: 'boolean',
+                            description: trans.__('Whether to auto-send the provided input after opening the chat')
                         }
                     }
                 }
@@ -596,45 +780,25 @@ function registerCommands(app, rmRegistry, chatPanel, attachmentOpenerRegistry,
                     console.error('Error while moving the chat to main area: there is no reference model');
                     return false;
                 }
-                // Listen for the widget updated in tracker, to ensure the previous model name
-                // has been updated. This is required to remove the widget from the restorer
-                // when the previous widget is disposed.
-                const trackerUpdated = new PromiseDelegate();
-                const widgetUpdated = (_, widget) => {
-                    if (widget.model === previousModel) {
-                        trackerUpdated.resolve(true);
-                    }
-                };
-                tracker.widgetUpdated.connect(widgetUpdated);
-                // Rename temporary the previous model to be able to reuse this name for the new
-                // 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({
-                    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([
-                    trackerUpdated.promise,
-                    new Promise(r => setTimeout(() => {
-                        r(false);
-                    }, 2000))
-                ]);
-                tracker.widgetUpdated.disconnect(widgetUpdated);
-                if (!status) {
-                    return false;
-                }
                 if (area === 'main') {
-                    openInMain(model);
+                    // Temporarily bypass model disposal to transport model to main view
+                    // to keep the conversation when switching views
+                    // TODO: Remove this code when jupyter-chat PR #423 is merged and released
+                    const originalDispose = previousModel.dispose.bind(previousModel);
+                    previousModel.dispose = () => { };
+                    if (previousWidget instanceof ChatWidget) {
+                        if (!disposeSideChatModel(previousModel)) {
+                            previousWidget.dispose();
+                        }
+                    }
+                    // Restore model disposal and transport to main view
+                    previousModel.dispose = originalDispose;
+                    openInMain(previousModel);
                 }
                 else {
+                    // MainAreaChat disposal does not dispose the model internally, so this is safe.
                     previousWidget?.dispose();
-                    previousModel.dispose();
-                    chatPanel.open({ model });
+                    chatPanel.open({ model: previousModel });
                 }
                 return true;
             },
@@ -1118,6 +1282,7 @@ export default [
     skillRegistryPlugin,
     skillsCommandPlugin,
     chatModelHandler,
+    activeCellManager,
     plugin,
     toolRegistry,
     agentManagerFactory,

package/lib/models/settings-model.js

@@ -19,6 +19,7 @@ export class AISettingsModel extends VDomModel {
         diffDisplayMode: 'split',
         skillsPaths: ['.agents/skills', '_agents/skills'],
         chatBackupDirectory: '',
+        autoTitle: false,
         commandsRequiringApproval: [
             'notebook:restart-run-all',
             'notebook:run-cell',

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

@@ -3,7 +3,7 @@ import { createGoogleGenerativeAI } from '@ai-sdk/google';
 import { createMistral } from '@ai-sdk/mistral';
 import { createOpenAI } from '@ai-sdk/openai';
 import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
-import { BUILT_IN_PROVIDER_MODEL_INFO } from './generated-context-windows';
+import { BUILT_IN_PROVIDER_MODEL_INFO } from './generated-model-info';
 /**
  * Anthropic provider
  */

package/lib/providers/{generated-context-windows.d.ts → generated-model-info.d.ts}

@@ -1,8 +1,8 @@
 /**
- * This file is generated by `jlpm sync:model-context-windows`.
+ * This file is generated by `jlpm sync:model-info`.
  * Source: https://models.dev/api.json
  * Backed by: https://github.com/anomalyco/models.dev
- * Generated: 2026-04-08T16:23:34.080Z
+ * Generated: 2026-04-28T11:55:05.327Z
  */
 import type { IProviderModelInfo } from '../tokens';
 export declare const BUILT_IN_PROVIDER_MODEL_INFO: Record<string, Record<string, IProviderModelInfo>>;