@jupyterlite/ai 0.10.0 → 0.11.1

package/lib/agent.js

@@ -654,17 +654,24 @@ Guidelines:
 - End with a brief summary of accomplishments
 - Use natural, conversational tone throughout
 
-COMMAND DISCOVERY:
-- When you want to execute JupyterLab commands, ALWAYS use the 'discover_commands' tool first to find available commands and their metadata, with the optional query parameter.
-- The query should typically be a single word, e.g., 'terminal', 'notebook', 'cell', 'file', 'edit', 'view', 'run', etc, to find relevant commands.
-- If searching with a query does not yield the desired command, try again with a different query or use an empty query to list all commands.
-- This ensures you have complete information about command IDs, descriptions, and required arguments before attempting to execute them. Only after discovering the available commands should you use the 'execute_command' tool with the correct command ID and arguments.
+PRIMARY TOOL USAGE - COMMAND-BASED OPERATIONS:
+Most operations in JupyterLab should be performed using the command system:
+1. Use 'discover_commands' to find available commands and their metadata
+2. Use 'execute_command' to perform the actual operation
 
-TOOL SELECTION GUIDELINES:
-- For file operations (create, read, write, modify files and directories): Use dedicated file manipulation tools
-- For general JupyterLab UI interactions (opening panels, running commands, navigating interface): Use the general command tool (execute_command)
-- Examples of file operations: Creating notebooks, editing code files, managing project structure
-- Examples of UI interactions: Opening terminal, switching tabs, running notebook cells, accessing menus
+COMMAND DISCOVERY WORKFLOW:
+- For file and notebook operations, use query 'jupyterlab-ai-commands' to discover the curated set of AI commands (~17 commands for file/notebook/directory operations)
+- For other JupyterLab operations (terminal, launcher, UI), use specific keywords like 'terminal', 'launcher', etc.
+- IMPORTANT: Always use 'jupyterlab-ai-commands' as the query for file/notebook tasks - this returns a focused set of commands instead of 100+ generic JupyterLab commands
+
+KERNEL PREFERENCE FOR NOTEBOOKS AND CONSOLES:
+When creating notebooks or consoles for a specific programming language, use the 'kernelPreference' argument to specify the kernel:
+- To specify by language: { "kernelPreference": { "language": "python" } } or { "kernelPreference": { "language": "julia" } }
+- To specify by kernel name: { "kernelPreference": { "name": "python3" } } or { "kernelPreference": { "name": "julia-1.10" } }
+- Example: execute_command with commandId="notebook:create-new" and args={ "kernelPreference": { "language": "python" } }
+- Example: execute_command with commandId="console:create" and args={ "kernelPreference": { "name": "python3" } }
+- Common kernel names: "python3" (Python), "julia-1.10" (Julia), "ir" (R), "xpython" (xeus-python)
+- If unsure of exact kernel name, prefer using "language" which will match any kernel supporting that language
 `;
         return baseSystemPrompt + progressReportingPrompt;
     }

package/lib/chat-model-registry.d.ts

@@ -15,6 +15,11 @@ export declare class ChatModelRegistry implements IChatModelRegistry {
     get(name: string): AIChatModel | undefined;
     getAll(): AIChatModel[];
     remove(name: string): void;
+    /**
+     * Getter/setter for the active cell manager.
+     */
+    get activeCellManager(): ActiveCellManager | undefined;
+    set activeCellManager(manager: ActiveCellManager | undefined);
     private _models;
     private _docManager;
     private _agentManagerFactory;
@@ -49,7 +54,7 @@ export declare namespace ChatModelRegistry {
         /**
          * The active cell manager.
          */
-        activeCellManager: ActiveCellManager | undefined;
+        activeCellManager?: ActiveCellManager | undefined;
         /**
          * The application language translation bundle.
          */

package/lib/chat-model-registry.js

@@ -52,6 +52,9 @@ export class ChatModelRegistry {
     add(model) {
         if (!this._models.find(m => m.name === model.name)) {
             this._models.push(model);
+            model.disposed.connect(() => {
+                this.remove(model.name);
+            });
         }
     }
     get(name) {
@@ -66,6 +69,15 @@ export class ChatModelRegistry {
             this._models.splice(index, 1);
         }
     }
+    /**
+     * Getter/setter for the active cell manager.
+     */
+    get activeCellManager() {
+        return this._activeCellManager;
+    }
+    set activeCellManager(manager) {
+        this._activeCellManager = manager;
+    }
     _models = [];
     _docManager;
     _agentManagerFactory;

package/lib/chat-model.d.ts

@@ -81,6 +81,13 @@ export declare class AIChatModel extends AbstractChatModel {
      * @param event Event containing the message completion data
      */
     private _handleMessageComplete;
+    /**
+     * Extracts a human-readable summary from tool input for display in the header.
+     * @param toolName The name of the tool being called
+     * @param input The formatted JSON input string
+     * @returns A short summary string or empty string if none available
+     */
+    private _extractToolSummary;
     /**
      * Handles the start of a tool call execution.
      * @param event Event containing the tool call start data

package/lib/chat-model.js

@@ -242,18 +242,47 @@ export class AIChatModel extends AbstractChatModel {
             this._currentStreamingMessage = null;
         }
     }
+    /**
+     * Extracts a human-readable summary from tool input for display in the header.
+     * @param toolName The name of the tool being called
+     * @param input The formatted JSON input string
+     * @returns A short summary string or empty string if none available
+     */
+    _extractToolSummary(toolName, input) {
+        try {
+            const parsedInput = JSON.parse(input);
+            switch (toolName) {
+                case 'execute_command':
+                    if (parsedInput.commandId) {
+                        return parsedInput.commandId;
+                    }
+                    break;
+                case 'discover_commands':
+                    if (parsedInput.query) {
+                        return `query: "${parsedInput.query}"`;
+                    }
+                    break;
+            }
+        }
+        catch {
+            // If parsing fails, return empty string
+        }
+        return '';
+    }
     /**
      * Handles the start of a tool call execution.
      * @param event Event containing the tool call start data
      */
     _handleToolCallStartEvent(event) {
         const messageId = UUID.uuid4();
+        const summary = this._extractToolSummary(event.data.toolName, event.data.input);
         const context = {
             toolCallId: event.data.callId,
             messageId,
             toolName: event.data.toolName,
             input: event.data.input,
-            status: 'pending'
+            status: 'pending',
+            summary
         };
         this._toolContexts.set(event.data.callId, context);
         const toolCallMessage = {
@@ -261,6 +290,7 @@ export class AIChatModel extends AbstractChatModel {
                 toolName: context.toolName,
                 input: context.input,
                 status: context.status,
+                summary: context.summary,
                 trans: this._trans
             }),
             sender: this._getAIUser(),
@@ -337,6 +367,7 @@ export class AIChatModel extends AbstractChatModel {
                 toolName: context.toolName,
                 input: context.input,
                 status: context.status,
+                summary: context.summary,
                 output,
                 approvalId: context.approvalId,
                 trans: this._trans
@@ -642,12 +673,15 @@ var Private;
      * Builds HTML for a tool call display.
      */
     function buildToolCallHtml(options) {
-        const { toolName, input, status, output, approvalId, trans } = options;
+        const { toolName, input, status, summary, output, approvalId, trans } = options;
         const config = STATUS_CONFIG[status];
         const statusText = getStatusText(status, trans);
         const escapedToolName = escapeHtml(toolName);
         const escapedInput = escapeHtml(input);
         const openAttr = config.open ? ' open' : '';
+        const summaryHtml = summary
+            ? `<span class="jp-ai-tool-summary">${escapeHtml(summary)}</span>`
+            : '';
         let bodyContent = `
 <div class="jp-ai-tool-section">
 <div class="jp-ai-tool-label">${trans.__('Input')}</div>
