@jupyterlite/ai 0.16.0 → 0.18.0

package/src/components/clear-button.tsx

@@ -16,7 +16,7 @@ export interface IClearButtonProps
   /**
    * The function to clear messages.
    */
-  clearMessages: () => void;
+  clearMessages: () => Promise<void>;
   /**
    * The application language translator.
    */
@@ -53,8 +53,8 @@ export function clearItem(
   return {
     element: (props: InputToolbarRegistry.IToolbarItemProps) => {
       const { model } = props;
-      const clearMessages = () =>
-        (model.chatContext as AIChatModel.IAIChatContext).clearMessages();
+      const clearMessages = async () =>
+        await (model.chatContext as AIChatModel.IAIChatContext).clearMessages();
       const clearProps: IClearButtonProps = {
         ...props,
         clearMessages,

package/src/components/save-button.tsx

@@ -7,7 +7,7 @@ import {
 import type { TranslationBundle } from '@jupyterlab/translation';
 import React, { useEffect, useState } from 'react';
 
-import { AIChatModel } from '../chat-model';
+import { IAIChatModel } from '../tokens';
 
 const COMPONENT_CLASS = 'jp-ai-SaveButton';
 const AUTOSAVE_BUTTON_CLASS = 'jp-ai-AutoSaveButton';
@@ -19,7 +19,7 @@ export interface ISaveButtonProps {
   /**
    * The chat model, used to listen for message changes for auto-save.
    */
-  model: AIChatModel;
+  model: IAIChatModel;
   /**
    * The application language translator.
    */
@@ -40,7 +40,7 @@ export function SaveComponent(props: ISaveButtonProps): JSX.Element {
    * Effect that update the autosave state when it is updated on the model.
    */
   useEffect(() => {
-    const updateAutosave = (_: AIChatModel, value: boolean) => {
+    const updateAutosave = (_: IAIChatModel, value: boolean) => {
       setAutosave(value);
     };
 

package/src/index.ts

@@ -58,7 +58,7 @@ import {
   ToolbarButton
 } from '@jupyterlab/ui-components';
 
-import { PromiseDelegate, UUID } from '@lumino/coreutils';
+import { UUID } from '@lumino/coreutils';
 
 import { DisposableSet } from '@lumino/disposable';
 
@@ -70,8 +70,6 @@ import { ISecretsManager, SecretsManager } from 'jupyter-secrets-manager';
 
 import { AgentManagerFactory } from './agent';
 
-import { AIChatModel } from './chat-model';
-
 import { RenderedMessageOutputAreaCompat } from './rendered-message-outputarea';
 
 import { ClearCommandProvider } from './chat-commands/clear';
@@ -95,7 +93,8 @@ import {
   IProviderRegistry,
   IToolRegistry,
   ISkillRegistry,
-  SECRETS_NAMESPACE
+  SECRETS_NAMESPACE,
+  IAIChatModel
 } from './tokens';
 
 import {
@@ -357,6 +356,27 @@ const chatModelHandler: JupyterFrontEndPlugin<IChatModelHandler> = {
   }
 };
 
+/**
+ * The active cell manager plugin, to allow copying code from chat to notebook.
+ */
+const activeCellManager: JupyterFrontEndPlugin<void> = {
+  id: '@jupyterlite/ai:activeCellManager',
+  description: 'Add the active cell manager to the model handler',
+  autoStart: true,
+  requires: [IChatModelHandler, INotebookTracker],
+  activate: (
+    app: JupyterFrontEnd,
+    modelHandler: IChatModelHandler,
+    notebookTracker: INotebookTracker
+  ) => {
+    const activeCellManager = new ActiveCellManager({
+      tracker: notebookTracker,
+      shell: app.shell
+    });
+    modelHandler.activeCellManager = activeCellManager;
+  }
+};
+
 /**
  * Initialization data for the extension.
  */
@@ -376,7 +396,6 @@ const plugin: JupyterFrontEndPlugin<IChatTracker> = {
     IThemeManager,
     ILayoutRestorer,
     ILabShell,
-    INotebookTracker,
     ITranslator,
     IComponentsRendererFactory,
     ICommandPalette,
@@ -392,7 +411,6 @@ const plugin: JupyterFrontEndPlugin<IChatTracker> = {
     themeManager?: IThemeManager,
     restorer?: ILayoutRestorer,
     labShell?: ILabShell,
-    notebookTracker?: INotebookTracker,
     translator?: ITranslator,
     chatComponentsFactory?: IComponentsRendererFactory,
     palette?: ICommandPalette,
@@ -416,17 +434,6 @@ const plugin: JupyterFrontEndPlugin<IChatTracker> = {
       }
     };
 
-    // Create ActiveCellManager if notebook tracker is available, and add it to the
-    // model registry.
-    let activeCellManager: ActiveCellManager | undefined;
-    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<MainAreaChat | ChatWidget>({ namespace });
@@ -518,7 +525,7 @@ const plugin: JupyterFrontEndPlugin<IChatTracker> = {
 
     let usageWidget: UsageWidget | null = null;
     chatPanel.chatOpened.connect((_, widget) => {
-      const model = widget.model as AIChatModel;
+      const model = widget.model as IAIChatModel;
 
       // Add the widget to the tracker.
       tracker.add(widget);
@@ -527,6 +534,18 @@ const plugin: JupyterFrontEndPlugin<IChatTracker> = {
         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);
 
@@ -565,11 +584,9 @@ const plugin: JupyterFrontEndPlugin<IChatTracker> = {
         );
 
         if (aiWriting) {
-          widget.inputToolbarRegistry?.hide('send');
           widget.inputToolbarRegistry?.show('stop');
         } else {
           widget.inputToolbarRegistry?.hide('stop');
-          widget.inputToolbarRegistry?.show('send');
         }
       }
 
@@ -582,6 +599,7 @@ const plugin: JupyterFrontEndPlugin<IChatTracker> = {
       });
 
       widget.disposed.connect(() => {
+        model.titleChanged.disconnect(updateToolbarTitleOverlay);
         model.nameChanged.disconnect(saveTracker);
         model.agentManager.activeProviderChanged.disconnect(saveTracker);
         model.writersChanged?.disconnect(writersChanged);
@@ -607,7 +625,7 @@ const plugin: JupyterFrontEndPlugin<IChatTracker> = {
         args: widget => ({
           name: widget.model.name,
           area: widget instanceof MainAreaChat ? 'main' : 'side',
-          provider: (widget.model as AIChatModel).agentManager.activeProvider
+          provider: (widget.model as IAIChatModel).agentManager.activeProvider
         }),
         name: widget => {
           const area = widget instanceof MainAreaChat ? 'main' : 'side';
@@ -641,24 +659,39 @@ const plugin: JupyterFrontEndPlugin<IChatTracker> = {
     );
 
     /**
-     * The callback to approve or reject a tool.
+     * The callback for grouped tool calls permission decisions.
      */
-    function toolCallApproval(
-      targetId: string,
-      approvalId: string,
-      isApproved: boolean
+    function toolCallPermissionDecision(
+      sessionId: string,
+      toolCallId: string,
+      optionId: string
     ) {
-      const model = tracker.find(chat => chat.model.name === targetId)?.model;
+      const model = tracker.find(chat => chat.model.name === sessionId)
+        ?.model as IAIChatModel;
       if (!model) {
         return;
       }
+
+      const isApproved = optionId === 'approve';
       isApproved
-        ? (model as AIChatModel).agentManager.approveToolCall(approvalId)
-        : (model as AIChatModel).agentManager.rejectToolCall(approvalId);
+        ? model.agentManager.approveToolCall(toolCallId)
+        : model.agentManager.rejectToolCall(toolCallId);
     }
 
     if (chatComponentsFactory) {
-      chatComponentsFactory.toolCallApproval = toolCallApproval;
+      chatComponentsFactory.toolCallPermissionDecision =
+        toolCallPermissionDecision;
+
+      chatComponentsFactory.removeQueuedMessage = (
+        targetId: string,
+        messageId: string
+      ) => {
+        const model = tracker.find(chat => chat.model.name === targetId)?.model;
+        if (!model) {
+          return;
+        }
+        (model as IAIChatModel).removeQueuedMessage(messageId);
+      };
     }
 
     return tracker;
@@ -734,12 +767,13 @@ function registerCommands(
       }
     });
 
-    const openInMain = (model: AIChatModel) => {
+    const openInMain = (model: IAIChatModel): MainAreaChat => {
+      const inputToolbarRegistry = inputToolbarFactory.create();
       const content = new ChatWidget({
         model,
         rmRegistry,
         themeManager: themeManager ?? null,
-        inputToolbarRegistry: inputToolbarFactory.create(),
+        inputToolbarRegistry,
         attachmentOpenerRegistry,
         chatCommandRegistry
       });
@@ -767,6 +801,64 @@ function registerCommands(
         model.nameChanged.disconnect(saveTracker);
         model.agentManager.activeProviderChanged.disconnect(saveTracker);
       });
+
+      return widget;
+    };
+
+    const focusOnChat = (
+      area: 'main' | 'side',
+      widget?: ChatWidget | MainAreaChat
+    ) => {
+      if (area === 'main' && widget) {
+        app.shell.activateById(widget.id);
+      } else {
+        app.shell.activateById(chatPanel.id);
+      }
+    };
+
+    const applyInputArgs = (model: IChatModel, args: any) => {
+      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?: string,
+      provider?: string
+    ): ChatWidget | MainAreaChat | undefined => {
+      if (!name && !provider) {
+        return;
+      }
+      return tracker.find(widget => {
+        const model = widget.model as IAIChatModel;
+        return (
+          (!name || widget.model.name === name) &&
+          (!provider || model.agentManager.activeProvider === provider)
+        );
+      });
+    };
+
+    const disposeSideChatModel = (model: IChatModel): boolean => {
+      const loadedName = chatPanel
+        .getLoadedModelNames()
+        .find(name => chatPanel.getLoadedModel(name) === model);
+
+      if (!loadedName) {
+        return false;
+      }
+
+      chatPanel.disposeLoadedModel(loadedName);
+      return true;
     };
 
     commands.addCommand(CommandIds.openChat, {
@@ -801,11 +893,18 @@ function registerCommands(
           return false;
         }
 
+        const shouldFocus = args.focus === true;
+        let widget: ChatWidget | MainAreaChat | undefined;
         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: {
@@ -824,6 +923,137 @@ function registerCommands(
             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): Promise<boolean> => {
+        const area = (args.area as string) === 'main' ? 'main' : 'side';
+        const provider = (args.provider as string) ?? undefined;
+        const name = (args.name as string) ?? 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
+          }) as Promise<boolean>;
+        }
+
+        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
+          })) as boolean;
+          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'
+              )
             }
           }
         }
@@ -847,11 +1077,11 @@ function registerCommands(
           return false;
         }
         let previousWidget: ChatWidget | MainAreaChat | undefined;
-        let previousModel: AIChatModel | undefined;
+        let previousModel: IAIChatModel | undefined;
         tracker.forEach(widget => {
           if (widget.model.name === args.name) {
             previousWidget = widget;
-            previousModel = widget.model as AIChatModel;
+            previousModel = widget.model as IAIChatModel;
           }
         });
 
@@ -862,51 +1092,26 @@ function registerCommands(
           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<boolean>();
-        const widgetUpdated = (_: any, widget: ChatWidget | MainAreaChat) => {
-          if (widget.model === previousModel) {
-            trackerUpdated.resolve(true);
+        if (area === 'main') {
+          // 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();
+            }
           }
-        };
-        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 as string,
-          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<boolean>(r =>
-            setTimeout(() => {
-              r(false);
-            }, 2000)
-          )
-        ]);
-        tracker.widgetUpdated.disconnect(widgetUpdated);
-
-        if (!status) {
-          return false;
-        }
-
-        if (area === 'main') {
-          openInMain(model);
+          // 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;
@@ -935,15 +1140,15 @@ function registerCommands(
       caption: trans.__('Save the chat as local file'),
       icon: saveIcon,
       execute: async (args): Promise<boolean> => {
-        let model: AIChatModel | null = null;
+        let model: IAIChatModel | null = null;
         if (args.name) {
           tracker.forEach(widget => {
             if (widget.model.name === args.name) {
-              model = widget.model as AIChatModel;
+              model = widget.model as IAIChatModel;
             }
           });
         } else {
-          model = (tracker.currentWidget?.model as AIChatModel) ?? null;
+          model = (tracker.currentWidget?.model as IAIChatModel) ?? null;
         }
         if (model === null) {
           console.log('No chat to save');
@@ -980,15 +1185,15 @@ function registerCommands(
           console.warn('The restoration is not possible');
           return false;
         }
-        let model: AIChatModel | null = null;
+        let model: IAIChatModel | null = null;
         if (args.name) {
           tracker.forEach(widget => {
             if (widget.model.name === args.name) {
-              model = widget.model as AIChatModel;
+              model = widget.model as IAIChatModel;
             }
           });
         } else {
-          model = (tracker.currentWidget?.model as AIChatModel) ?? null;
+          model = (tracker.currentWidget?.model as IAIChatModel) ?? null;
         }
         if (model === null) {
           console.warn('There is no chat to restore');
@@ -1512,6 +1717,7 @@ export default [
   skillRegistryPlugin,
   skillsCommandPlugin,
   chatModelHandler,
+  activeCellManager,
   plugin,
   toolRegistry,
   agentManagerFactory,

package/src/models/settings-model.ts

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

package/src/providers/built-in-providers.ts

@@ -4,7 +4,7 @@ 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';
 import type { IProviderInfo } from '../tokens';
 import type { IModelOptions } from './models';