@jupyterlite/ai 0.8.1 → 0.9.0-a0

package/lib/index.js

@@ -1,83 +1,145 @@
-import { ActiveCellManager, buildChatSidebar, buildErrorWidget, ChatCommandRegistry, IChatCommandRegistry, InputToolbarRegistry } from '@jupyter/chat';
-import { ILayoutRestorer } from '@jupyterlab/application';
-import { IThemeManager } from '@jupyterlab/apputils';
+import { ILabShell, ILayoutRestorer } from '@jupyterlab/application';
+import { ActiveCellManager, AttachmentOpenerRegistry, ChatWidget, InputToolbarRegistry } from '@jupyter/chat';
+import { ICommandPalette, IThemeManager } from '@jupyterlab/apputils';
 import { ICompletionProviderManager } from '@jupyterlab/completer';
+import { IDocumentManager } from '@jupyterlab/docmanager';
 import { INotebookTracker } from '@jupyterlab/notebook';
 import { IRenderMimeRegistry } from '@jupyterlab/rendermime';
+import { IKernelSpecManager } from '@jupyterlab/services';
 import { ISettingRegistry } from '@jupyterlab/settingregistry';
-import { IFormRendererRegistry } from '@jupyterlab/ui-components';
-import { ISecretsManager, SecretsManager } from 'jupyter-secrets-manager';
-import { ChatHandler, welcomeMessage } from './chat-handler';
-import { CompletionProvider } from './completion-provider';
-import { defaultProviderPlugins } from './default-providers';
-import { AIProviderRegistry } from './provider';
-import { aiSettingsRenderer, textArea } from './settings';
-import { IAIProviderRegistry, PLUGIN_IDS } from './tokens';
+import { settingsIcon } from '@jupyterlab/ui-components';
+import { AgentManager } from './agent';
+import { AIChatModel } from './chat-model';
+import { ChatProviderRegistry, CompletionProviderRegistry } from './providers/provider-registry';
+import { IChatProviderRegistry, ICompletionProviderRegistry, IAISettingsModel, IToolRegistry } from './tokens';
+import { registerBuiltInChatProviders, registerBuiltInCompletionProviders } from './providers/built-in-providers';
+import { AICompletionProvider } from './completion';
+import { clearItem } from './components/clear-button';
+import { createModelSelectItem } from './components/model-select';
 import { stopItem } from './components/stop-button';