@@ -674,7 +708,7 @@ var Private;
         return `<details class="jp-ai-tool-call ${config.cssClass}"${openAttr}>
 <summary class="jp-ai-tool-header">
 <div class="jp-ai-tool-icon">⚡</div>
-<div class="jp-ai-tool-title">${escapedToolName}</div>
+<div class="jp-ai-tool-title">${escapedToolName}${summaryHtml}</div>
 <div class="jp-ai-tool-status ${config.statusClass}">${statusText}</div>
 </summary>
 <div class="jp-ai-tool-body">${bodyContent}

package/lib/components/clear-button.js

@@ -8,10 +8,9 @@ export function ClearButton(props) {
     const { translator: trans } = props;
     const tooltip = trans.__('Clear chat');
     return (React.createElement(TooltippedButton, { onClick: props.clearMessages, tooltip: tooltip, buttonProps: {
-            size: 'small',
+            title: tooltip,
             variant: 'outlined',
-            color: 'secondary',
-            title: tooltip
+            color: 'secondary'
         } },
         React.createElement(ClearIcon, null)));
 }

package/lib/components/model-select.js

@@ -61,16 +61,15 @@ export function ModelSelect(props) {
     // Show a message if no providers are configured
     if (availableModels.length === 0) {
         return (React.createElement(TooltippedButton, { onClick: () => { }, tooltip: trans.__('No providers configured. Please go to AI Settings to add a provider.'), buttonProps: {
-                size: 'small',
                 variant: 'outlined',
                 color: 'warning',
                 disabled: true,
                 title: trans.__('No Providers Available')
             }, sx: {
                 minWidth: 'auto',
+                width: 'unset',
                 display: 'flex',
-                alignItems: 'center',
-                height: '29px'
+                alignItems: 'center'
             } },
             React.createElement(Typography, { variant: "caption", sx: { fontSize: '0.7rem', fontWeight: 500 } }, trans.__('No Providers'))));
     }
@@ -78,9 +77,6 @@ export function ModelSelect(props) {
         React.createElement(TooltippedButton, { onClick: e => {
                 openMenu(e.currentTarget);
             }, tooltip: trans.__('Current Model: %1 - %2', currentProviderLabel, currentModel), buttonProps: {
-                size: 'small',
-                variant: 'contained',
-                color: 'primary',
                 title: trans.__('Select AI Model'),
                 onKeyDown: e => {
                     if (e.key !== 'Enter' && e.key !== ' ') {
@@ -92,9 +88,9 @@ export function ModelSelect(props) {
                 }
             }, sx: {
                 minWidth: 'auto',
+                width: 'unset',
                 display: 'flex',
-                alignItems: 'center',
-                height: '29px'
+                alignItems: 'center'
             } },
             React.createElement(Typography, { variant: "caption", sx: { fontSize: '0.7rem', fontWeight: 500, textTransform: 'none' } }, currentProviderLabel)),
         React.createElement(Menu, { open: menuOpen, onClose: closeMenu, anchorEl: menuAnchorEl, anchorOrigin: {

package/lib/components/stop-button.js

@@ -1,4 +1,4 @@
-import { TooltippedButton } from '@jupyter/chat';
+import { TooltippedIconButton } from '@jupyter/chat';
 import StopIcon from '@mui/icons-material/Stop';
 import React from 'react';
 /**
@@ -7,11 +7,10 @@ import React from 'react';
 export function StopButton(props) {
     const { translator: trans } = props;
     const tooltip = trans.__('Stop streaming');
-    return (React.createElement(TooltippedButton, { onClick: props.stopStreaming, tooltip: tooltip, buttonProps: {
-            size: 'small',
-            variant: 'contained',
-            color: 'error',
+    return (React.createElement(TooltippedIconButton, { onClick: props.stopStreaming, tooltip: tooltip, buttonProps: {
             title: tooltip
+        }, sx: {
+            backgroundColor: 'var(--mui-palette-error-main, #d32f2f);'
         } },
         React.createElement(StopIcon, null)));
 }

package/lib/components/tool-select.js

@@ -64,9 +64,9 @@ export function ToolSelect(props) {
         React.createElement(TooltippedButton, { onClick: e => {
                 openMenu(e.currentTarget);
             }, tooltip: trans.__('Tools (%1/%2 selected)', selectedToolNames.length.toString(), tools.length.toString()), buttonProps: {
-                size: 'small',
-                variant: selectedToolNames.length > 0 ? 'contained' : 'outlined',
-                color: 'primary',
+                ...(selectedToolNames.length === 0 && {
+                    variant: 'outlined'
+                }),
                 title: trans.__('Select AI Tools'),
                 onKeyDown: e => {
                     if (e.key !== 'Enter' && e.key !== ' ') {
@@ -79,7 +79,7 @@ export function ToolSelect(props) {
             }, sx: selectedToolNames.length === 0
                 ? { backgroundColor: 'var(--jp-layout-color3)' }
                 : {} },
-            React.createElement(BuildIcon, null)),
+            React.createElement(BuildIcon, { sx: { fontSize: 'small' } })),
         React.createElement(Menu, { open: menuOpen, onClose: closeMenu, anchorEl: menuAnchorEl, anchorOrigin: {
                 vertical: 'top',
                 horizontal: 'right'

package/lib/index.d.ts

@@ -6,3 +6,4 @@ import { AISettingsModel } from './models/settings-model';
 declare const _default: (JupyterFrontEndPlugin<IProviderRegistry> | JupyterFrontEndPlugin<void> | JupyterFrontEndPlugin<IChatModelRegistry> | JupyterFrontEndPlugin<AgentManagerFactory> | JupyterFrontEndPlugin<AISettingsModel> | JupyterFrontEndPlugin<IDiffManager> | JupyterFrontEndPlugin<IToolRegistry> | JupyterFrontEndPlugin<IInputToolbarRegistryFactory>)[];
 export default _default;
 export * from './tokens';
+export * from './icons';

package/lib/index.js

@@ -3,10 +3,8 @@ import { ActiveCellManager, AttachmentOpenerRegistry, chatIcon, ChatWidget, IInp
 import { ICommandPalette, IThemeManager, WidgetTracker } from '@jupyterlab/apputils';
 import { ICompletionProviderManager } from '@jupyterlab/completer';
 import { IDocumentManager } from '@jupyterlab/docmanager';
-import { IEditorTracker } from '@jupyterlab/fileeditor';
 import { INotebookTracker } from '@jupyterlab/notebook';
 import { IRenderMimeRegistry } from '@jupyterlab/rendermime';
-import { IKernelSpecManager } from '@jupyterlab/services';
 import { ISettingRegistry } from '@jupyterlab/settingregistry';
 import { IStatusBar } from '@jupyterlab/statusbar';
 import { ITranslator, nullTranslator } from '@jupyterlab/translation';
@@ -24,8 +22,6 @@ import { clearItem, createModelSelectItem, createToolSelectItem, stopItem, Compl
 import { AISettingsModel } from './models/settings-model';
 import { DiffManager } from './diff-manager';
 import { ToolRegistry } from './tools/tool-registry';
-import { createAddCellTool, createDeleteCellTool, createExecuteActiveCellTool, createGetCellInfoTool, createGetNotebookInfoTool, createNotebookCreationTool, createRunCellTool, createSaveNotebookTool, createSetCellContentTool } from './tools/notebook';
-import { createCopyFileTool, createDeleteFileTool, createGetFileInfoTool, createNavigateToDirectoryTool, createNewFileTool, createOpenFileTool, createRenameFileTool, createSetFileContentTool } from './tools/file';
 import { createDiscoverCommandsTool, createExecuteCommandTool } from './tools/commands';
 import { AISettingsWidget } from './widgets/ai-settings';
 import { MainAreaChat } from './widgets/main-area-chat';
@@ -109,20 +105,11 @@ const chatModelRegistry = {
     description: 'Registry for the current chat model',
     autoStart: true,
     requires: [IAISettingsModel, IAgentManagerFactory, IDocumentManager],
-    optional: [IProviderRegistry, INotebookTracker, IToolRegistry, ITranslator],
+    optional: [IProviderRegistry, IToolRegistry, ITranslator],
     provides: IChatModelRegistry,
-    activate: (app, settingsModel, agentManagerFactory, docManager, providerRegistry, notebookTracker, toolRegistry, translator) => {
+    activate: (app, settingsModel, agentManagerFactory, docManager, providerRegistry, toolRegistry, translator) => {
         const trans = (translator ?? nullTranslator).load('jupyterlite_ai');
-        // Create ActiveCellManager if notebook tracker is available
-        let activeCellManager;
-        if (notebookTracker) {
-            activeCellManager = new ActiveCellManager({
-                tracker: notebookTracker,
-                shell: app.shell
-            });
-        }
         return new ChatModelRegistry({
-            activeCellManager,
             settingsModel,
             agentManagerFactory,
             docManager,
@@ -145,8 +132,14 @@ const plugin = {
         IChatModelRegistry,
         IAISettingsModel
     ],
-    optional: [IThemeManager, ILayoutRestorer, ILabShell, ITranslator],
-    activate: (app, rmRegistry, inputToolbarFactory, modelRegistry, settingsModel, themeManager, restorer, labShell, translator) => {
+    optional: [
+        IThemeManager,
+        ILayoutRestorer,
+        ILabShell,
+        INotebookTracker,
+        ITranslator
+    ],
+    activate: (app, rmRegistry, inputToolbarFactory, modelRegistry, settingsModel, themeManager, restorer, labShell, notebookTracker, translator) => {
         const trans = (translator ?? nullTranslator).load('jupyterlite_ai');
         // Create attachment opener registry to handle file attachments
         const attachmentOpenerRegistry = new AttachmentOpenerRegistry();
@@ -156,6 +149,16 @@ const plugin = {
         attachmentOpenerRegistry.set('notebook', attachment => {
             app.commands.execute('docmanager:open', { path: attachment.value });
         });
+        // 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
+            });
+        }
+        modelRegistry.activeCellManager = activeCellManager;
         // Create chat panel with drag/drop functionality
         const chatPanel = new MultiChatPanel({
             rmRegistry,
@@ -568,47 +571,10 @@ const toolRegistry = {
     id: '@jupyterlite/ai:tool-registry',
     description: 'Provide the AI tool registry',
     autoStart: true,
-    requires: [IAISettingsModel, IDocumentManager, IKernelSpecManager],
-    optional: [INotebookTracker, IDiffManager, IEditorTracker],
+    requires: [IAISettingsModel],
     provides: IToolRegistry,
-    activate: (app, settingsModel, docManager, kernelSpecManager, notebookTracker, diffManager, editorTracker) => {
+    activate: (app, settingsModel) => {
         const toolRegistry = new ToolRegistry();
-        const notebookCreationTool = createNotebookCreationTool(docManager, kernelSpecManager);
-        toolRegistry.add('create_notebook', notebookCreationTool);
-        // Add high-level notebook operation tools
-        const addCellTool = createAddCellTool(docManager, notebookTracker);
-        const getNotebookInfoTool = createGetNotebookInfoTool(docManager, notebookTracker);
-        const getCellInfoTool = createGetCellInfoTool(docManager, notebookTracker);
-        const setCellContentTool = createSetCellContentTool(docManager, notebookTracker, diffManager);
-        const runCellTool = createRunCellTool(docManager, notebookTracker);
-        const deleteCellTool = createDeleteCellTool(docManager, notebookTracker);
-        const saveNotebookTool = createSaveNotebookTool(docManager, notebookTracker);
-        const executeActiveCellTool = createExecuteActiveCellTool(docManager, notebookTracker);
-        toolRegistry.add('add_cell', addCellTool);
-        toolRegistry.add('get_notebook_info', getNotebookInfoTool);
-        toolRegistry.add('get_cell_info', getCellInfoTool);
-        toolRegistry.add('set_cell_content', setCellContentTool);
-        toolRegistry.add('run_cell', runCellTool);
-        toolRegistry.add('delete_cell', deleteCellTool);
-        toolRegistry.add('save_notebook', saveNotebookTool);
-        toolRegistry.add('execute_active_cell', executeActiveCellTool);
-        // Add file operation tools
-        const newFileTool = createNewFileTool(docManager);
-        const openFileTool = createOpenFileTool(docManager);
-        const deleteFileTool = createDeleteFileTool(docManager);
-        const renameFileTool = createRenameFileTool(docManager);
-        const copyFileTool = createCopyFileTool(docManager);
-        const navigateToDirectoryTool = createNavigateToDirectoryTool(app.commands);
-        const getFileInfoTool = createGetFileInfoTool(docManager, editorTracker);
-        const setFileContentTool = createSetFileContentTool(docManager, diffManager);
-        toolRegistry.add('create_file', newFileTool);
-        toolRegistry.add('open_file', openFileTool);
-        toolRegistry.add('delete_file', deleteFileTool);
-        toolRegistry.add('rename_file', renameFileTool);
-        toolRegistry.add('copy_file', copyFileTool);
-        toolRegistry.add('navigate_to_directory', navigateToDirectoryTool);
-        toolRegistry.add('get_file_info', getFileInfoTool);
-        toolRegistry.add('set_file_content', setFileContentTool);
         // Add command operation tools
         const discoverCommandsTool = createDiscoverCommandsTool(app.commands);
         const executeCommandTool = createExecuteCommandTool(app.commands, settingsModel);
@@ -695,3 +661,4 @@ export default [
 ];
 // Export extension points for other extensions to use
 export * from './tokens';
+export * from './icons';

package/lib/models/settings-model.js

@@ -29,7 +29,8 @@ export class AISettingsModel extends VDomModel {
             'fileeditor:run-code',
             'kernelmenu:run',
             'kernelmenu:restart-and-run-all',
-            'runmenu:run-all'
+            'runmenu:run-all',
+            'jupyterlab-ai-commands:run-cell'
         ],
         systemPrompt: `You are Jupyternaut, an AI coding assistant built specifically for the JupyterLab environment.
 
