@jupyterlite/ai 0.16.0 → 0.17.0

package/lib/index.js

@@ -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.
@@ -386,6 +401,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);
@@ -514,6 +530,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 +602,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 +632,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')
                         }
                     }
                 }
@@ -615,7 +790,8 @@ function registerCommands(app, rmRegistry, chatPanel, attachmentOpenerRegistry,
                     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.
                 const status = await Promise.any([
@@ -630,6 +806,14 @@ function registerCommands(app, rmRegistry, chatPanel, attachmentOpenerRegistry,
                 }
                 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();
@@ -1118,6 +1302,7 @@ export default [
     skillRegistryPlugin,
     skillsCommandPlugin,
     chatModelHandler,
+    activeCellManager,
     plugin,
     toolRegistry,
     agentManagerFactory,

package/lib/tokens.d.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';
 import { AIChatModel } from './chat-model';
@@ -17,6 +17,7 @@ export declare namespace CommandIds {
     const openSettings = "@jupyterlite/ai:open-settings";
     const reposition = "@jupyterlite/ai:reposition";
     const openChat = "@jupyterlite/ai:open-chat";
+    const openOrRevealChat = "@jupyterlite/ai:open-or-reveal-chat";
     const moveChat = "@jupyterlite/ai:move-chat";
     const refreshSkills = "@jupyterlite/ai:refresh-skills";
     const saveChat = "@jupyterlite/ai:save-chat";
@@ -465,7 +466,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
@@ -492,7 +493,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.
@@ -561,6 +567,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/lib/tokens.js

@@ -7,6 +7,7 @@ export var CommandIds;
     CommandIds.openSettings = '@jupyterlite/ai:open-settings';
     CommandIds.reposition = '@jupyterlite/ai:reposition';
     CommandIds.openChat = '@jupyterlite/ai:open-chat';
+    CommandIds.openOrRevealChat = '@jupyterlite/ai:open-or-reveal-chat';
     CommandIds.moveChat = '@jupyterlite/ai:move-chat';
     CommandIds.refreshSkills = '@jupyterlite/ai:refresh-skills';
     CommandIds.saveChat = '@jupyterlite/ai:save-chat';

package/lib/widgets/main-area-chat.d.ts

@@ -26,5 +26,6 @@ export declare class MainAreaChat extends MainAreaWidget<ChatWidget> {
      */
     get area(): string | undefined;
     private _writersChanged;
+    private _titleChanged;
     private _outputAreaCompat;
 }

package/lib/widgets/main-area-chat.js

@@ -10,7 +10,8 @@ import { CommandIds } from '../tokens';
 export class MainAreaChat extends MainAreaWidget {
     constructor(options) {
         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;
         // Move to side button.
         this.toolbar.addItem('moveToSide', new CommandToolbarButton({
@@ -43,12 +44,14 @@ export class MainAreaChat extends MainAreaWidget {
             chatPanel: this.content
         });
         this.model.writersChanged.connect(this._writersChanged);
+        this.model.titleChanged.connect(this._titleChanged);
     }
     dispose() {
         super.dispose();
         // 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);
     }
     /**
      * Get the model of the chat.
@@ -74,5 +77,8 @@ export class MainAreaChat extends MainAreaWidget {
             this.content.inputToolbarRegistry?.show('send');
         }
     };
+    _titleChanged = () => {
+        this.title.caption = this.model.title ?? this.model.name;
+    };
     _outputAreaCompat;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jupyterlite/ai",
-    "version": "0.16.0",
+    "version": "0.17.0",
     "description": "AI code completions and chat for JupyterLite",
     "keywords": [
         "jupyter",

package/src/agent.ts

@@ -4,6 +4,7 @@ import { IRenderMimeRegistry } from '@jupyterlab/rendermime';
 import { PromiseDelegate } from '@lumino/coreutils';
 import { ISignal, Signal } from '@lumino/signaling';
 import {
+  generateText,
   ToolLoopAgent,
   type ModelMessage,
   type LanguageModel,
@@ -13,7 +14,9 @@ import {
   type TypedToolError,
   type TypedToolOutputDenied,
   type TypedToolResult,
-  type AssistantModelMessage
+  type UserContent,
+  type AssistantModelMessage,
+  APICallError
 } from 'ai';
 import { ISecretsManager } from 'jupyter-secrets-manager';
 
@@ -504,12 +507,13 @@ export class AgentManager implements IAgentManager {
     this._pendingApprovals.clear();
 
     // Convert chat messages to model messages
-    const modelMessages = messages.map(msg => {
-      const isAIMessage = msg.sender.username === 'ai-assistant';
+    const modelMessages: ModelMessage[] = messages.map(msg => {
+      const role =
+        msg.sender.username === 'ai-assistant' ? 'assistant' : 'user';
       return {
-        role: isAIMessage ? 'assistant' : 'user',
+        role,
         content: msg.body
-      } as ModelMessage;
+      };
     });
     this._history = Private.sanitizeModelMessages(modelMessages);
   }
@@ -571,10 +575,17 @@ export class AgentManager implements IAgentManager {
    * Handles the complete execution cycle including tool calls.
    * @param message The user message to respond to (may include processed attachment content)
    */
-  async generateResponse(message: string): Promise<void> {
+  async generateResponse(message: UserContent): Promise<void> {
     this._streaming = new PromiseDelegate();
     this._controller = new AbortController();
     const responseHistory: ModelMessage[] = [];
+
+    // Add user message to history
+    responseHistory.push({
+      role: 'user',
+      content: message
+    });
+
     try {
       // Ensure we have an agent
       if (!this._agent) {
@@ -585,12 +596,6 @@ export class AgentManager implements IAgentManager {
         throw new Error('Failed to initialize agent');
       }
 
-      // Add user message to history
-      responseHistory.push({
-        role: 'user',
-        content: message
-      });
-
       let continueLoop = true;
       while (continueLoop) {
         const result = await this._agent.stream({
@@ -647,9 +652,41 @@ export class AgentManager implements IAgentManager {
       this._history.push(...Private.sanitizeModelMessages(responseHistory));
     } catch (error) {
       if ((error as Error).name !== 'AbortError') {
+        let helpMessage = `${(error as Error).message}`;
+
+        // Remove attachments from history on payload rejection errors
+        if (
+          APICallError.isInstance(error) &&
+          (error.statusCode === 400 ||
+            error.statusCode === 404 ||
+            error.statusCode === 413 ||
+            error.statusCode === 415 ||
+            error.statusCode === 422)
+        ) {
+          for (const msg of [...this._history, ...responseHistory]) {
+            if (msg.role === 'user' && Array.isArray(msg.content)) {
+              const hasMedia = msg.content.some(p => p.type !== 'text');
+              if (hasMedia) {
+                const textContent = msg.content
+                  .filter(p => p.type === 'text')
+                  .map(p => (p as { text: string }).text)
+                  .join('\n');
+                msg.content =
+                  textContent || '_Attachment removed due to error_';
+              }
+            }
+          }
+          helpMessage +=
+            '\n\nAttachments have been removed from history. Please send your prompt again.';
+        }
         this._agentEvent.emit({
           type: 'error',
-          data: { error: error as Error }
+          data: { error: new Error(helpMessage) }
+        });
+        this._history.push(...Private.sanitizeModelMessages(responseHistory));
+        this._history.push({
+          role: 'assistant',
+          content: helpMessage
         });
       }
     } finally {
@@ -658,6 +695,24 @@ export class AgentManager implements IAgentManager {
     }
   }
 
+  /**
+   * 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.
+   */
+  async textResponse(messages: ModelMessage[]): Promise<string> {
+    try {
+      const model = await this._createModel();
+      const result = await generateText({
+        model,
+        messages
+      });
+      this._updateTokenUsage(result.totalUsage, result.totalUsage.inputTokens);
+      return result.text;
+    } catch (e) {
+      throw `Error while getting the topic of the chat\n${e}`;
+    }
+  }
+
   /**
    * Updates cumulative token usage statistics from a completed model step.
    */
@@ -932,6 +987,9 @@ ${richOutputWorkflowInstruction}`;
           await this._handleApprovalRequest(part, processResult);
           break;
 
+        case 'error':
+          throw part.error;
+
         case 'finish-step':
           this._updateTokenUsage(part.usage, part.usage.inputTokens);
           break;
@@ -940,7 +998,7 @@ ${richOutputWorkflowInstruction}`;
           processResult.aborted = true;
           break;
 
-        // Ignore: text-start, text-end, finish, error, and others
+        // Ignore: text-start, text-end, finish, and others
         default:
           break;
       }

package/src/chat-commands/clear.ts

@@ -29,7 +29,7 @@ export class ClearCommandProvider implements IChatCommandProvider {
     const context = inputModel.chatContext as
       | AIChatModel.IAIChatContext
       | undefined;
-    context?.clearMessages?.();
+    await context?.clearMessages?.();
 
     inputModel.value = '';
     inputModel.clearAttachments();

package/src/chat-model-handler.ts

@@ -29,7 +29,8 @@ export class ChatModelHandler implements IChatModelHandler {
   }
 
   createModel(options: ICreateChatOptions): AIChatModel {
-    const { name, activeProvider, tokenUsage, messages, autosave } = options;
+    const { name, activeProvider, tokenUsage, messages, autosave, title } =
+      options;
 
     // Create Agent Manager first so it can be shared
     const agentManager = this._agentManagerFactory.createAgent({
@@ -58,6 +59,10 @@ export class ChatModelHandler implements IChatModelHandler {
 
     model.name = name;
 
+    if (title) {
+      model.title = title;
+    }
+
     return model;
   }