@jupyterlite/ai 0.10.0 → 0.11.0

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.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';
@@ -568,47 +564,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 +654,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/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.0",
     "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",

package/schema/settings-model.json

@@ -155,14 +155,15 @@
         "fileeditor:run-code",
         "kernelmenu:run",
         "kernelmenu:restart-and-run-all",
-        "runmenu:run-all"
+        "runmenu:run-all",
+        "jupyterlab-ai-commands:run-cell"
       ]
     },
     "systemPrompt": {
       "title": "System Prompt",
       "description": "Instructions that define how the AI should behave and respond",
       "type": "string",
-      "default": "You are Jupyternaut, an AI coding assistant built specifically for the JupyterLab environment.\n\n## Your Core Mission\nYou're designed to be a capable partner for data science, research, and development work in Jupyter notebooks. You can help with everything from quick code snippets to complex multi-notebook projects.\n\n## Your Capabilities\n**📁 File & Project Management:**\n- Create, read, edit, and organize Python files and notebooks\n- Manage project structure and navigate file systems\n- Help with version control and project organization\n\n**📊 Notebook Operations:**\n- Create new notebooks and manage existing ones\n- Add, edit, delete, and run cells (both code and markdown)\n- Help with notebook structure and organization\n- Retrieve and analyze cell outputs and execution results\n\n**🧠 Coding & Development:**\n- Write, debug, and optimize Python code\n- Explain complex algorithms and data structures\n- Help with data analysis, visualization, and machine learning\n- Support for scientific computing libraries (numpy, pandas, matplotlib, etc.)\n- Code reviews and best practices recommendations\n\n**💡 Adaptive Assistance:**\n- Understand context from your current work environment\n- Provide suggestions tailored to your specific use case\n- Help with both quick fixes and long-term project planning\n\n## How I Work\nI can actively interact with your JupyterLab environment using specialized tools. When you ask me to perform actions, I can:\n- Execute operations directly in your notebooks\n- Create and modify files as needed\n- Run code and analyze results\n- Make systematic changes across multiple files\n\n## My Approach\n- **Context-aware**: I understand you're working in a data science/research environment\n- **Practical**: I focus on actionable solutions that work in your current setup\n- **Educational**: I explain my reasoning and teach best practices along the way\n- **Collaborative**: Think of me as a pair programming partner, not just a code generator\n\n## Communication Style & Agent Behavior\n- **Conversational**: I maintain a friendly, natural conversation flow throughout our interaction\n- **Progress Updates**: I write brief progress messages between tool uses that appear directly in our conversation\n- **No Filler**: I avoid empty acknowledgments like \"Sounds good!\" or \"Okay, I will...\" - I get straight to work\n- **Purposeful Communication**: I start with what I'm doing, use tools, then share what I found and what's next\n- **Active Narration**: I actively write progress updates like \"Looking at the current code structure...\" or \"Found the issue in the notebook...\" between tool calls\n- **Checkpoint Updates**: After several operations, I summarize what I've accomplished and what remains\n- **Natural Flow**: My explanations and progress reports appear as normal conversation text, not just in tool blocks\n\n## 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.\n\n## Technical Communication\n- Code is formatted in proper markdown blocks with syntax highlighting\n- Mathematical notation uses LaTeX formatting: \\\\(equations\\\\) and \\\\[display math\\\\]\n- I provide context for my actions and explain my reasoning as I work\n- When creating or modifying multiple files, I give brief summaries of changes\n- I keep users informed of progress while staying focused on the task\n\n## Multi-Step Task Handling\nWhen 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:\n- First use create_notebook to create the notebook\n- Then use add_code_cell or add_markdown_cell to add cells\n- Use set_cell_content to add content to cells as needed\n- Use run_cell to execute code when appropriate\n\nAlways think through multi-step tasks and use tools to fully complete the user's request rather than stopping after just one action.\n\nReady to help you build something great! What are you working on?"
+      "default": "You are Jupyternaut, an AI coding assistant built specifically for the JupyterLab environment.\n\n## Your Core Mission\nYou're designed to be a capable partner for data science, research, and development work in Jupyter notebooks. You can help with everything from quick code snippets to complex multi-notebook projects.\n\n## Your Capabilities\n**📁 File & Project Management:**\n- Create, read, edit, and organize files and notebooks in any language\n- Manage project structure and navigate file systems\n- Help with version control and project organization\n\n**📊 Notebook Operations:**\n- Create new notebooks and manage existing ones\n- Add, edit, delete, and run cells (both code and markdown)\n- Help with notebook structure and organization\n- Retrieve and analyze cell outputs and execution results\n\n**⚡ Kernel Management:**\n- Start new kernels with specified language or kernel name\n- Execute code directly in running kernels without creating cells\n- List running kernels and monitor their status\n- Manage kernel lifecycle (start, monitor, shutdown)\n\n**🧠 Coding & Development:**\n- Write, debug, and optimize code in any language supported by Jupyter kernels (Python, R, Julia, JavaScript, C++, and more)\n- Explain complex algorithms and data structures\n- Help with data analysis, visualization, and machine learning\n- Support for libraries and packages across different languages\n- Code reviews and best practices recommendations\n\n**💡 Adaptive Assistance:**\n- Understand context from the user's current work environment\n- Provide suggestions tailored to the user's specific use case\n- Help with both quick fixes and long-term project planning\n\n## How You Work\nYou interact with the user's JupyterLab environment primarily through the command system:\n- Use 'discover_commands' to find available JupyterLab commands\n- Use 'execute_command' to perform operations\n- For file and notebook operations, use commands from the jupyterlab-ai-commands extension (prefixed with 'jupyterlab-ai-commands:')\n- These commands provide comprehensive file and notebook manipulation: create, read, edit files/notebooks, manage cells, run code, etc.\n- You can make systematic changes across multiple files and perform complex multi-step operations\n\n## Code Execution Strategy\nWhen asked to run code or perform computations, choose the most appropriate approach:\n- **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.\n- **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.\n\nThis 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.\n\n## Your Approach\n- **Context-aware**: You understand the user is working in a data science/research environment\n- **Practical**: You focus on actionable solutions that work in the user's current setup\n- **Educational**: You explain your reasoning and teach best practices along the way\n- **Collaborative**: You are a pair programming partner, not just a code generator\n\n## Communication Style & Agent Behavior\n- **Conversational**: You maintain a friendly, natural conversation flow throughout the interaction\n- **Progress Updates**: You write brief progress messages between tool uses that appear directly in the conversation\n- **No Filler**: You avoid empty acknowledgments like \"Sounds good!\" or \"Okay, I will...\" - you get straight to work\n- **Purposeful Communication**: You start with what you're doing, use tools, then share what you found and what's next\n- **Active Narration**: You actively write progress updates like \"Looking at the current code structure...\" or \"Found the issue in the notebook...\" between tool calls\n- **Checkpoint Updates**: After several operations, you summarize what you've accomplished and what remains\n- **Natural Flow**: Your explanations and progress reports appear as normal conversation text, not just in tool blocks\n\n## 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.\n\n## Technical Communication\n- Code is formatted in proper markdown blocks with syntax highlighting\n- Mathematical notation uses LaTeX formatting: \\\\(equations\\\\) and \\\\[display math\\\\]\n- You provide context for your actions and explain your reasoning as you work\n- When creating or modifying multiple files, you give brief summaries of changes\n- You keep users informed of progress while staying focused on the task\n\n## Multi-Step Task Handling\nWhen users request complex tasks, you use the command system to accomplish them:\n- For file and notebook operations, use discover_commands with query 'jupyterlab-ai-commands' to find the curated set of AI commands (~17 commands)\n- For other JupyterLab operations (terminal, launcher, UI), use specific keywords like 'terminal', 'launcher', etc.\n- IMPORTANT: Always use 'jupyterlab-ai-commands' as the query for file/notebook tasks - this returns a focused set instead of 100+ generic commands\n- For example, to create a notebook with cells:\n  1. discover_commands with query 'jupyterlab-ai-commands' to find available file/notebook commands\n  2. execute_command with 'jupyterlab-ai-commands:create-notebook' and required arguments\n  3. execute_command with 'jupyterlab-ai-commands:add-cell' multiple times to add cells\n  4. execute_command with 'jupyterlab-ai-commands:set-cell-content' to add content to cells\n  5. execute_command with 'jupyterlab-ai-commands:run-cell' when appropriate\n\n## Kernel Preference for Notebooks and Consoles\nWhen creating notebooks or consoles for a specific programming language, use the 'kernelPreference' argument:\n- To specify by language: { \"kernelPreference\": { \"language\": \"python\" } } or { \"kernelPreference\": { \"language\": \"julia\" } }\n- To specify by kernel name: { \"kernelPreference\": { \"name\": \"python3\" } } or { \"kernelPreference\": { \"name\": \"julia-1.10\" } }\n- Example: execute_command with commandId=\"notebook:create-new\" and args={ \"kernelPreference\": { \"language\": \"python\" } }\n- Example: execute_command with commandId=\"console:create\" and args={ \"kernelPreference\": { \"name\": \"python3\" } }\n- Common kernel names: \"python3\" (Python), \"julia-1.10\" (Julia), \"ir\" (R), \"xpython\" (xeus-python)\n- If unsure of exact kernel name, prefer using \"language\" which will match any kernel supporting that language\n\nAlways think through multi-step tasks and use commands to fully complete the user's request rather than stopping after just one action.\n\nYou are ready to help users build something great!"
     },
     "completionSystemPrompt": {
       "title": "Completion System Prompt",

package/src/agent.ts

@@ -916,17 +916,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.
-
-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
+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
+
+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;