@@ -38,7 +39,7 @@ You're designed to be a capable partner for data science, research, and developm
 
 ## Your Capabilities
 **📁 File & Project Management:**
-- Create, read, edit, and organize Python files and notebooks
+- Create, read, edit, and organize files and notebooks in any language
 - Manage project structure and navigate file systems
 - Help with version control and project organization
 
@@ -48,51 +49,64 @@ You're designed to be a capable partner for data science, research, and developm
 - Help with notebook structure and organization
 - Retrieve and analyze cell outputs and execution results
 
+**⚡ Kernel Management:**
+- Start new kernels with specified language or kernel name
+- Execute code directly in running kernels without creating cells
+- List running kernels and monitor their status
+- Manage kernel lifecycle (start, monitor, shutdown)
+
 **🧠 Coding & Development:**
-- Write, debug, and optimize Python code
+- Write, debug, and optimize code in any language supported by Jupyter kernels (Python, R, Julia, JavaScript, C++, and more)
 - Explain complex algorithms and data structures
 - Help with data analysis, visualization, and machine learning
-- Support for scientific computing libraries (numpy, pandas, matplotlib, etc.)
+- Support for libraries and packages across different languages
 - Code reviews and best practices recommendations
 
 **💡 Adaptive Assistance:**
-- Understand context from your current work environment
-- Provide suggestions tailored to your specific use case
+- Understand context from the user's current work environment
+- Provide suggestions tailored to the user's specific use case
 - Help with both quick fixes and long-term project planning
 
