@jupyterlite/ai 0.11.1 → 0.13.0

package/src/index.ts

@@ -9,16 +9,21 @@ import {
   ActiveCellManager,
   AttachmentOpenerRegistry,
   chatIcon,
+  ChatCommandRegistry,
   ChatWidget,
   IAttachmentOpenerRegistry,
+  IChatCommandRegistry,
+  IChatTracker,
   IInputToolbarRegistryFactory,
   InputToolbarRegistry,
-  MultiChatPanel
+  MultiChatPanel,
+  IChatModel
 } from '@jupyter/chat';
 
 import {
   ICommandPalette,
   IThemeManager,
+  showErrorMessage,
   WidgetTracker
 } from '@jupyterlab/apputils';
 
@@ -34,6 +39,8 @@ import { ISettingRegistry } from '@jupyterlab/settingregistry';
 
 import { IStatusBar } from '@jupyterlab/statusbar';
 
+import { PathExt } from '@jupyterlab/coreutils';
+
 import {
   ITranslator,
   nullTranslator,
@@ -49,25 +56,31 @@ import {
 import { ISecretsManager, SecretsManager } from 'jupyter-secrets-manager';
 
 import { PromiseDelegate, UUID } from '@lumino/coreutils';
+import { DisposableSet } from '@lumino/disposable';
 
 import { AgentManagerFactory } from './agent';
 
 import { AIChatModel } from './chat-model';
+import { RenderedMessageOutputAreaCompat } from './rendered-message-outputarea';
+
+import { ClearCommandProvider } from './chat-commands/clear';
+import { SkillsCommandProvider } from './chat-commands/skills';
 
 import { ProviderRegistry } from './providers/provider-registry';
 
 import { ApprovalButtons } from './approval-buttons';
 
-import { ChatModelRegistry } from './chat-model-registry';
+import { ChatModelHandler } from './chat-model-handler';
 
 import {
   CommandIds,
   IAgentManagerFactory,
   IProviderRegistry,
   IToolRegistry,
+  ISkillRegistry,
   SECRETS_NAMESPACE,
   IAISettingsModel,
-  IChatModelRegistry,
+  IChatModelHandler,
   IDiffManager
 } from './tokens';
 
@@ -90,7 +103,9 @@ import {
   TokenUsageWidget
 } from './components';
 
-import { AISettingsModel } from './models/settings-model';
+import { AISettingsModel, IProviderConfig } from './models/settings-model';
+
+import { loadSkillsFromPaths, SkillRegistry } from './skills';
 
 import { DiffManager } from './diff-manager';
 
@@ -100,6 +115,8 @@ import {
   createDiscoverCommandsTool,
   createExecuteCommandTool
 } from './tools/commands';
+import { createDiscoverSkillsTool, createLoadSkillTool } from './tools/skills';
+import { createBrowserFetchTool } from './tools/web';
 
 import { AISettingsWidget } from './widgets/ai-settings';
 
@@ -184,30 +201,85 @@ const genericProviderPlugin: JupyterFrontEndPlugin<void> = {
 };
 
 /**
- * The chat model registry.
+ * Chat command registry plugin.
+ */
+const chatCommandRegistryPlugin: JupyterFrontEndPlugin<IChatCommandRegistry> = {
+  id: '@jupyterlite/ai:chat-command-registry',
+  description: 'Provide the chat command registry for JupyterLite AI.',
+  autoStart: true,
+  provides: IChatCommandRegistry,
+  activate: () => {
+    return new ChatCommandRegistry();
+  }
+};
+
+/**
+ * Clear chat command plugin.
+ */
+const clearCommandPlugin: JupyterFrontEndPlugin<void> = {
+  id: '@jupyterlite/ai:clear-command',
+  description: 'Register the /clear chat command.',
+  autoStart: true,
+  requires: [IChatCommandRegistry],
+  activate: (app, registry: IChatCommandRegistry) => {
+    registry.addProvider(new ClearCommandProvider());
+  }
+};
+
+/**
+ * Skills chat command plugin.
+ */
+const skillsCommandPlugin: JupyterFrontEndPlugin<void> = {
+  id: '@jupyterlite/ai:skills-command',
+  description: 'Register the /skills chat command.',
+  autoStart: true,
+  requires: [IChatCommandRegistry, ISkillRegistry],
+  activate: (
+    app,
+    registry: IChatCommandRegistry,
+    skillRegistry: ISkillRegistry
+  ) => {
+    registry.addProvider(
+      new SkillsCommandProvider({
+        skillRegistry,
+        commands: app.commands
+      })
+    );
+  }
+};
+
+/**
+ * The chat model handler.
  */
-const chatModelRegistry: JupyterFrontEndPlugin<IChatModelRegistry> = {
-  id: '@jupyterlite/ai:chat-model-registry',
-  description: 'Registry for the current chat model',
+const chatModelHandler: JupyterFrontEndPlugin<IChatModelHandler> = {
+  id: '@jupyterlite/ai:chat-model-handler',
+  description: 'A handler to create current chat model',
   autoStart: true,
-  requires: [IAISettingsModel, IAgentManagerFactory, IDocumentManager],
+  requires: [
+    IAISettingsModel,
+    IAgentManagerFactory,
+    IDocumentManager,
+    IRenderMimeRegistry
+  ],
   optional: [IProviderRegistry, IToolRegistry, ITranslator],
-  provides: IChatModelRegistry,
+  provides: IChatModelHandler,
   activate: (
     app: JupyterFrontEnd,
     settingsModel: AISettingsModel,
     agentManagerFactory: AgentManagerFactory,
     docManager: IDocumentManager,
+    rmRegistry: IRenderMimeRegistry,
     providerRegistry?: IProviderRegistry,
     toolRegistry?: IToolRegistry,
     translator?: ITranslator
-  ): IChatModelRegistry => {
+  ): IChatModelHandler => {
     const trans = (translator ?? nullTranslator).load('jupyterlite_ai');
 
-    return new ChatModelRegistry({
+    return new ChatModelHandler({
       settingsModel,
       agentManagerFactory,
       docManager,
+      rmRegistry,
       providerRegistry,
       toolRegistry,
       trans
@@ -218,15 +290,17 @@ const chatModelRegistry: JupyterFrontEndPlugin<IChatModelRegistry> = {
 /**
  * Initialization data for the extension.
  */
-const plugin: JupyterFrontEndPlugin<void> = {
+const plugin: JupyterFrontEndPlugin<IChatTracker> = {
   id: '@jupyterlite/ai:plugin',
   description: 'AI in JupyterLab',
   autoStart: true,
+  provides: IChatTracker,
   requires: [
     IRenderMimeRegistry,
     IInputToolbarRegistryFactory,
-    IChatModelRegistry,
-    IAISettingsModel
+    IChatModelHandler,
+    IAISettingsModel,
+    IChatCommandRegistry
   ],
   optional: [
     IThemeManager,
@@ -239,14 +313,15 @@ const plugin: JupyterFrontEndPlugin<void> = {
     app: JupyterFrontEnd,
     rmRegistry: IRenderMimeRegistry,
     inputToolbarFactory: IInputToolbarRegistryFactory,
-    modelRegistry: IChatModelRegistry,
+    modelHandler: IChatModelHandler,
     settingsModel: AISettingsModel,
+    chatCommandRegistry: IChatCommandRegistry,
     themeManager?: IThemeManager,
     restorer?: ILayoutRestorer,
     labShell?: ILabShell,
     notebookTracker?: INotebookTracker,
     translator?: ITranslator
-  ): void => {
+  ): IChatTracker => {
     const trans = (translator ?? nullTranslator).load('jupyterlite_ai');
     // Create attachment opener registry to handle file attachments
     const attachmentOpenerRegistry = new AttachmentOpenerRegistry();
@@ -267,7 +342,11 @@ const plugin: JupyterFrontEndPlugin<void> = {
         shell: app.shell
       });
     }
-    modelRegistry.activeCellManager = activeCellManager;
+    modelHandler.activeCellManager = activeCellManager;
+
+    // Creating the tracker for the chat widgets
+    const namespace = 'ai-chat';
+    const tracker = new WidgetTracker<MainAreaChat | ChatWidget>({ namespace });
 
     // Create chat panel with drag/drop functionality
     const chatPanel = new MultiChatPanel({
@@ -275,19 +354,36 @@ const plugin: JupyterFrontEndPlugin<void> = {
       themeManager: themeManager ?? null,
       inputToolbarFactory,
       attachmentOpenerRegistry,
-      createModel: async (name?: string) => {
-        const model = modelRegistry.createModel(name);
+      chatCommandRegistry,
+      createModel: async (provider?: string) => {
+        if (!provider) {
+          provider = settingsModel.getDefaultProvider()?.id;
+          if (!provider) {
+            showErrorMessage('Error creating chat', 'Please set up a provider');
+            app.commands.execute('@jupyterlite/ai:open-settings');
+            return {};
+          }
+        }
+        let name = settingsModel.getProvider(provider)?.name ?? UUID.uuid4();
+        const modelName = name;
+        const existingName = new Set(chatPanel.getLoadedModelNames());
+        tracker.forEach(widget => existingName.add(widget.model.name));
+        let i = 1;
+        while (existingName.has(name)) {
+          name = `${modelName}-${i}`;
+          i += 1;
+        }
+        const model = modelHandler.createModel(name, provider);
         return { model };
       },
-      renameChat: async (oldName: string, newName: string) => {
-        const model = modelRegistry.get(oldName);
-        const concurrencyModel = modelRegistry.get(newName);
-        if (model && !concurrencyModel) {
-          model.name = newName;
-          return true;
-        }
-        return false;
+      getChatNames: async () => {
+        const names: { [name: string]: string } = {};
+        settingsModel.config.providers.forEach(provider => {
+          names[provider.name] = provider.id;
+        });
+        return names;
       },
+      renameChat: true,
       openInMain: (name: string) =>
         app.commands.execute(CommandIds.moveChat, {
           area: 'main',
@@ -311,28 +407,40 @@ const plugin: JupyterFrontEndPlugin<void> = {
       })
     );
 
-    chatPanel.sectionAdded.connect((_, section) => {
-      const { widget } = section;
-      const model = section.model as AIChatModel;
+    let tokenUsageWidget: TokenUsageWidget | null = null;
+    chatPanel.chatOpened.connect((_, widget) => {
+      const model = widget.model as AIChatModel;
 
       // Add the widget to the tracker.
       tracker.add(widget);
 
+      function saveTracker() {
+        tracker.save(widget);
+      }
+
       // Update the tracker if the model name changed.
-      model.nameChanged.connect(() => tracker.save(widget));
+      model.nameChanged.connect(saveTracker);
+
       // Update the tracker if the active provider changed.
-      model.agentManager.activeProviderChanged.connect(() =>
-        tracker.save(widget)
-      );
+      model.agentManager.activeProviderChanged.connect(saveTracker);
+
+      // Update the token usage widget.
+      tokenUsageWidget?.dispose();
 
-      const tokenUsageWidget = new TokenUsageWidget({
+      tokenUsageWidget = new TokenUsageWidget({
         tokenUsageChanged: model.tokenUsageChanged,
         settingsModel,
         initialTokenUsage: model.agentManager.tokenUsage,
         translator: trans
       });
-      section.toolbar.insertBefore('markRead', 'token-usage', tokenUsageWidget);
-      model.writersChanged?.connect((_, writers) => {
+      chatPanel.current?.toolbar.insertBefore(
+        'markRead',
+        'token-usage',
+        tokenUsageWidget
+      );
+
+      // Listen for writers change to display the stop button.
+      function writersChanged(_: IChatModel, writers: IChatModel.IWriter[]) {
         // Check if AI is currently writing (streaming)
         const aiWriting = writers.some(
           writer => writer.user.username === 'ai-assistant'
@@ -345,28 +453,34 @@ const plugin: JupyterFrontEndPlugin<void> = {
           widget.inputToolbarRegistry?.hide('stop');
           widget.inputToolbarRegistry?.show('send');
         }
-      });
+      }
+
+      model.writersChanged?.connect(writersChanged);
 
       // Associate an approval buttons object to the chat.
       const approvalButton = new ApprovalButtons({
         chatPanel: widget,
         agentManager: model.agentManager
       });
+      // Temporary compat: keep output-area CSS context for MIME renderers
+      // until jupyter-chat provides it natively.
+      const outputAreaCompat = new RenderedMessageOutputAreaCompat({
+        chatPanel: widget
+      });
 
       widget.disposed.connect(() => {
+        model.nameChanged.disconnect(saveTracker);
+        model.agentManager.activeProviderChanged.disconnect(saveTracker);
+        model.writersChanged?.disconnect(writersChanged);
+
         // Dispose of the approval buttons widget when the chat is disposed.
         approvalButton.dispose();
-        // Remove the model from the registry when the widget is disposed.
-        modelRegistry.remove(model.name);
+        outputAreaCompat.dispose();
       });
     });
 
     app.shell.add(chatPanel, 'left', { rank: 1000 });
 
-    // Creating the tracker for the document
-    const namespace = 'ai-chat';
-    const tracker = new WidgetTracker<MainAreaChat | ChatWidget>({ namespace });
-
     if (restorer) {
       restorer.add(chatPanel, chatPanel.id);
       void restorer.restore(tracker, {
@@ -385,10 +499,7 @@ const plugin: JupyterFrontEndPlugin<void> = {
 
     // Create a chat with default provider at startup.
     app.restored.then(() => {
-      if (
-        !modelRegistry.getAll().length &&
-        settingsModel.config.defaultProvider
-      ) {
+      if (!tracker.size && settingsModel.config.defaultProvider) {
         app.commands.execute(CommandIds.openChat);
       }
     });
@@ -400,12 +511,15 @@ const plugin: JupyterFrontEndPlugin<void> = {
       attachmentOpenerRegistry,
       inputToolbarFactory,
       settingsModel,
+      chatCommandRegistry,
       tracker,
-      modelRegistry,
+      modelHandler,
       trans,
       themeManager,
       labShell
     );
+
+    return tracker;
   }
 };
 
@@ -416,8 +530,9 @@ function registerCommands(
   attachmentOpenerRegistry: IAttachmentOpenerRegistry,
   inputToolbarFactory: IInputToolbarRegistryFactory,
   settingsModel: AISettingsModel,
+  chatCommandRegistry: IChatCommandRegistry,
   tracker: WidgetTracker<MainAreaChat | ChatWidget>,
-  modelRegistry: IChatModelRegistry,
+  modelRegistry: IChatModelHandler,
   trans: TranslationBundle,
   themeManager?: IThemeManager,
   labShell?: ILabShell
@@ -481,7 +596,8 @@ function registerCommands(
         rmRegistry,
         themeManager: themeManager ?? null,
         inputToolbarRegistry: inputToolbarFactory.create(),
-        attachmentOpenerRegistry
+        attachmentOpenerRegistry,
+        chatCommandRegistry
       });
       const widget = new MainAreaChat({
         content,
@@ -494,16 +610,18 @@ function registerCommands(
       // Add the widget to the tracker.
       tracker.add(widget);
 
+      function saveTracker() {
+        tracker.save(widget);
+      }
+
       // Update the tracker if the model name changed.
-      model.nameChanged.connect(() => tracker.save(widget));
+      model.nameChanged.connect(saveTracker);
       // Update the tracker if the active provider changed.
-      model.agentManager.activeProviderChanged.connect(() =>
-        tracker.save(widget)
-      );
+      model.agentManager.activeProviderChanged.connect(saveTracker);
 
-      // Remove the model from the registry when the widget is disposed.
       widget.disposed.connect(() => {
-        modelRegistry.remove(model.name);
+        model.nameChanged.disconnect(saveTracker);
+        model.agentManager.activeProviderChanged.disconnect(saveTracker);
       });
     };
 
@@ -512,15 +630,26 @@ function registerCommands(
       execute: async (args): Promise<boolean> => {
         const area = (args.area as string) === 'main' ? 'main' : 'side';
         const provider = (args.provider as string) ?? undefined;
+        let name = (args.name as string) ?? undefined;
 
-        // Do not open the chat if the provider in args does not exists in settings.
-        if (provider && !settingsModel.getProvider(provider)) {
+        let providerConfig: IProviderConfig | undefined = undefined;
+        if (provider) {
+          providerConfig = settingsModel.getProvider(provider);
+        } else {
+          providerConfig = settingsModel.getDefaultProvider();
+        }
+
+        // Do not open the chat if the provider in args does not exists in settings or
+        // if there is no default provider.
+        if (!providerConfig) {
           return false;
         }
-        const model = modelRegistry.createModel(
-          args.name ? (args.name as string) : undefined,
-          provider
-        );
+
+        if (!name) {
+          name = providerConfig.name;
+        }
+
+        const model = modelRegistry.createModel(name, provider);
         if (!model) {
           return false;
         }
@@ -528,7 +657,7 @@ function registerCommands(
         if (area === 'main') {
           openInMain(model);
         } else {
-          chatPanel.addChat({ model });
+          chatPanel.open({ model });
         }
         return true;
       },
@@ -570,7 +699,15 @@ function registerCommands(
           );
           return false;
         }
-        const previousModel = modelRegistry.get(args.name as string);
+        let previousWidget: ChatWidget | MainAreaChat | undefined;
+        let previousModel: AIChatModel | undefined;
+        tracker.forEach(widget => {
+          if (widget.model.name === args.name) {
+            previousWidget = widget;
+            previousModel = widget.model as AIChatModel;
+          }
+        });
+
         if (!previousModel) {
           console.error(
             'Error while moving the chat to main area: there is no reference model'
@@ -596,12 +733,12 @@ function registerCommands(
         // Create a new model by duplicating the previous model attributes.
         const model = modelRegistry.createModel(
           args.name as string,
-          previousModel?.agentManager.activeProvider,
-          previousModel?.agentManager.tokenUsage
-        );
-        previousModel?.messages.forEach(message =>
-          model?.messageAdded(message)
+          previousModel.agentManager.activeProvider,
+          previousModel.agentManager.tokenUsage
         );
+        previousModel?.messages.forEach(message => {
+          model?.messageAdded({ ...message.content });
+        });
 
         // Wait (with timeout) for the tracker to have updated the previous widget.
         const status = await Promise.any([
@@ -621,15 +758,9 @@ function registerCommands(
         if (area === 'main') {
           openInMain(model);
         } else {
-          const current = app.shell.currentWidget;
-          // Remove the current main area chat.
-          if (
-            current instanceof MainAreaChat &&
-            current.model.name === previousModel.name
-          ) {
-            current.dispose();
-          }
-          chatPanel.addChat({ model });
+          previousWidget?.dispose();
+          previousModel.dispose();
+          chatPanel.open({ model });
         }
 
         return true;
@@ -641,7 +772,7 @@ function registerCommands(
             area: {
               type: 'string',
               enum: ['main', 'side'],
-              description: trans.__('The name of the area to move the chat to')
+              description: trans.__('The area to move the chat to')
             },
             name: {
               type: 'string',
@@ -656,7 +787,9 @@ function registerCommands(
 }
 
 /**
- * A plugin to provide the settings model.
+ * A plugin to provide the agent manager factory, the completion provider and
+ * the settings model.
+ * All these objects require the secrets manager token with the same namespace.
  */
 const agentManagerFactory: JupyterFrontEndPlugin<AgentManagerFactory> =
   SecretsManager.sign(SECRETS_NAMESPACE, token => ({
@@ -666,6 +799,7 @@ const agentManagerFactory: JupyterFrontEndPlugin<AgentManagerFactory> =
     provides: IAgentManagerFactory,
     requires: [IAISettingsModel, IProviderRegistry],
     optional: [
+      ISkillRegistry,
       ICommandPalette,
       ICompletionProviderManager,
       ILayoutRestorer,
@@ -677,7 +811,8 @@ const agentManagerFactory: JupyterFrontEndPlugin<AgentManagerFactory> =
       app: JupyterFrontEnd,
       settingsModel: AISettingsModel,
       providerRegistry: IProviderRegistry,
-      palette: ICommandPalette,
+      skillRegistry?: ISkillRegistry,
+      palette?: ICommandPalette,
       completionManager?: ICompletionProviderManager,
       restorer?: ILayoutRestorer,
       secretsManager?: ISecretsManager,
@@ -687,6 +822,7 @@ const agentManagerFactory: JupyterFrontEndPlugin<AgentManagerFactory> =
       const trans = (translator ?? nullTranslator).load('jupyterlite_ai');
       const agentManagerFactory = new AgentManagerFactory({
         settingsModel,
+        skillRegistry,
         secretsManager,
         token
       });
@@ -797,13 +933,31 @@ const diffManager: JupyterFrontEndPlugin<IDiffManager> = {
   }
 };
 
+/**
+ * Skill registry plugin
+ */
+const skillRegistryPlugin: JupyterFrontEndPlugin<ISkillRegistry> = {
+  id: '@jupyterlite/ai:skill-registry',
+  description: 'Provide the skill registry',
+  autoStart: true,
+  provides: ISkillRegistry,
+  activate: () => {
+    return new SkillRegistry();
+  }
+};
+
 const toolRegistry: JupyterFrontEndPlugin<IToolRegistry> = {
   id: '@jupyterlite/ai:tool-registry',
   description: 'Provide the AI tool registry',
   autoStart: true,
   requires: [IAISettingsModel],
+  optional: [ISkillRegistry],
   provides: IToolRegistry,
-  activate: (app: JupyterFrontEnd, settingsModel: AISettingsModel) => {
+  activate: (
+    app: JupyterFrontEnd,
+    settingsModel: AISettingsModel,
+    skillRegistry?: ISkillRegistry
+  ) => {
     const toolRegistry = new ToolRegistry();
 
     // Add command operation tools
@@ -815,6 +969,14 @@ const toolRegistry: JupyterFrontEndPlugin<IToolRegistry> = {
 
     toolRegistry.add('discover_commands', discoverCommandsTool);
     toolRegistry.add('execute_command', executeCommandTool);
+    toolRegistry.add('browser_fetch', createBrowserFetchTool());
+    if (skillRegistry) {
+      toolRegistry.add(
+        'discover_skills',
+        createDiscoverSkillsTool(skillRegistry)
+      );
+      toolRegistry.add('load_skill', createLoadSkillTool(skillRegistry));
+    }
 
     return toolRegistry;
   }
@@ -829,12 +991,13 @@ const inputToolbarFactory: JupyterFrontEndPlugin<IInputToolbarRegistryFactory> =
     description: 'The input toolbar registry plugin.',
     autoStart: true,
     provides: IInputToolbarRegistryFactory,
-    requires: [IAISettingsModel, IToolRegistry],
+    requires: [IAISettingsModel, IToolRegistry, IProviderRegistry],
     optional: [ITranslator],
     activate: (
       app: JupyterFrontEnd,
       settingsModel: AISettingsModel,
       toolRegistry: IToolRegistry,
+      providerRegistry: IProviderRegistry,
       translator?: ITranslator
     ): IInputToolbarRegistryFactory => {
       const trans = (translator ?? nullTranslator).load('jupyterlite_ai');
@@ -842,6 +1005,8 @@ const inputToolbarFactory: JupyterFrontEndPlugin<IInputToolbarRegistryFactory> =
       const clearButton = clearItem(trans);
       const toolSelectButton = createToolSelectItem(
         toolRegistry,
+        settingsModel,
+        providerRegistry,
         settingsModel.config.toolsEnabled,
         trans
       );
@@ -900,6 +1065,144 @@ const completionStatus: JupyterFrontEndPlugin<void> = {
   }
 };
 
+/**
+ * Skills plugin: discovers and registers agent skills from the filesystem.
+ */
+const skillsPlugin: JupyterFrontEndPlugin<void> = {
+  id: '@jupyterlite/ai:skills',
+  description: 'Discover and register agent skills',
+  autoStart: true,
+  requires: [IAISettingsModel, IDocumentManager, ISkillRegistry],
+  optional: [ICommandPalette, ITranslator],
+  activate: async (
+    app: JupyterFrontEnd,
+    settingsModel: AISettingsModel,
+    docManager: IDocumentManager,
+    skillRegistry: ISkillRegistry,
+    palette?: ICommandPalette,
+    translator?: ITranslator
+  ) => {
+    const trans = (translator ?? nullTranslator).load('jupyterlite_ai');
+    const validateResourcePath = (resourcePath: string): string | null => {
+      if (resourcePath.startsWith('/')) {
+        return null;
+      }
+
+      const normalized = PathExt.normalize(resourcePath);
+      if (normalized.startsWith('..') || normalized === '') {
+        return null;
+      }
+
+      return normalized;
+    };
+
+    let currentSkillsPaths = settingsModel.config.skillsPaths;
+    let currentSkillDisposables = new DisposableSet();
+
+    const loadAndRegister = async () => {
+      const skillsPaths = settingsModel.config.skillsPaths;
+      const skills = await loadSkillsFromPaths(
+        docManager.services.contents,
+        skillsPaths
+      );
+
+      const registrations = skills.map(skill => ({
+        name: skill.name,
+        description: skill.description,
+        instructions: skill.instructions,
+        resources: skill.resources,
+        loadResource: async (resource: string) => {
+          const validatedPath = validateResourcePath(resource);
+          if (validatedPath === null) {
+            return {
+              name: skill.name,
+              resource,
+              error: 'Invalid resource path: path traversal not allowed'
+            };
+          }
+
+          if (!skill.resources.includes(validatedPath)) {
+            return {
+              name: skill.name,
+              resource,
+              error: `Resource not found: ${resource}`
+            };
+          }
+
+          const resourcePath = `${skill.path}/${validatedPath}`;
+          try {
+            const fileModel = await docManager.services.contents.get(
+              resourcePath,
+              {
+                content: true
+              }
+            );
+            if (typeof fileModel.content !== 'string') {
+              return {
+                name: skill.name,
+                resource,
+                error: 'Resource content is not a string'
+              };
+            }
+            return {
+              name: skill.name,
+              resource,
+              content: fileModel.content
+            };
+          } catch (error) {
+            return {
+              name: skill.name,
+              resource,
+              error: `Failed to read resource: ${error}`
+            };
+          }
+        }
+      }));
+
+      currentSkillDisposables.dispose();
+      currentSkillDisposables = new DisposableSet();
+      for (const registration of registrations) {
+        currentSkillDisposables.add(skillRegistry.registerSkill(registration));
+      }
+    };
+
+    app.commands.addCommand(CommandIds.refreshSkills, {
+      label: trans.__('Refresh Agents Skills'),
+      caption: trans.__(
+        'Re-scan the agents skills directory and update the registry'
+      ),
+      execute: async () => {
+        await loadAndRegister();
+      }
+    });
+
+    if (palette) {
+      palette.addItem({
+        command: CommandIds.refreshSkills,
+        category: trans.__('AI Assistant')
+      });
+    }
+
+    loadAndRegister().catch(error =>
+      console.warn('Failed to load skills on activation:', error)
+    );
+
+    settingsModel.stateChanged.connect(() => {
+      const newPaths = settingsModel.config.skillsPaths;
+      if (
+        newPaths.length === currentSkillsPaths.length &&
+        newPaths.every((p, i) => p === currentSkillsPaths[i])
+      ) {
+        return;
+      }
+      currentSkillsPaths = newPaths;
+      loadAndRegister().catch(error =>
+        console.warn('Failed to reload skills:', error)
+      );
+    });
+  }
+};
+
 export default [
   providerRegistryPlugin,
   anthropicProviderPlugin,
@@ -909,12 +1212,17 @@ export default [
   genericProviderPlugin,
   settingsModel,
   diffManager,
-  chatModelRegistry,
+  chatCommandRegistryPlugin,
+  clearCommandPlugin,
+  skillRegistryPlugin,
+  skillsCommandPlugin,
+  chatModelHandler,
   plugin,
   toolRegistry,
   agentManagerFactory,
   inputToolbarFactory,
-  completionStatus
+  completionStatus,
+  skillsPlugin
 ];
 
 // Export extension points for other extensions to use