-const chatCommandRegistryPlugin = {
-    id: PLUGIN_IDS.chatCommandRegistry,
-    description: 'Autocompletion registry',
+import { createToolSelectItem } from './components/tool-select';
+import { AISettingsModel } from './models/settings-model';
+import { ToolRegistry } from './tools/tool-registry';
+import { createAddCellTool, createDeleteCellTool, createExecuteActiveCellTool, createGetCellInfoTool, createGetNotebookInfoTool, createNotebookCreationTool, createRunCellTool, createSaveNotebookTool, createSetCellContentTool } from './tools/notebook';
+import { createCopyFileTool, createDeleteFileTool, createNavigateToDirectoryTool, createNewFileTool, createOpenFileTool, createRenameFileTool } from './tools/file';
+import { createDiscoverCommandsTool, createExecuteCommandTool } from './tools/commands';
+import { AISettingsWidget } from './widgets/ai-settings';
+import { ChatWrapperWidget } from './widgets/chat-wrapper';
+/**
+ * Command IDs namespace
+ */
+var CommandIds;
+(function (CommandIds) {
+    CommandIds.openSettings = '@jupyterlite/ai:open-settings';
+    CommandIds.reposition = '@jupyterlite/ai:reposition';
+})(CommandIds || (CommandIds = {}));
+/**
+ * Chat provider registry plugin
+ */
+const chatProviderRegistryPlugin = {
+    id: '@jupyterlite/ai:chat-provider-registry',
+    description: 'Chat AI provider registry',
     autoStart: true,
-    provides: IChatCommandRegistry,
+    provides: IChatProviderRegistry,
     activate: () => {
-        const registry = new ChatCommandRegistry();
-        registry.addProvider(new ChatHandler.ClearCommandProvider());
-        return registry;
+        return new ChatProviderRegistry();
     }
 };
-const chatPlugin = {
-    id: PLUGIN_IDS.chat,
-    description: 'LLM chat extension',
+/**
+ * Completion provider registry plugin
+ */
+const completionProviderRegistryPlugin = {
+    id: '@jupyterlite/ai:completion-provider-registry',
+    description: 'Completion provider registry',
     autoStart: true,
-    requires: [IAIProviderRegistry, IRenderMimeRegistry, IChatCommandRegistry],
+    provides: ICompletionProviderRegistry,
+    activate: () => {
+        return new CompletionProviderRegistry();
+    }
+};
+/**
+ * Built-in chat providers plugin
+ */
+const builtInChatProvidersPlugin = {
+    id: '@jupyterlite/ai:built-in-chat-providers',
+    description: 'Register built-in chat AI providers',
+    autoStart: true,
+    requires: [IChatProviderRegistry],
+    activate: (app, chatRegistry) => {
+        registerBuiltInChatProviders(chatRegistry);
+    }
+};
+/**
+ * Built-in completion providers plugin
+ */
+const builtInCompletionProvidersPlugin = {
+    id: '@jupyterlite/ai:built-in-completion-providers',
+    description: 'Register built-in completion providers',
+    autoStart: true,
+    requires: [ICompletionProviderRegistry],
+    activate: (app, completionRegistry) => {
+        registerBuiltInCompletionProviders(completionRegistry);
+    }
+};
+/**
+ * Initialization data for the extension.
+ */
+const plugin = {
+    id: '@jupyterlite/ai:plugin',
+    description: 'AI in JupyterLab',
+    autoStart: true,
+    requires: [
+        IAISettingsModel,
+        IToolRegistry,
+        IRenderMimeRegistry,
+        IDocumentManager,
+        IChatProviderRegistry
+    ],
     optional: [
-        INotebookTracker,
-        ISettingRegistry,
         IThemeManager,
-        ILayoutRestorer
+        ICommandPalette,
+        INotebookTracker,
+        ILayoutRestorer,
+        ILabShell
     ],
-    activate: async (app, providerRegistry, rmRegistry, chatCommandRegistry, notebookTracker, settingsRegistry, themeManager, restorer) => {
-        let activeCellManager = null;
+    activate: (app, settingsModel, toolRegistry, rmRegistry, docManager, chatProviderRegistry, themeManager, palette, notebookTracker, restorer, labShell) => {
+        // Create ActiveCellManager if notebook tracker is available
+        let activeCellManager;
         if (notebookTracker) {
             activeCellManager = new ActiveCellManager({
                 tracker: notebookTracker,
                 shell: app.shell
             });
         }
-        const chatHandler = new ChatHandler({
-            providerRegistry,
-            activeCellManager
+        // Create Agent Manager first so it can be shared
+        const agentManager = new AgentManager({
+            settingsModel,
+            toolRegistry,
+            chatProviderRegistry: chatProviderRegistry
         });
-        let sendWithShiftEnter = false;
-        let enableCodeToolbar = true;
-        let personaName = 'AI';
-        function loadSetting(setting) {
-            sendWithShiftEnter = setting.get('sendWithShiftEnter')
-                .composite;
-            enableCodeToolbar = setting.get('enableCodeToolbar').composite;
-            personaName = setting.get('personaName').composite;
-            // set the properties
-            chatHandler.config = { sendWithShiftEnter, enableCodeToolbar };
-            chatHandler.personaName = personaName;
-        }
-        Promise.all([app.restored, settingsRegistry?.load(chatPlugin.id)])
-            .then(([, settings]) => {
-            if (!settings) {
-                console.warn('The SettingsRegistry is not loaded for the chat extension');
-                return;
-            }
-            loadSetting(settings);
-            settings.changed.connect(loadSetting);
-        })
-            .catch(reason => {
-            console.error(`Something went wrong when reading the settings.\n${reason}`);
+        // Create AI chat model
+        const chatModel = new AIChatModel({
+            user: { username: 'user', display_name: 'User' },
+            settingsModel,
+            agentManager,
+            activeCellManager,
+            documentManager: docManager
         });
-        let chatWidget = null;
+        // Create input toolbar registry with all buttons
         const inputToolbarRegistry = InputToolbarRegistry.defaultToolbarRegistry();
-        const stopButton = stopItem(() => chatHandler.stopStreaming());
+        const stopButton = stopItem();
+        const clearButton = clearItem();
+        const toolSelectButton = createToolSelectItem(toolRegistry, settingsModel.config.toolsEnabled);
+        const modelSelectButton = createModelSelectItem(settingsModel);
         inputToolbarRegistry.addItem('stop', stopButton);
-        chatHandler.writersChanged.connect((_, writers) => {
-            if (writers.filter(writer => writer.user.username === chatHandler.personaName).length) {
+        inputToolbarRegistry.addItem('clear', clearButton);
+        inputToolbarRegistry.addItem('model', modelSelectButton);
+        inputToolbarRegistry.addItem('tools', toolSelectButton);
+        // Listen to writers changes to show/hide stop button
+        chatModel.writersChanged.connect((_, writers) => {
+            // Check if AI is currently writing (streaming)
+            const aiWriting = writers.some(writer => writer.user.username === 'ai-assistant');
+            if (aiWriting) {
                 inputToolbarRegistry.hide('send');
                 inputToolbarRegistry.show('stop');
             }
@@ -86,131 +148,224 @@ const chatPlugin = {
                 inputToolbarRegistry.show('send');
             }
         });
-        try {
-            chatWidget = buildChatSidebar({
-                model: chatHandler,
-                themeManager,
-                rmRegistry,
-                chatCommandRegistry,
-                inputToolbarRegistry,
-                welcomeMessage: welcomeMessage(providerRegistry.providers)
-            });
-        }
-        catch (e) {
-            chatWidget = buildErrorWidget(themeManager);
-        }
-        chatWidget.title.caption = 'Jupyterlite AI Chat';
-        chatWidget.id = '@jupyterlite/ai:chat-widget';
-        app.shell.add(chatWidget, 'left', { rank: 2000 });
+        // Listen for settings changes to update tool availability
+        settingsModel.stateChanged.connect(() => {
+            const config = settingsModel.config;
+            if (!config.toolsEnabled) {
+                inputToolbarRegistry.hide('tools');
+            }
+            else {
+                inputToolbarRegistry.show('tools');
+            }
+        });
+        // Create attachment opener registry to handle file attachments
+        const attachmentOpenerRegistry = new AttachmentOpenerRegistry();
+        attachmentOpenerRegistry.set('file', attachment => {
+            app.commands.execute('docmanager:open', { path: attachment.value });
+        });
+        attachmentOpenerRegistry.set('notebook', attachment => {
+            app.commands.execute('docmanager:open', { path: attachment.value });
+        });
+        // Create chat panel with drag/drop functionality
+        const chatPanel = new ChatWidget({
+            model: chatModel,
+            rmRegistry,
+            themeManager,
+            inputToolbarRegistry,
+            attachmentOpenerRegistry
+        });
+        // Create wrapper widget with a toolbar
+        const chatWrapper = new ChatWrapperWidget({
+            chatPanel,
+            commands: app.commands,
+            chatModel,
+            settingsModel
+        });
+        app.shell.add(chatWrapper, 'left', { rank: 1000 });
+        const settingsWidget = new AISettingsWidget({
+            settingsModel,
+            agentManager,
+            themeManager,
+            chatProviderRegistry
+        });
+        settingsWidget.id = 'jupyterlite-ai-settings';
+        settingsWidget.title.icon = settingsIcon;
         if (restorer) {
-            restorer.add(chatWidget, chatWidget.id);
+            restorer.add(chatWrapper, chatWrapper.id);
+            restorer.add(settingsWidget, settingsWidget.id);
         }
+        registerCommands(app, palette, settingsWidget, labShell);
     }
 };
-const completerPlugin = {
-    id: PLUGIN_IDS.completer,
-    autoStart: true,
-    requires: [IAIProviderRegistry, ICompletionProviderManager],
-    activate: (app, providerRegistry, manager) => {
-        const completer = new CompletionProvider({
-            providerRegistry,
-            requestCompletion: () => app.commands.execute('inline-completer:invoke')
-        });
-        manager.registerInlineProvider(completer);
-    }
-};
-const providerRegistryPlugin = SecretsManager.sign(PLUGIN_IDS.providerRegistry, token => ({
-    id: PLUGIN_IDS.providerRegistry,
-    autoStart: true,
-    requires: [IFormRendererRegistry, ISettingRegistry],
-    optional: [IRenderMimeRegistry, ISecretsManager],
-    provides: IAIProviderRegistry,
-    activate: (app, editorRegistry, settingRegistry, rmRegistry, secretsManager) => {
-        const providerRegistry = new AIProviderRegistry({
-            token,
-            secretsManager
-        });
-        editorRegistry.addRenderer(`${PLUGIN_IDS.providerRegistry}.AIproviders`, aiSettingsRenderer({
-            providerRegistry,
-            secretsToken: token,
-            rmRegistry,
-            secretsManager
-        }));
-        settingRegistry
-            .load(providerRegistryPlugin.id)
-            .then(settings => {
-            if (!secretsManager) {
-                delete settings.schema.properties?.['UseSecretsManager'];
+function registerCommands(app, palette, settingsWidget, labShell) {
+    const { commands } = app;
+    commands.addCommand(CommandIds.openSettings, {
+        label: 'AI Settings',
+        caption: 'Configure AI providers and behavior',
+        icon: settingsIcon,
+        execute: () => {
+            // Check if the widget already exists in shell
+            let widget = Array.from(app.shell.widgets('main')).find(w => w.id === 'jupyterlite-ai-settings');
+            if (!widget && settingsWidget) {
+                // Use the pre-created widget
+                widget = settingsWidget;
+                app.shell.add(widget, 'main');
+            }
+            if (widget) {
+                app.shell.activateById(widget.id);
             }
-            const updateProvider = () => {
-                // Get the Ai provider settings.
-                const providerSettings = settings.get('AIproviders')
-                    .composite;
-                // Update completer provider.
-                if (Object.keys(providerSettings).includes('completer')) {
-                    providerRegistry.setCompleterProvider(providerSettings['completer']);
+        },
+        describedBy: {
+            args: {}
+        }
+    });
+    if (labShell) {
+        commands.addCommand(CommandIds.reposition, {
+            label: 'Reposition Widget',
+            execute: (args) => {
+                const { widgetId, area, mode } = args;
+                const widget = widgetId
+                    ? Array.from(labShell.widgets('main')).find(w => w.id === widgetId) ||
+                        labShell.currentWidget
+                    : labShell.currentWidget;
+                if (!widget) {
+                    return;
                 }
-                else {
-                    providerRegistry.setCompleterProvider({});
+                if (area && area !== 'main') {
+                    // Move to different area
+                    labShell.move(widget, area);
+                    labShell.activateById(widget.id);
                 }
-                // Update chat provider.
-                if (Object.keys(providerSettings).includes('chat')) {
-                    providerRegistry.setChatProvider(providerSettings['chat']);
+                else if (mode) {
+                    // Reposition within main area using split mode
+                    labShell.add(widget, 'main', { mode, activate: true });
                 }
-                else {
-                    providerRegistry.setChatProvider({});
+            },
+            describedBy: {
+                args: {
+                    type: 'object',
+                    properties: {
+                        widgetId: {
+                            type: 'string',
+                            description: 'The widget ID to reposition in the application shell'
+                        },
+                        area: {
+                            type: 'string',
+                            description: 'The name of the area to reposition the widget to'
+                        },
+                        mode: {
+                            type: 'string',
+                            enum: ['split-left', 'split-right', 'split-top', 'split-bottom'],
+                            description: 'The mode to use when repositioning the widget'
+                        }
+                    }
                 }
-            };
-            settings.changed.connect(() => updateProvider());
-            updateProvider();
-        })
-            .catch(reason => {
-            console.error(`Failed to load settings for ${providerRegistryPlugin.id}`, reason);
+            }
+        });
+    }
+    // Add to command palette if available
+    if (palette) {
+        palette.addItem({
+            command: CommandIds.openSettings,
+            category: 'AI Assistant'
         });
-        return providerRegistry;
     }
-}));
-const systemPromptsPlugin = {
-    id: PLUGIN_IDS.systemPrompts,
+}
+/**
+ * A plugin to provide AI-powered code completion.
+ */
+const completionPlugin = {
+    id: '@jupyterlite/ai:completion',
+    description: 'AI-powered code completion',
     autoStart: true,
-    requires: [IAIProviderRegistry, ISettingRegistry],
-    optional: [IFormRendererRegistry],
-    activate: (app, providerRegistry, settingsRegistry, editorRegistry) => {
-        // Set textarea renderer for the prompt setting.
-        editorRegistry?.addRenderer(`${PLUGIN_IDS.systemPrompts}.chatSystemPrompt`, textArea);
-        editorRegistry?.addRenderer(`${PLUGIN_IDS.systemPrompts}.completionSystemPrompt`, textArea);
-        /**
-         * Update the prompts in the provider registry.
-         */
-        function loadSetting(setting) {
-            providerRegistry.chatSystemPrompt = setting.get('chatSystemPrompt')
-                .composite;
-            providerRegistry.completerSystemPrompt = setting.get('completionSystemPrompt').composite;
+    requires: [IAISettingsModel, ICompletionProviderRegistry],
+    optional: [ICompletionProviderManager],
+    activate: (app, settingsModel, completionProviderRegistry, manager) => {
+        if (!manager) {
+            console.info('Completion provider manager not available, skipping AI completion setup');
+            return;
         }
-        Promise.all([
-            app.restored,
-            settingsRegistry?.load(PLUGIN_IDS.systemPrompts)
-        ])
-            .then(([, settings]) => {
-            if (!settings) {
-                console.warn('The SettingsRegistry is not loaded for the chat extension');
-                return;
-            }
-            loadSetting(settings);
-            settings.changed.connect(loadSetting);
-        })
-            .catch(reason => {
-            console.error(`Something went wrong when reading the settings.\n${reason}`);
+        const completionProvider = new AICompletionProvider({
+            settingsModel,
+            completionProviderRegistry: completionProviderRegistry
         });
+        manager.registerInlineProvider(completionProvider);
+    }
+};
+/**
+ * A plugin to provide the settings model.
+ */
+const settingsModel = {
+    id: '@jupyterlite/ai:settings-model',
+    description: 'Provide the AI settings model',
+    autoStart: true,
+    provides: IAISettingsModel,
+    requires: [ISettingRegistry],
+    activate: (app, settingRegistry) => {
+        return new AISettingsModel({ settingRegistry });
+    }
+};
+/**
+ * A plugin to provide the tool registry.
+ */
+const toolRegistry = {
+    id: '@jupyterlite/ai:tool-registry',
+    description: 'Provide the AI tool registry',
+    autoStart: true,
+    requires: [IAISettingsModel, IDocumentManager, IKernelSpecManager],
+    optional: [INotebookTracker],
+    provides: IToolRegistry,
+    activate: (app, settingsModel, docManager, kernelSpecManager, notebookTracker) => {
+        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);
+        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);
+        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);
+        // Add command operation tools
+        const discoverCommandsTool = createDiscoverCommandsTool(app.commands);
+        const executeCommandTool = createExecuteCommandTool(app.commands, settingsModel);
+        toolRegistry.add('discover_commands', discoverCommandsTool);
+        toolRegistry.add('execute_command', executeCommandTool);
+        return toolRegistry;
     }
 };
 export default [
-    providerRegistryPlugin,
-    chatCommandRegistryPlugin,
-    chatPlugin,
-    completerPlugin,
-    systemPromptsPlugin,
-    ...defaultProviderPlugins
+    chatProviderRegistryPlugin,
+    completionProviderRegistryPlugin,
+    builtInChatProvidersPlugin,
+    builtInCompletionProvidersPlugin,
+    plugin,
+    completionPlugin,
+    settingsModel,
+    toolRegistry
 ];
-export { IAIProviderRegistry } from './tokens';
-export * from './base-completer';
+// Export extension points for other extensions to use
+export * from './tokens';

package/lib/mcp/browser.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Browser-compatible MCP Server implementation
+ *
+ * This is a custom implementation that works around the limitation in
+ * @openai/agents where MCPServerStreamableHttp doesn't work in browsers
+ */
+interface MCPServer {
+    cacheToolsList: boolean;
+    toolFilter?: any;
+    connect(): Promise<void>;
+    readonly name: string;
+    close(): Promise<void>;
+    listTools(): Promise<MCPTool[]>;
+    callTool(toolName: string, args: Record<string, unknown> | null): Promise<CallToolResultContent>;
+    invalidateToolsCache(): Promise<void>;
+}
+interface MCPTool {
+    name: string;
+    description?: string;
+    inputSchema: {
+        type: 'object';
+        properties: Record<string, any>;
+        required: string[];
+        additionalProperties: boolean;
+    };
+}
+type CallToolResultContent = Array<{
+    type: string;
+    text: string;
+}>;
+interface MCPServerStreamableHttpOptions {
+    url: string;
+    cacheToolsList?: boolean;
+    clientSessionTimeoutSeconds?: number;
+    name?: string;
+    logger?: any;
+    toolFilter?: any;
+    timeout?: number;
+    authProvider?: any;
+    requestInit?: any;
+    fetch?: any;
+    reconnectionOptions?: any;
+    sessionId?: string;
+}
+/**
+ * Browser-compatible MCP Server implementation that works around limitations
+ * in @openai/agents where MCPServerStreamableHttp doesn't work in browsers.
+ *
+ * This class provides a streamable HTTP client transport for MCP (Model Context Protocol)
+ * servers that can be used in browser environments.
+ */
+export declare class BrowserMCPServerStreamableHttp implements MCPServer {
+    readonly name: string;
+    readonly cacheToolsList: boolean;
+    readonly toolFilter: any;
+    constructor(options: MCPServerStreamableHttpOptions);
+    connect(): Promise<void>;
+    close(): Promise<void>;
+    listTools(): Promise<MCPTool[]>;
+    callTool(toolName: string, args: Record<string, unknown> | null): Promise<CallToolResultContent>;
+    invalidateToolsCache(): Promise<void>;
+    private _session;
+    private _toolsList;
+    private _cacheDirty;
+    private _transport;
+    private _options;
+}
+export {};