-## How I Work
-I can actively interact with your JupyterLab environment using specialized tools. When you ask me to perform actions, I can:
-- Execute operations directly in your notebooks
+## How You Work
+You can actively interact with the user's JupyterLab environment using specialized tools. When asked to perform actions, you can:
+- Execute operations directly in notebooks
 - Create and modify files as needed
 - Run code and analyze results
 - Make systematic changes across multiple files
 
-## My Approach
-- **Context-aware**: I understand you're working in a data science/research environment
-- **Practical**: I focus on actionable solutions that work in your current setup
-- **Educational**: I explain my reasoning and teach best practices along the way
-- **Collaborative**: Think of me as a pair programming partner, not just a code generator
+## Code Execution Strategy
+When asked to run code or perform computations, choose the most appropriate approach:
+- **For quick computations or one-off code execution**: Use kernel commands to start a kernel and execute code directly, without creating notebook files. This is ideal for calculations, data lookups, or testing code snippets.
+- **For work that should be saved**: Create or use notebooks when the user needs a persistent record of their work, wants to iterate on code, or is building something they'll return to later.
+
+This means if the user asks you to "calculate the factorial of 100" or "check what library version is installed", run that directly in a kernel rather than creating a new notebook file.
+
+## Your Approach
+- **Context-aware**: You understand the user is working in a data science/research environment
+- **Practical**: You focus on actionable solutions that work in the user's current setup
+- **Educational**: You explain your reasoning and teach best practices along the way
+- **Collaborative**: You are a pair programming partner, not just a code generator
 
 ## Communication Style & Agent Behavior
