@jupyterlite/ai 0.9.0-a3 → 0.9.0

package/lib/components/model-select.js

@@ -2,7 +2,6 @@ import { TooltippedButton } from '@jupyter/chat';
 import CheckIcon from '@mui/icons-material/Check';
 import { Menu, MenuItem, Typography } from '@mui/material';
 import React, { useCallback, useEffect, useState } from 'react';
-const SELECT_ITEM_CLASS = 'labai-model-select-item';
 /**
  * The model select component for choosing AI models.
  */
@@ -114,7 +113,7 @@ export function ModelSelect(props) {
                     paddingRight: '2em',
                     minWidth: '200px'
                 }
-            } }, availableModels.map(({ provider, providerLabel, isSelected }) => (React.createElement(MenuItem, { key: provider, className: SELECT_ITEM_CLASS, onClick: async (e) => {
+            } }, availableModels.map(({ provider, providerLabel, isSelected }) => (React.createElement(MenuItem, { key: provider, onClick: async (e) => {
                 await selectModel(provider);
                 // Prevent sending message on model selection
                 e.stopPropagation();

package/lib/diff-manager.d.ts

@@ -0,0 +1,25 @@
+import { CommandRegistry } from '@lumino/commands';
+import { AISettingsModel } from './models/settings-model';
+import { IDiffManager, IShowCellDiffParams, IShowFileDiffParams } from './tokens';
+/**
+ * Implementation of the diff manager
+ */
+export declare class DiffManager implements IDiffManager {
+    /**
+     * Construct a new DiffManager
+     */
+    constructor(options: {
+        commands: CommandRegistry;
+        settingsModel: AISettingsModel;
+    });
+    /**
+     * Show diff between original and modified cell content
+     */
+    showCellDiff(params: IShowCellDiffParams): Promise<void>;
+    /**
+     * Show diff between original and modified file content
+     */
+    showFileDiff(params: IShowFileDiffParams): Promise<void>;
+    private _commands;
+    private _settingsModel;
+}

package/lib/diff-manager.js

@@ -0,0 +1,60 @@
+/**
+ * Command IDs for unified cell diffs
+ */
+const UNIFIED_DIFF_COMMAND_ID = 'jupyterlab-diff:unified-cell-diff';
+/**
+ * Command IDs for split cell diffs
+ */
+const SPLIT_DIFF_COMMAND_ID = 'jupyterlab-diff:split-cell-diff';
+/**
+ * Command ID for unified file diffs
+ */
+const UNIFIED_FILE_DIFF_COMMAND_ID = 'jupyterlab-diff:unified-file-diff';
+/**
+ * Implementation of the diff manager
+ */
+export class DiffManager {
+    /**
+     * Construct a new DiffManager
+     */
+    constructor(options) {
+        this._commands = options.commands;
+        this._settingsModel = options.settingsModel;
+    }
+    /**
+     * Show diff between original and modified cell content
+     */
+    async showCellDiff(params) {
+        if (!this._settingsModel.config.showCellDiff) {
+            return;
+        }
+        const showDiffCommandId = this._settingsModel.config.diffDisplayMode === 'unified'
+            ? UNIFIED_DIFF_COMMAND_ID
+            : SPLIT_DIFF_COMMAND_ID;
+        await this._commands.execute(showDiffCommandId, {
+            originalSource: params.original,
+            newSource: params.modified,
+            cellId: params.cellId,
+            showActionButtons: params.showActionButtons ?? true,
+            openDiff: params.openDiff ?? true,
+            notebookPath: params.notebookPath
+        });
+    }
+    /**
+     * Show diff between original and modified file content
+     */
+    async showFileDiff(params) {
+        if (!this._settingsModel.config.showFileDiff) {
+            return;
+        }
+        // File diffs only support unified view
+        await this._commands.execute(UNIFIED_FILE_DIFF_COMMAND_ID, {
+            originalSource: params.original,
+            newSource: params.modified,
+            filePath: params.filePath,
+            showActionButtons: params.showActionButtons ?? true
+        });
+    }
+    _commands;
+    _settingsModel;
+}

package/lib/icons.d.ts

@@ -1,4 +1,3 @@
 import { LabIcon } from '@jupyterlab/ui-components';
-export declare const labaiIcon: LabIcon;
 export declare const jupyternautIcon: LabIcon;
 export declare const AI_AVATAR: string;

package/lib/icons.js

@@ -1,12 +1,8 @@
 import { LabIcon } from '@jupyterlab/ui-components';
-import labaiIconSvg from '../style/icons/jupyternaut-lite.svg';
-export const labaiIcon = new LabIcon({
-    name: '@jupyterlite/ai:icon',
-    svgstr: labaiIconSvg
-});
+import jupyternautSvg from '../style/icons/jupyternaut-lite.svg';
 export const jupyternautIcon = new LabIcon({
     name: '@jupyterlite/ai:jupyternaut',
-    svgstr: labaiIconSvg
+    svgstr: jupyternautSvg
 });
 const AI_AVATAR_BASE64 = btoa(jupyternautIcon.svgstr);
 export const AI_AVATAR = `data:image/svg+xml;base64,${AI_AVATAR_BASE64}`;

package/lib/index.d.ts

@@ -1,8 +1,8 @@
 import { JupyterFrontEndPlugin } from '@jupyterlab/application';
 import { IInputToolbarRegistryFactory } from '@jupyter/chat';
 import { AgentManagerFactory } from './agent';
-import { IProviderRegistry, IToolRegistry, IChatModelRegistry } from './tokens';
+import { IProviderRegistry, IToolRegistry, IChatModelRegistry, IDiffManager } from './tokens';
 import { AISettingsModel } from './models/settings-model';
-declare const _default: (JupyterFrontEndPlugin<IProviderRegistry> | JupyterFrontEndPlugin<void> | JupyterFrontEndPlugin<IChatModelRegistry> | JupyterFrontEndPlugin<AgentManagerFactory> | JupyterFrontEndPlugin<AISettingsModel> | JupyterFrontEndPlugin<IToolRegistry> | JupyterFrontEndPlugin<IInputToolbarRegistryFactory>)[];
+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';

package/lib/index.js

@@ -3,10 +3,12 @@ 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 { settingsIcon, Toolbar, ToolbarButton } from '@jupyterlab/ui-components';
 import { ISecretsManager, SecretsManager } from 'jupyter-secrets-manager';
 import { PromiseDelegate, UUID } from '@lumino/coreutils';
@@ -14,14 +16,15 @@ import { AgentManagerFactory } from './agent';
 import { ProviderRegistry } from './providers/provider-registry';
 import { ApprovalButtons } from './approval-buttons';
 import { ChatModelRegistry } from './chat-model-registry';
-import { CommandIds, IAgentManagerFactory, IProviderRegistry, IToolRegistry, SECRETS_NAMESPACE, IAISettingsModel, IChatModelRegistry } from './tokens';
-import { anthropicProvider, googleProvider, mistralProvider, openaiProvider, ollamaProvider, genericProvider } from './providers/built-in-providers';
+import { CommandIds, IAgentManagerFactory, IProviderRegistry, IToolRegistry, SECRETS_NAMESPACE, IAISettingsModel, IChatModelRegistry, IDiffManager } from './tokens';
+import { anthropicProvider, googleProvider, mistralProvider, openaiProvider, genericProvider } from './providers/built-in-providers';
 import { AICompletionProvider } from './completion';
-import { clearItem, createModelSelectItem, createToolSelectItem, stopItem, TokenUsageWidget } from './components';
+import { clearItem, createModelSelectItem, createToolSelectItem, stopItem, CompletionStatusWidget, TokenUsageWidget } from './components';
 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, createNavigateToDirectoryTool, createNewFileTool, createOpenFileTool, createRenameFileTool } from './tools/file';
+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';
@@ -85,18 +88,6 @@ const openaiProviderPlugin = {
         providerRegistry.registerProvider(openaiProvider);
     }
 };
-/**
- * Ollama provider plugin
- */
-const ollamaProviderPlugin = {
-    id: '@jupyterlite/ai:ollama-provider',
-    description: 'Register Ollama provider',
-    autoStart: true,
-    requires: [IProviderRegistry],
-    activate: (app, providerRegistry) => {
-        providerRegistry.registerProvider(ollamaProvider);
-    }
-};
 /**
  * Generic provider plugin
  */
@@ -478,6 +469,7 @@ const agentManagerFactory = SecretsManager.sign(SECRETS_NAMESPACE, token => ({
         });
         settingsWidget.id = 'jupyterlite-ai-settings';
         settingsWidget.title.icon = settingsIcon;
+        settingsWidget.title.iconClass = 'jp-ai-settings-icon';
         // Build the completion provider
         if (completionManager) {
             const completionProvider = new AICompletionProvider({
@@ -498,6 +490,7 @@ const agentManagerFactory = SecretsManager.sign(SECRETS_NAMESPACE, token => ({
             label: 'AI Settings',
             caption: 'Configure AI providers and behavior',
             icon: settingsIcon,
+            iconClass: 'jp-ai-settings-icon',
             execute: () => {
                 // Check if the widget already exists in shell
                 let widget = Array.from(app.shell.widgets('main')).find(w => w.id === 'jupyterlite-ai-settings');
@@ -537,15 +530,30 @@ const settingsModel = {
         return new AISettingsModel({ settingRegistry });
     }
 };
+/**
+ * Diff manager plugin
+ */
+const diffManager = {
+    id: '@jupyterlite/ai:diff-manager',
+    description: 'Provide the diff manager for notebook cell diffs',
+    autoStart: true,
+    provides: IDiffManager,
+    requires: [IAISettingsModel],
+    activate: (app, settingsModel) => {
+        return new DiffManager({
+            commands: app.commands,
+            settingsModel
+        });
+    }
+};
 const toolRegistry = {
     id: '@jupyterlite/ai:tool-registry',
     description: 'Provide the AI tool registry',
     autoStart: true,
     requires: [IAISettingsModel, IDocumentManager, IKernelSpecManager],
-    optional: [INotebookTracker],
+    optional: [INotebookTracker, IDiffManager, IEditorTracker],
     provides: IToolRegistry,
-    activate: (app, settingsModel, docManager, kernelSpecManager, notebookTracker) => {
-        const { commands } = app;
+    activate: (app, settingsModel, docManager, kernelSpecManager, notebookTracker, diffManager, editorTracker) => {
         const toolRegistry = new ToolRegistry();
         const notebookCreationTool = createNotebookCreationTool(docManager, kernelSpecManager);
         toolRegistry.add('create_notebook', notebookCreationTool);
@@ -553,7 +561,7 @@ const toolRegistry = {
         const addCellTool = createAddCellTool(docManager, notebookTracker);
         const getNotebookInfoTool = createGetNotebookInfoTool(docManager, notebookTracker);
         const getCellInfoTool = createGetCellInfoTool(docManager, notebookTracker);
-        const setCellContentTool = createSetCellContentTool(docManager, commands, notebookTracker);
+        const setCellContentTool = createSetCellContentTool(docManager, notebookTracker, diffManager);
         const runCellTool = createRunCellTool(docManager, notebookTracker);
         const deleteCellTool = createDeleteCellTool(docManager, notebookTracker);
         const saveNotebookTool = createSaveNotebookTool(docManager, notebookTracker);
@@ -573,12 +581,16 @@ const toolRegistry = {
         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);
@@ -591,7 +603,7 @@ const toolRegistry = {
  * Extension providing the input toolbar registry.
  */
 const inputToolbarFactory = {
-    id: 'labai:input-toolbar-factory',
+    id: '@jupyterlite/ai:input-toolbar-factory',
     description: 'The input toolbar registry plugin.',
     autoStart: true,
     provides: IInputToolbarRegistryFactory,
@@ -623,20 +635,39 @@ const inputToolbarFactory = {
         };
     }
 };
+const completionStatus = {
+    id: '@jupyterlite/ai:completion-status',
+    description: 'The completion status displayed in the status bar',
+    autoStart: true,
+    requires: [IAISettingsModel],
+    optional: [IStatusBar],
+    activate: (app, settingsModel, statusBar) => {
+        if (!statusBar) {
+            return;
+        }
+        const item = new CompletionStatusWidget({ settingsModel });
+        statusBar?.registerStatusItem('completionState', {
+            item,
+            align: 'right',
+            rank: 10
+        });
+    }
+};
 export default [
     providerRegistryPlugin,
     anthropicProviderPlugin,
     googleProviderPlugin,
     mistralProviderPlugin,
     openaiProviderPlugin,
-    ollamaProviderPlugin,
     genericProviderPlugin,
     settingsModel,
+    diffManager,
     chatModelRegistry,
     plugin,
     toolRegistry,
     agentManagerFactory,
-    inputToolbarFactory
+    inputToolbarFactory,
+    completionStatus
 ];
 // Export extension points for other extensions to use
 export * from './tokens';

package/lib/models/settings-model.d.ts

@@ -36,10 +36,14 @@ export interface IAIConfig {
     contextAwareness: boolean;
     codeExecution: boolean;
     systemPrompt: string;
+    completionSystemPrompt: string;
     toolsEnabled: boolean;
     sendWithShiftEnter: boolean;
     showTokenUsage: boolean;
     commandsRequiringApproval: string[];
+    showCellDiff: boolean;
+    showFileDiff: boolean;
+    diffDisplayMode: 'split' | 'unified';
 }
 export declare class AISettingsModel extends VDomModel {
     private _config;

package/lib/models/settings-model.js

@@ -13,6 +13,9 @@ export class AISettingsModel extends VDomModel {
         toolsEnabled: true,
         sendWithShiftEnter: false,
         showTokenUsage: false,
+        showCellDiff: true,
+        showFileDiff: true,
+        diffDisplayMode: 'split',
         commandsRequiringApproval: [
             'notebook:restart-run-all',
             'notebook:run-cell',
@@ -97,7 +100,18 @@ 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?`
+Ready to help you build something great! What are you working on?`,
+        // 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.
+Rules:
+- Return only the completion text, no explanations or comments
+- Do not include code block markers (\`\`\` or similar)
+- Make completions contextually relevant to the surrounding code and notebook context
+- Follow the language-specific conventions and style guidelines for the detected programming language
+- Keep completions concise but functional
+- Do not repeat the existing code that comes before the cursor
+- Use variables, imports, functions, and other definitions from previous notebook cells when relevant`
     };
     _settingRegistry;
     _settings = null;
@@ -152,7 +166,7 @@ Ready to help you build something great! What are you working on?`
         }
         return this._config.activeCompleterProvider
             ? this.getProvider(this._config.activeCompleterProvider)
-            : this.getDefaultProvider();
+            : undefined;
     }
     async addProvider(providerConfig) {
         const id = `${providerConfig.provider}-${Date.now()}`;
@@ -205,6 +219,11 @@ Ready to help you build something great! What are you working on?`
             return;
         }
         Object.assign(provider, updates);
+        Object.keys(provider).forEach(key => {
+            if (key !== 'id' && updates[key] === undefined) {
+                delete provider[key];
+            }
+        });
         await this.saveSetting('providers', this._config.providers);
     }
     async setActiveProvider(id) {
@@ -284,6 +303,9 @@ Ready to help you build something great! What are you working on?`
                 if (value !== undefined) {
                     await this._settings.set(key, value);
                 }
+                else {
+                    await this._settings.remove(key);
+                }
             }
         }
         catch (error) {

package/lib/providers/built-in-providers.d.ts

@@ -15,10 +15,6 @@ export declare const mistralProvider: IProviderInfo;
  * OpenAI provider
  */
 export declare const openaiProvider: IProviderInfo;
-/**
- * Ollama provider
- */
-export declare const ollamaProvider: IProviderInfo;
 /**
  * Generic OpenAI-compatible provider
  */

package/lib/providers/built-in-providers.js

@@ -2,7 +2,7 @@ import { createAnthropic } from '@ai-sdk/anthropic';
 import { createGoogleGenerativeAI } from '@ai-sdk/google';
 import { createMistral } from '@ai-sdk/mistral';
 import { createOpenAI } from '@ai-sdk/openai';
-import { createOllama } from 'ollama-ai-provider-v2';
+import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
 /**
  * Anthropic provider
  */
@@ -13,6 +13,8 @@ export const anthropicProvider = {
     defaultModels: [
         'claude-sonnet-4-5',
         'claude-sonnet-4-5-20250929',
+        'claude-haiku-4-5',
+        'claude-haiku-4-5-20251001',
         'claude-opus-4-1',
         'claude-opus-4-0',
         'claude-sonnet-4-0',
@@ -192,25 +194,6 @@ export const openaiProvider = {
         return openai(modelName);
     }
 };
-/**
- * Ollama provider
- */
-export const ollamaProvider = {
-    id: 'ollama',
-    name: 'Ollama',
-    apiKeyRequirement: 'none',
-    defaultModels: [],
-    supportsBaseURL: true,
-    supportsHeaders: true,
-    factory: (options) => {
-        const ollama = createOllama({
-            baseURL: options.baseURL || 'http://localhost:11434/api',
-            ...(options.headers && { headers: options.headers })
-        });
-        const modelName = options.model || 'phi3';
-        return ollama(modelName);
-    }
-};
 /**
  * Generic OpenAI-compatible provider
  */
@@ -223,13 +206,24 @@ export const genericProvider = {
     supportsHeaders: true,
     supportsToolCalling: true,
     description: 'Uses /chat/completions endpoint',
+    baseUrls: [
+        {
+            url: 'http://localhost:4000',
+            description: 'Default for local LiteLLM server'
+        },
+        {
+            url: 'http://localhost:11434/v1',
+            description: 'Default for local Ollama server'
+        }
+    ],
     factory: (options) => {
-        const openai = createOpenAI({
+        const openaiCompatible = createOpenAICompatible({
+            name: options.provider,
             apiKey: options.apiKey || 'dummy',
-            ...(options.baseURL && { baseURL: options.baseURL }),
+            baseURL: options.baseURL ?? '',
             ...(options.headers && { headers: options.headers })
         });
         const modelName = options.model || 'gpt-4o';
-        return openai(modelName);
+        return openaiCompatible(modelName);
     }
 };

package/lib/tokens.d.ts

@@ -130,6 +130,13 @@ export interface IProviderInfo {
      * Optional description shown in the UI
      */
     description?: string;
+    /**
+     * Optional URL suggestions
+     */
+    baseUrls?: {
+        url: string;
+        description?: string;
+    }[];
     /**
      * Factory function for creating language models
      */
@@ -190,3 +197,70 @@ export interface IChatModelRegistry {
     createModel(name?: string, activeProvider?: string, tokenUsage?: ITokenUsage): AIChatModel;
 }
 export declare const IChatModelRegistry: Token<IChatModelRegistry>;
+/**
+ * Parameters for showing cell diff
+ */
+export interface IShowCellDiffParams {
+    /**
+     * Original cell content
+     */
+    original: string;
+    /**
+     * Modified cell content
+     */
+    modified: string;
+    /**
+     * Optional cell ID
+     */
+    cellId?: string;
+    /**
+     * Whether to show action buttons in the diff view
+     */
+    showActionButtons?: boolean;
+    /**
+     * Whether to open the diff view
+     */
+    openDiff?: boolean;
+    /**
+     * Optional path to the notebook
+     */
+    notebookPath?: string;
+}
+/**
+ * Parameters for showing file diff
+ */
+export interface IShowFileDiffParams {
+    /**
+     * Original file content
+     */
+    original: string;
+    /**
+     * Modified file content
+     */
+    modified: string;
+    /**
+     * Optional file path
+     */
+    filePath?: string;
+    /**
+     * Whether to show action buttons in the diff view
+     */
+    showActionButtons?: boolean;
+}
+/**
+ * Interface for managing diff operations
+ */
+export interface IDiffManager {
+    /**
+     * Show diff between original and modified cell content
+     */
+    showCellDiff(params: IShowCellDiffParams): Promise<void>;
+    /**
+     * Show diff between original and modified file content
+     */
+    showFileDiff(params: IShowFileDiffParams): Promise<void>;
+}
+/**
+ * Token for the diff manager.
+ */
+export declare const IDiffManager: Token<IDiffManager>;

package/lib/tokens.js

@@ -35,3 +35,7 @@ export const SECRETS_REPLACEMENT = '***';
  */
 export const IAgentManagerFactory = new Token('@jupyterlite/ai:agent-manager-factory');
 export const IChatModelRegistry = new Token('@jupyterlite/ai:chat-model-registry');
+/**
+ * Token for the diff manager.
+ */
+export const IDiffManager = new Token('@jupyterlite/ai:diff-manager');

package/lib/tools/commands.js

@@ -15,43 +15,44 @@ export function createDiscoverCommandsTool(commands) {
                 .nullable()
                 .describe('Optional search query to filter commands')
         }),
-        execute: async () => {
-            try {
-                const commandList = [];
-                // Get all command IDs
-                const commandIds = commands.listCommands();
-                for (const id of commandIds) {
-                    try {
-                        // Get command metadata using various CommandRegistry methods
-                        const description = await commands.describedBy(id);
-                        const label = commands.label(id);
-                        const caption = commands.caption(id);
-                        const usage = commands.usage(id);
-                        commandList.push({
-                            id,
-                            label: label || undefined,
-                            caption: caption || undefined,
-                            description: usage || undefined,
-                            args: description?.args || undefined
-                        });
-                    }
-                    catch (error) {
-                        // Some commands might not have descriptions, skip them
-                        commandList.push({ id });
+        execute: async (input) => {
+            const { query } = input;
+            const commandList = [];
+            // Get all command IDs
+            const commandIds = commands.listCommands();
+            for (const id of commandIds) {
+                // Get command metadata using various CommandRegistry methods
+                const description = await commands.describedBy(id);
+                const label = commands.label(id);
+                const caption = commands.caption(id);
+                const usage = commands.usage(id);
+                const command = {
+                    id,
+                    label: label || undefined,
+                    caption: caption || undefined,
+                    description: usage || undefined,
+                    args: description?.args || undefined
+                };
+                // Filter by query if provided
+                if (query) {
+                    const searchTerm = query.toLowerCase();
+                    const matchesQuery = id.toLowerCase().includes(searchTerm) ||
+                        label?.toLowerCase().includes(searchTerm) ||
+                        caption?.toLowerCase().includes(searchTerm) ||
+                        usage?.toLowerCase().includes(searchTerm);
+                    if (matchesQuery) {
+                        commandList.push(command);
                     }
                 }
-                return {
-                    success: true,
-                    commandCount: commandList.length,
-                    commands: commandList
-                };
-            }
-            catch (error) {
-                return {
-                    success: false,
-                    error: `Failed to discover commands: ${error instanceof Error ? error.message : String(error)}`
-                };
+                else {
+                    commandList.push(command);
+                }
             }
+            return {
+                success: true,
+                commandCount: commandList.length,
+                commands: commandList
+            };
         }
     });
 }
@@ -69,7 +70,7 @@ export function createExecuteCommandTool(commands, settingsModel) {
                 .optional()
                 .describe('Optional arguments to pass to the command')
         }),
-        needsApproval: async (_context, { commandId }) => {
+        needsApproval: async (context, { commandId }) => {
             // Use configurable list of commands requiring approval
             const commandsRequiringApproval = settingsModel.config.commandsRequiringApproval;
             return commandsRequiringApproval.some(cmd => commandId.includes(cmd) || cmd.includes(commandId));