@jupyterlite/ai 0.16.0 → 0.17.0

package/src/index.ts

@@ -357,6 +357,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 +397,6 @@ const plugin: JupyterFrontEndPlugin<IChatTracker> = {
     IThemeManager,
     ILayoutRestorer,
     ILabShell,
-    INotebookTracker,
     ITranslator,
     IComponentsRendererFactory,
     ICommandPalette,
@@ -392,7 +412,6 @@ const plugin: JupyterFrontEndPlugin<IChatTracker> = {
     themeManager?: IThemeManager,
     restorer?: ILayoutRestorer,
     labShell?: ILabShell,
-    notebookTracker?: INotebookTracker,
     translator?: ITranslator,
     chatComponentsFactory?: IComponentsRendererFactory,
     palette?: ICommandPalette,
@@ -416,17 +435,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 });
@@ -527,6 +535,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);
 
@@ -582,6 +602,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);
@@ -734,7 +755,7 @@ function registerCommands(
       }
     });
 
-    const openInMain = (model: AIChatModel) => {
+    const openInMain = (model: AIChatModel): MainAreaChat => {
       const content = new ChatWidget({
         model,
         rmRegistry,
@@ -767,6 +788,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 AIChatModel;
+        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 +880,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 +910,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'
+              )
             }
           }
         }
@@ -883,7 +1100,8 @@ function registerCommands(
           activeProvider: previousModel.agentManager.activeProvider,
           tokenUsage: previousModel.agentManager.tokenUsage,
           messages: previousModel.messages,
-          autosave: previousModel.autosave
+          autosave: previousModel.autosave,
+          title: previousModel.title
         });
 
         // Wait (with timeout) for the tracker to have updated the previous widget.
@@ -903,6 +1121,15 @@ function registerCommands(
 
         if (area === 'main') {
           openInMain(model);
+
+          if (previousWidget instanceof ChatWidget) {
+            // Clean up the side-panel model entry before disposing the previous
+            // widget/model state.
+            if (!disposeSideChatModel(previousModel)) {
+              previousWidget.dispose();
+              previousModel.dispose();
+            }
+          }
         } else {
           previousWidget?.dispose();
           previousModel.dispose();
@@ -1512,6 +1739,7 @@ export default [
   skillRegistryPlugin,
   skillsCommandPlugin,
   chatModelHandler,
+  activeCellManager,
   plugin,
   toolRegistry,
   agentManagerFactory,

package/src/tokens.ts

@@ -4,7 +4,7 @@ import { IRenderMimeRegistry } from '@jupyterlab/rendermime';
 import { Token } from '@lumino/coreutils';
 import type { IDisposable } from '@lumino/disposable';
 import { ISignal } from '@lumino/signaling';
-import type { Tool, LanguageModel } from 'ai';
+import type { Tool, LanguageModel, UserContent, ModelMessage } from 'ai';
 import { ISecretsManager } from 'jupyter-secrets-manager';
 
 import type { IModelOptions } from './providers/models';
@@ -30,6 +30,7 @@ export namespace CommandIds {
   export const openSettings = '@jupyterlite/ai:open-settings';
   export const reposition = '@jupyterlite/ai:reposition';
   export const openChat = '@jupyterlite/ai:open-chat';
+  export const openOrRevealChat = '@jupyterlite/ai:open-or-reveal-chat';
   export const moveChat = '@jupyterlite/ai:move-chat';
   export const refreshSkills = '@jupyterlite/ai:refresh-skills';
   export const saveChat = '@jupyterlite/ai:save-chat';
@@ -584,7 +585,7 @@ export interface IAgentManager {
   /**
    * Clears conversation history and resets agent state.
    */
-  clearHistory(): void;
+  clearHistory(): Promise<void>;
   /**
    * Sets the conversation history with a list of messages from the chat.
    * @param messages The chat messages to set as history
@@ -611,7 +612,12 @@ export interface IAgentManager {
    * Handles the complete execution cycle including tool calls.
    * @param message The user message to respond to (may include processed attachment content)
    */
-  generateResponse(message: string): Promise<void>;
+  generateResponse(message: UserContent): Promise<void>;
+  /**
+   * Create a transient language model to request a text response, which won't be added to history.
+   * @param messages - the messages sequence to send to the model.
+   */
+  textResponse(messages: ModelMessage[]): Promise<string>;
   /**
    * Initializes the AI agent with current settings and tools.
    * Sets up the agent with model configuration, tools, and MCP tools.
@@ -695,6 +701,10 @@ export interface ICreateChatOptions {
    * Whether the chat is autosaved or not.
    */
   autosave?: boolean;
+  /**
+   * An optional title to the chat.
+   */
+  title?: string | null;
 }
 /**
  * Token for the chat model handler.

package/src/widgets/main-area-chat.ts

@@ -24,7 +24,8 @@ export namespace MainAreaChat {
 export class MainAreaChat extends MainAreaWidget<ChatWidget> {
   constructor(options: MainAreaChat.IOptions) {
     super(options);
-    this.title.label = this.content.model.name;
+    this.title.label = this.model.name;
+    this.title.caption = this.model.title ?? this.model.name;
 
     const { trans } = options;
 
@@ -69,6 +70,8 @@ export class MainAreaChat extends MainAreaWidget<ChatWidget> {
     });
 
     this.model.writersChanged.connect(this._writersChanged);
+
+    this.model.titleChanged.connect(this._titleChanged);
   }
 
   dispose(): void {
@@ -76,6 +79,7 @@ export class MainAreaChat extends MainAreaWidget<ChatWidget> {
     // Dispose of the approval buttons widget when the chat is disposed.
     this._outputAreaCompat.dispose();
     this.model.writersChanged.disconnect(this._writersChanged);
+    this.model.titleChanged.disconnect(this._titleChanged);
   }
 
   /**
@@ -107,5 +111,9 @@ export class MainAreaChat extends MainAreaWidget<ChatWidget> {
     }
   };
 
+  private _titleChanged = () => {
+    this.title.caption = this.model.title ?? this.model.name;
+  };
+
   private _outputAreaCompat: RenderedMessageOutputAreaCompat;
 }