-- **Conversational**: I maintain a friendly, natural conversation flow throughout our interaction
-- **Progress Updates**: I write brief progress messages between tool uses that appear directly in our conversation
-- **No Filler**: I avoid empty acknowledgments like "Sounds good!" or "Okay, I will..." - I get straight to work
-- **Purposeful Communication**: I start with what I'm doing, use tools, then share what I found and what's next
-- **Active Narration**: I actively write progress updates like "Looking at the current code structure..." or "Found the issue in the notebook..." between tool calls
-- **Checkpoint Updates**: After several operations, I summarize what I've accomplished and what remains
-- **Natural Flow**: My explanations and progress reports appear as normal conversation text, not just in tool blocks
+- **Conversational**: You maintain a friendly, natural conversation flow throughout the interaction
+- **Progress Updates**: You write brief progress messages between tool uses that appear directly in the conversation
+- **No Filler**: You avoid empty acknowledgments like "Sounds good!" or "Okay, I will..." - you get straight to work
+- **Purposeful Communication**: You start with what you're doing, use tools, then share what you found and what's next
+- **Active Narration**: You actively write progress updates like "Looking at the current code structure..." or "Found the issue in the notebook..." between tool calls
+- **Checkpoint Updates**: After several operations, you summarize what you've accomplished and what remains
+- **Natural Flow**: Your explanations and progress reports appear as normal conversation text, not just in tool blocks
 
 ## IMPORTANT: Always write progress messages between tools that explain what you're doing and what you found. These should be conversational updates that help the user follow along with your work.
 
 ## Technical Communication
 - Code is formatted in proper markdown blocks with syntax highlighting
 - Mathematical notation uses LaTeX formatting: \\(equations\\) and \\[display math\\]
-- I provide context for my actions and explain my reasoning as I work
-- When creating or modifying multiple files, I give brief summaries of changes
-- I keep users informed of progress while staying focused on the task
+- You provide context for your actions and explain your reasoning as you work
+- When creating or modifying multiple files, you give brief summaries of changes
+- You keep users informed of progress while staying focused on the task
 
 ## Multi-Step Task Handling
-When users request complex tasks that require multiple steps (like "create a notebook with example cells"), I use tools in sequence to accomplish the complete task. For example:
+When users request complex tasks that require multiple steps (like "create a notebook with example cells"), you use tools in sequence to accomplish the complete task. For example:
 - First use create_notebook to create the notebook
 - Then use add_code_cell or add_markdown_cell to add cells
 - Use set_cell_content to add content to cells as needed
@@ -100,7 +114,7 @@ When users request complex tasks that require multiple steps (like "create a not
 
 Always think through multi-step tasks and use tools to fully complete the user's request rather than stopping after just one action.
 
-Ready to help you build something great! What are you working on?`,
+You are ready to help users build something great!`,
         // Completion system prompt - also defined in schema/settings-model.json
         // This serves as a fallback if settings fail to load or are not available
         completionSystemPrompt: `You are an AI code completion assistant. Complete the given code fragment with appropriate code.

package/lib/tokens.d.ts

@@ -1,3 +1,4 @@
+import { ActiveCellManager } from '@jupyter/chat';
 import { Token } from '@lumino/coreutils';
 import { ISignal } from '@lumino/signaling';
 import type { Tool, LanguageModel } from 'ai';
@@ -194,6 +195,7 @@ export interface IChatModelRegistry {
     getAll(): AIChatModel[];
     remove(name: string): void;
     createModel(name?: string, activeProvider?: string, tokenUsage?: ITokenUsage): AIChatModel;
+    activeCellManager: ActiveCellManager | undefined;
 }
 export declare const IChatModelRegistry: Token<IChatModelRegistry>;
 /**

package/lib/tools/commands.js

@@ -12,7 +12,7 @@ export function createDiscoverCommandsTool(commands) {
                 .string()
                 .optional()
                 .nullable()
-                .describe('Optional search query to filter commands')
+                .describe("Optional search query to filter commands. It doesn't need to be provided to list all commands")
         }),
         execute: async (input) => {
             const { query } = input;
@@ -66,9 +66,9 @@ export function createExecuteCommandTool(commands, settingsModel) {
         inputSchema: z.object({
             commandId: z.string().describe('The ID of the command to execute'),
             args: z
-                .any()
+                .record(z.string(), z.unknown())
                 .optional()
-                .describe('Optional arguments to pass to the command')
+                .describe('Optional arguments object to pass to the command (must be an object, not a string)')
         }),
         needsApproval: (input) => {
             const commandsRequiringApproval = settingsModel.config.commandsRequiringApproval || [];
@@ -85,16 +85,12 @@ export function createExecuteCommandTool(commands, settingsModel) {
             }
             // Execute the command
             const result = await commands.execute(commandId, args);
-            // Handle Widget objects specially (including subclasses like DocumentWidget)
+            // Handle Widget objects specially by extracting id and title
             let serializedResult;
-            if (result &&
-                typeof result === 'object' &&
-                (result.constructor?.name?.includes('Widget') || result.id)) {
+            if (result && typeof result === 'object' && result.id) {
                 serializedResult = {
-                    type: result.constructor?.name || 'Widget',
                     id: result.id,
-                    title: result.title?.label || result.title,
-                    className: result.className
+                    title: result.title?.label || result.title
                 };
             }
             else {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jupyterlite/ai",
-    "version": "0.10.0",
+    "version": "0.11.1",
     "description": "AI code completions and chat for JupyterLite",
     "keywords": [
         "jupyter",
@@ -56,13 +56,13 @@
         "docs:build": "sed -e 's/\\[@/[/g' -e 's/@/\\@/g' CHANGELOG.md > docs/_changelog_content.md && jupyter book build --html"
     },
     "dependencies": {
-        "@ai-sdk/anthropic": "^3.0.1",
-        "@ai-sdk/google": "^3.0.1",
-        "@ai-sdk/mcp": "^1.0.1",
-        "@ai-sdk/mistral": "^3.0.1",
-        "@ai-sdk/openai": "^3.0.1",
-        "@ai-sdk/openai-compatible": "^2.0.1",
-        "@jupyter/chat": "^0.18.2",
+        "@ai-sdk/anthropic": "^3.0.23",
+        "@ai-sdk/google": "^3.0.13",
+        "@ai-sdk/mcp": "^1.0.13",
+        "@ai-sdk/mistral": "^3.0.12",
+        "@ai-sdk/openai": "^3.0.18",
+        "@ai-sdk/openai-compatible": "^2.0.18",
+        "@jupyter/chat": "^0.19.0-alpha.3",
         "@jupyterlab/application": "^4.0.0",
         "@jupyterlab/apputils": "^4.5.6",
         "@jupyterlab/cells": "^4.4.6",
@@ -86,9 +86,9 @@
         "@lumino/widgets": "^2.7.1",
         "@mui/icons-material": "^7",
         "@mui/material": "^7",
-        "ai": "^6.0.0",
+        "ai": "^6.0.49",
         "jupyter-secrets-manager": "^0.4.0",
-        "zod": "^4.2.1"
+        "zod": "^4.3.6"
     },
     "devDependencies": {
         "@jupyterlab/builder": "^4.0.0",