@jupyternaut/persona 0.20.0 → 0.20.1

package/lib/chat-commands/index.d.ts

@@ -0,0 +1,3 @@
+export * from './mention';
+export * from './skills';
+//# sourceMappingURL=index.d.ts.map

package/lib/chat-commands/index.js

@@ -0,0 +1,2 @@
+export * from './mention';
+export * from './skills';

package/lib/chat-commands/skills.d.ts

@@ -0,0 +1,25 @@
+import { ChatCommand, IChatCommandProvider, IInputModel } from '@jupyter/chat';
+import type { ISkillRegistry } from '@jupyternaut/agent';
+import { CommandRegistry } from '@lumino/commands';
+export declare class SkillsCommandProvider implements IChatCommandProvider {
+    constructor(options: SkillsCommandProvider.IOptions);
+    id: string;
+    listCommandCompletions(inputModel: IInputModel): Promise<ChatCommand[]>;
+    onSubmit(inputModel: IInputModel): Promise<void>;
+    private _isActive;
+    private _command;
+    private _regex;
+    private _commands;
+    private _skillRegistry;
+    private _sendSystemMessage;
+    private _isDefault;
+}
+export declare namespace SkillsCommandProvider {
+    interface IOptions {
+        skillRegistry: ISkillRegistry;
+        commands: CommandRegistry;
+        sendSystemMessage: (chatName: string, body: string) => void;
+        isDefault: (chatName: string) => boolean;
+    }
+}
+//# sourceMappingURL=skills.d.ts.map

package/lib/chat-commands/skills.js

@@ -0,0 +1,73 @@
+import { CommandIds } from '../tokens';
+export class SkillsCommandProvider {
+    constructor(options) {
+        this._skillRegistry = options.skillRegistry;
+        this._commands = options.commands;
+        this._sendSystemMessage = options.sendSystemMessage;
+        this._isDefault = options.isDefault;
+    }
+    id = '@jupyternaut/persona:skills-command';
+    async listCommandCompletions(inputModel) {
+        if (!this._isActive(inputModel)) {
+            return [];
+        }
+        const match = inputModel.currentWord?.match(this._regex)?.[0];
+        if (!match) {
+            return [];
+        }
+        if (this._command.name.startsWith(match)) {
+            return [this._command];
+        }
+        return [];
+    }
+    async onSubmit(inputModel) {
+        if (!this._isActive(inputModel)) {
+            return;
+        }
+        const trimmed = inputModel.value.trim();
+        const match = trimmed.match(/^\/skills(?:\s+(.+))?$/);
+        if (!match) {
+            return;
+        }
+        if (this._commands.hasCommand(CommandIds.refreshSkills)) {
+            await this._commands.execute(CommandIds.refreshSkills);
+        }
+        const query = match[1]?.trim();
+        const filtered = this._skillRegistry.listSkills(query);
+        let body = '';
+        if (filtered.length === 0) {
+            body = query
+                ? `No skills found matching "${query}".`
+                : 'No skills are currently registered.';
+        }
+        else {
+            const heading = query
+                ? `Skills matching "${query}" (${filtered.length}):`
+                : `Available skills (${filtered.length}):`;
+            const lines = filtered.map(skill => `- \`${skill.name}\` — ${skill.description}`);
+            body = [heading, '', ...lines].join('\n');
+        }
+        const chatName = inputModel.chatContext?.name;
+        if (chatName) {
+            this._sendSystemMessage(chatName, body);
+        }
+        // Prevent the message to be actually sent.
+        inputModel.value = '';
+        inputModel.clearAttachments();
+        inputModel.clearMentions();
+    }
+    _isActive(inputModel) {
+        const chatName = inputModel.chatContext?.name;
+        return !!chatName && this._isDefault(chatName);
+    }
+    _command = {
+        name: '/skills',
+        providerId: this.id,
+        description: 'List available skills'
+    };
+    _regex = /^\/\w*$/;
+    _commands;
+    _skillRegistry;
+    _sendSystemMessage;
+    _isDefault;
+}

package/lib/index.d.ts

@@ -1,5 +1,5 @@
-import { IAgentManagerFactory, IAISettingsModel, IDiffManager, IProviderRegistry, IToolRegistry, ISkillRegistry } from '@jupyternaut/agent';
 import { JupyterFrontEndPlugin } from '@jupyterlab/application';
+import { IAgentManagerFactory, IAISettingsModel, IDiffManager, IProviderRegistry, IToolRegistry, ISkillRegistry } from '@jupyternaut/agent';
 import { IPersonaRegistry } from './tokens';
 declare const _default: (JupyterFrontEndPlugin<IProviderRegistry> | JupyterFrontEndPlugin<void> | JupyterFrontEndPlugin<IPersonaRegistry> | JupyterFrontEndPlugin<IAgentManagerFactory> | JupyterFrontEndPlugin<IAISettingsModel> | JupyterFrontEndPlugin<IDiffManager> | JupyterFrontEndPlugin<ISkillRegistry> | JupyterFrontEndPlugin<IToolRegistry>)[];
 export default _default;

package/lib/index.js

@@ -1,6 +1,5 @@
-import { anthropicProvider, createBrowserFetchTool, createDiscoverCommandsTool, createDiscoverSkillsTool, createExecuteCommandTool, createLoadSkillTool, genericProvider, googleProvider, loadSkillsFromPaths, mistralProvider, openaiProvider, AgentManagerFactory, IAgentManagerFactory, IAISettingsModel, IDiffManager, IProviderRegistry, IToolRegistry, ISkillRegistry, ProviderRegistry, SECRETS_NAMESPACE, SkillRegistry, ToolRegistry } from '@jupyternaut/agent';
-import { ILayoutRestorer } from '@jupyterlab/application';
 import { IChatTracker, IChatCommandRegistry } from '@jupyter/chat';
+import { ILayoutRestorer } from '@jupyterlab/application';
 import { ICommandPalette, IThemeManager } from '@jupyterlab/apputils';
 import { ICompletionProviderManager } from '@jupyterlab/completer';
 import { IDocumentManager } from '@jupyterlab/docmanager';
@@ -9,10 +8,12 @@ import { IStatusBar } from '@jupyterlab/statusbar';
 import { PathExt } from '@jupyterlab/coreutils';
 import { ITranslator, nullTranslator } from '@jupyterlab/translation';
 import { IFormRendererRegistry, settingsIcon } from '@jupyterlab/ui-components';
+import { anthropicProvider, createBrowserFetchTool, createDiscoverCommandsTool, createDiscoverSkillsTool, createExecuteCommandTool, createLoadSkillTool, genericProvider, googleProvider, loadSkillsFromPaths, mistralProvider, openaiProvider, AgentManagerFactory, IAgentManagerFactory, IAISettingsModel, IDiffManager, IProviderRegistry, IToolRegistry, ISkillRegistry, ProviderRegistry, SECRETS_NAMESPACE, SkillRegistry, ToolRegistry } from '@jupyternaut/agent';
 import { DisposableSet } from '@lumino/disposable';
+import { IComponentsRendererFactory } from 'jupyter-chat-components';
 import { IMcpManager } from 'jupyter-mcp-manager';
 import { ISecretsManager, SecretsManager } from 'jupyter-secrets-manager';
-import { MentionCommandProvider } from './chat-commands/mention';
+import { MentionCommandProvider, SkillsCommandProvider } from './chat-commands';
 import { AICompletionProvider } from './completion';
 import { CompletionStatusWidget } from './components';
 import { DiffManager } from './diff-manager';
@@ -180,6 +181,41 @@ const persona = {
         chatTracker?.widgetAdded.connect((_, widget) => attachPersona(widget));
     }
 };
+/**
+ * Registers groupedToolCall callbacks to route tool call approval decisions
+ * to the correct persona's agent manager.
+ */
+const chatComponentsCallbacks = {
+    id: '@jupyternaut/persona:chat-components-callbacks',
+    description: 'Register chat components callbacks for the persona.',
+    autoStart: true,
+    requires: [IPersonaRegistry],
+    optional: [IChatTracker, IComponentsRendererFactory],
+    activate: (_app, personaRegistry, chatTracker, chatComponentsFactory) => {
+        if (!chatComponentsFactory) {
+            return;
+        }
+        const findPersona = (sessionId) => {
+            const model = chatTracker?.find(chat => chat.model.name === sessionId)?.model;
+            return model ? personaRegistry.get(model) : undefined;
+        };
+        chatComponentsFactory.groupedToolCallCallbacks = {
+            ...chatComponentsFactory.groupedToolCallCallbacks,
+            toolCallPermissionDecision: (sessionId, toolCallId, optionId) => {
+                const agent = findPersona(sessionId)?.agentManager;
+                if (!agent) {
+                    return;
+                }
+                if (optionId === 'approve') {
+                    agent.approveToolCall(toolCallId);
+                }
+                else {
+                    agent.rejectToolCall(toolCallId);
+                }
+            }
+        };
+    }
+};
 /**
  * Clear chat command plugin.
  */
@@ -192,6 +228,39 @@ const mentionCommandPlugin = {
         registry.addProvider(new MentionCommandProvider());
     }
 };
+/**
+ * Skills chat command plugin.
+ */
+const skillsCommandPlugin = {
+    id: '@jupyternaut/persona:skills-command',
+    description: 'Register the /skills chat command.',
+    autoStart: true,
+    requires: [IChatCommandRegistry, ISkillRegistry, IPersonaRegistry],
+    optional: [IChatTracker],
+    activate: (app, registry, skillRegistry, personaRegistry, chatTracker) => {
+        const findModel = (chatName) => chatTracker?.find(c => c.model.name === chatName)?.model;
+        const isDefault = (chatName) => {
+            const model = findModel(chatName);
+            if (!model) {
+                return false;
+            }
+            const persona = personaRegistry.get(model);
+            return persona ? !persona.requireMention : false;
+        };
+        const sendSystemMessage = (chatName, body) => {
+            const model = findModel(chatName);
+            if (model) {
+                personaRegistry.get(model)?.sendSystemMessage(body);
+            }
+        };
+        registry.addProvider(new SkillsCommandProvider({
+            skillRegistry,
+            commands: app.commands,
+            isDefault,
+            sendSystemMessage
+        }));
+    }
+};
 /**
  * A plugin to provide the agent manager factory and completion provider.
  * These objects require the secrets manager token with the same namespace.
@@ -509,7 +578,9 @@ export default [
     // Persona
     personaRegistry,
     persona,
+    chatComponentsCallbacks,
     mentionCommandPlugin,
+    skillsCommandPlugin,
     // Settings
     settingsModel,
     settingsPanelPlugin,

package/lib/persona.d.ts

@@ -34,6 +34,7 @@ export declare class Persona implements IPersona {
     private _handleToolApprovalResolved;
     private _handleError;
     private _updateToolCallUI;
+    sendSystemMessage(body: string): void;
     /**
      * Whether a mention is required to trigger a response.
      * When false, the persona responds to all non-bot messages.

package/lib/persona.js

@@ -106,12 +106,15 @@ export class Persona {
         this._settingsModel = options.settingsModel;
         this._providerRegistry = options.providerRegistry;
         this._documentManager = options.documentManager;
-        for (const message of options.model.messages) {
-            this._respondedToIds.add(message.id);
-        }
         this._agent.agentEvent.connect(this._onAgentEvent, this);
         this._agent.activeProviderChanged.connect(this._onActiveProviderChanged, this);
-        this._model.messagesUpdated.connect(this._onMessagesUpdated, this);
+        // Wait for the chat to be ready before connect to message update.
+        this._model.ready.then(() => {
+            for (const message of this._model.messages) {
+                this._respondedToIds.add(message.id);
+            }
+            this._model.messagesUpdated.connect(this._onMessagesUpdated, this);
+        });
         this._model.disposed.connect(this.dispose, this);
     }
     dispose() {
@@ -241,13 +244,29 @@ export class Persona {
     _handleMessageChunk(event) {
         const streamingMessage = this._streamingMessage.get(event.data.messageId);
         if (streamingMessage) {
-            streamingMessage.update({ body: event.data.fullContent });
+            if (!this._model.updateMessage) {
+                streamingMessage.update({ body: event.data.fullContent });
+            }
+            else {
+                this._model.updateMessage(streamingMessage.id, {
+                    ...streamingMessage.content,
+                    body: event.data.fullContent
+                });
+            }
         }
     }
     _handleMessageComplete(event) {
         const streamingMessage = this._streamingMessage.get(event.data.messageId);
         if (streamingMessage) {
-            streamingMessage.update({ body: event.data.content });
+            if (!this._model.updateMessage) {
+                streamingMessage.update({ body: event.data.content });
+            }
+            else {
+                this._model.updateMessage(streamingMessage.id, {
+                    ...streamingMessage.content,
+                    body: event.data.content
+                });
+            }
             this._streamingMessage.delete(event.data.messageId);
         }
     }
@@ -363,34 +382,47 @@ export class Persona {
         }
         context.status = status;
         const displayName = context.title ?? context.toolName;
-        message.update({
-            mime_model: {
-                data: {
-                    'application/vnd.jupyter.chat.components': 'grouped-tool-calls'
-                },
-                metadata: {
-                    toolCalls: [
-                        {
-                            toolCallId: context.toolCallId,
-                            title: context.summary
-                                ? `${displayName} : ${context.summary}`
-                                : displayName,
-                            kind: context.toolName,
-                            status: context.status,
-                            rawInput: context.input,
-                            rawOutput: output,
-                            sessionId: this._model.name,
-                            permissionStatus: status === 'awaiting_approval' ? 'pending' : 'resolved',
-                            ...(status === 'awaiting_approval' && {
-                                permissionOptions: [
-                                    { optionId: 'approve', name: 'Approve', kind: 'allow_once' },
-                                    { optionId: 'reject', name: 'Reject', kind: 'reject_once' }
-                                ]
-                            })
-                        }
-                    ]
-                }
+        const mime_model = {
+            data: {
+                'application/vnd.jupyter.chat.components': 'grouped-tool-calls'
+            },
+            metadata: {
+                toolCalls: [
+                    {
+                        toolCallId: context.toolCallId,
+                        title: context.summary
+                            ? `${displayName} : ${context.summary}`
+                            : displayName,
+                        kind: context.toolName,
+                        status: context.status,
+                        rawInput: context.input,
+                        rawOutput: output,
+                        sessionId: this._model.name,
+                        permissionStatus: status === 'awaiting_approval' ? 'pending' : 'resolved',
+                        ...(status === 'awaiting_approval' && {
+                            permissionOptions: [
+                                { optionId: 'approve', name: 'Approve', kind: 'allow_once' },
+                                { optionId: 'reject', name: 'Reject', kind: 'reject_once' }
+                            ]
+                        })
+                    }
+                ]
             }
+        };
+        if (!this._model.updateMessage) {
+            message.update({ mime_model });
+        }
+        else {
+            this._model.updateMessage(message.id, {
+                ...message.content,
+                mime_model
+            });
+        }
+    }
+    sendSystemMessage(body) {
+        this._model.sendMessage({
+            body,
+            sender: this._persona
         });
     }
     /**

package/lib/tokens.d.ts

@@ -51,6 +51,10 @@ export interface IPersona {
      * Called after restoring a saved chat.
      */
     rebuildHistory(): Promise<void>;
+    /**
+     * Adds an assistant message to the chat (used by chat commands).
+     */
+    sendSystemMessage(body: string): void;
 }
 /**
  * Registry mapping chat models to their persona.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jupyternaut/persona",
-  "version": "0.20.0",
+  "version": "0.20.1",
   "description": "AI code completions and chat for JupyterLite",
   "keywords": [
     "jupyter",
@@ -58,7 +58,7 @@
     "@jupyterlab/statusbar": "^4.5.8",
     "@jupyterlab/translation": "^4.5.8",
     "@jupyterlab/ui-components": "^4.5.8",
-    "@jupyternaut/agent": "^0.20.0",
+    "@jupyternaut/agent": "^0.20.1",
     "@lumino/commands": "^2.3.2",
     "@lumino/coreutils": "^2.2.1",
     "@lumino/disposable": "^2.1.4",
@@ -67,6 +67,7 @@
     "@mui/icons-material": "^7",
     "@mui/material": "^7",
     "ai": "^7.0.106",
+    "jupyter-chat-components": "^0.6.0",
     "jupyter-mcp-manager": "^0.2.0",
     "jupyter-secrets-manager": "^0.5.0",
     "react": "^18.3.1"
@@ -101,10 +102,18 @@
         "bundled": true,
         "singleton": true
       },
+      "@jupyter/chat": {
+        "bundled": false,
+        "singleton": true
+      },
       "@jupyternaut/agent": {
         "bundled": true,
         "singleton": true
       },
+      "jupyter-chat-components": {
+        "bundled": false,
+        "singleton": true
+      },
       "jupyter-mcp-manager": {
         "bundled": false,
         "singleton": true

package/src/chat-commands/index.ts

@@ -0,0 +1,2 @@
+export * from './mention';
+export * from './skills';

package/src/chat-commands/skills.ts

@@ -0,0 +1,105 @@
+import { ChatCommand, IChatCommandProvider, IInputModel } from '@jupyter/chat';
+import type { ISkillRegistry } from '@jupyternaut/agent';
+import { CommandRegistry } from '@lumino/commands';
+
+import { CommandIds } from '../tokens';
+
+export class SkillsCommandProvider implements IChatCommandProvider {
+  constructor(options: SkillsCommandProvider.IOptions) {
+    this._skillRegistry = options.skillRegistry;
+    this._commands = options.commands;
+    this._sendSystemMessage = options.sendSystemMessage;
+    this._isDefault = options.isDefault;
+  }
+
+  public id: string = '@jupyternaut/persona:skills-command';
+
+  async listCommandCompletions(
+    inputModel: IInputModel
+  ): Promise<ChatCommand[]> {
+    if (!this._isActive(inputModel)) {
+      return [];
+    }
+
+    const match = inputModel.currentWord?.match(this._regex)?.[0];
+    if (!match) {
+      return [];
+    }
+
+    if (this._command.name.startsWith(match)) {
+      return [this._command];
+    }
+
+    return [];
+  }
+
+  async onSubmit(inputModel: IInputModel): Promise<void> {
+    if (!this._isActive(inputModel)) {
+      return;
+    }
+
+    const trimmed = inputModel.value.trim();
+    const match = trimmed.match(/^\/skills(?:\s+(.+))?$/);
+    if (!match) {
+      return;
+    }
+
+    if (this._commands.hasCommand(CommandIds.refreshSkills)) {
+      await this._commands.execute(CommandIds.refreshSkills);
+    }
+
+    const query = match[1]?.trim();
+    const filtered = this._skillRegistry.listSkills(query);
+
+    let body = '';
+    if (filtered.length === 0) {
+      body = query
+        ? `No skills found matching "${query}".`
+        : 'No skills are currently registered.';
+    } else {
+      const heading = query
+        ? `Skills matching "${query}" (${filtered.length}):`
+        : `Available skills (${filtered.length}):`;
+      const lines = filtered.map(
+        skill => `- \`${skill.name}\` — ${skill.description}`
+      );
+      body = [heading, '', ...lines].join('\n');
+    }
+
+    const chatName = inputModel.chatContext?.name;
+    if (chatName) {
+      this._sendSystemMessage(chatName, body);
+    }
+
+    // Prevent the message to be actually sent.
+    inputModel.value = '';
+    inputModel.clearAttachments();
+    inputModel.clearMentions();
+  }
+
+  private _isActive(inputModel: IInputModel): boolean {
+    const chatName = inputModel.chatContext?.name;
+    return !!chatName && this._isDefault(chatName);
+  }
+
+  private _command: ChatCommand = {
+    name: '/skills',
+    providerId: this.id,
+    description: 'List available skills'
+  };
+
+  private _regex: RegExp = /^\/\w*$/;
+  private _commands: CommandRegistry;
+  private _skillRegistry: ISkillRegistry;
+  private _sendSystemMessage: (chatName: string, body: string) => void;
+  private _isDefault: (chatName: string) => boolean;
+}
+
+export namespace SkillsCommandProvider {
+  export interface IOptions {
+    skillRegistry: ISkillRegistry;
+    commands: CommandRegistry;
+    sendSystemMessage: (chatName: string, body: string) => void;
+    isDefault: (chatName: string) => boolean;
+  }
+}

package/src/index.ts

@@ -1,3 +1,27 @@
+import { IChatTracker, IChatPanel, IChatCommandRegistry } from '@jupyter/chat';
+
+import {
+  ILayoutRestorer,
+  JupyterFrontEnd,
+  JupyterFrontEndPlugin
+} from '@jupyterlab/application';
+
+import { ICommandPalette, IThemeManager } from '@jupyterlab/apputils';
+
+import { ICompletionProviderManager } from '@jupyterlab/completer';
+
+import { IDocumentManager } from '@jupyterlab/docmanager';
+
+import { ISettingRegistry } from '@jupyterlab/settingregistry';
+
+import { IStatusBar } from '@jupyterlab/statusbar';
+
+import { PathExt } from '@jupyterlab/coreutils';
+
+import { ITranslator, nullTranslator } from '@jupyterlab/translation';
+
+import { IFormRendererRegistry, settingsIcon } from '@jupyterlab/ui-components';
+
 import {
   anthropicProvider,
   createBrowserFetchTool,
@@ -25,37 +49,15 @@ import {
 
 import type { IAISecretsAccess } from '@jupyternaut/agent';
 
-import {
-  ILayoutRestorer,
-  JupyterFrontEnd,
-  JupyterFrontEndPlugin
-} from '@jupyterlab/application';
-
-import { IChatTracker, IChatPanel, IChatCommandRegistry } from '@jupyter/chat';
-
-import { ICommandPalette, IThemeManager } from '@jupyterlab/apputils';
-
-import { ICompletionProviderManager } from '@jupyterlab/completer';
-
-import { IDocumentManager } from '@jupyterlab/docmanager';
-
-import { ISettingRegistry } from '@jupyterlab/settingregistry';
-
-import { IStatusBar } from '@jupyterlab/statusbar';
-
-import { PathExt } from '@jupyterlab/coreutils';
-
-import { ITranslator, nullTranslator } from '@jupyterlab/translation';
-
-import { IFormRendererRegistry, settingsIcon } from '@jupyterlab/ui-components';
-
 import { DisposableSet } from '@lumino/disposable';
 
+import { IComponentsRendererFactory } from 'jupyter-chat-components';
+
 import { IMcpManager } from 'jupyter-mcp-manager';
 
 import { ISecretsManager, SecretsManager } from 'jupyter-secrets-manager';
 
-import { MentionCommandProvider } from './chat-commands/mention';
+import { MentionCommandProvider, SkillsCommandProvider } from './chat-commands';
 
 import { AICompletionProvider } from './completion';
 
@@ -271,6 +273,54 @@ const persona: JupyterFrontEndPlugin<void> = {
   }
 };
 
+/**
+ * Registers groupedToolCall callbacks to route tool call approval decisions
+ * to the correct persona's agent manager.
+ */
+const chatComponentsCallbacks: JupyterFrontEndPlugin<void> = {
+  id: '@jupyternaut/persona:chat-components-callbacks',
+  description: 'Register chat components callbacks for the persona.',
+  autoStart: true,
+  requires: [IPersonaRegistry],
+  optional: [IChatTracker, IComponentsRendererFactory],
+  activate: (
+    _app: JupyterFrontEnd,
+    personaRegistry: IPersonaRegistry,
+    chatTracker: IChatTracker | null,
+    chatComponentsFactory?: IComponentsRendererFactory
+  ): void => {
+    if (!chatComponentsFactory) {
+      return;
+    }
+
+    const findPersona = (sessionId: string) => {
+      const model = chatTracker?.find(
+        chat => chat.model.name === sessionId
+      )?.model;
+      return model ? personaRegistry.get(model) : undefined;
+    };
+
+    chatComponentsFactory.groupedToolCallCallbacks = {
+      ...chatComponentsFactory.groupedToolCallCallbacks,
+      toolCallPermissionDecision: (
+        sessionId: string,
+        toolCallId: string,
+        optionId: string
+      ) => {
+        const agent = findPersona(sessionId)?.agentManager;
+        if (!agent) {
+          return;
+        }
+        if (optionId === 'approve') {
+          agent.approveToolCall(toolCallId);
+        } else {
+          agent.rejectToolCall(toolCallId);
+        }
+      }
+    };
+  }
+};
+
 /**
  * Clear chat command plugin.
  */
@@ -284,6 +334,52 @@ const mentionCommandPlugin: JupyterFrontEndPlugin<void> = {
   }
 };
 
+/**
+ * Skills chat command plugin.
+ */
+const skillsCommandPlugin: JupyterFrontEndPlugin<void> = {
+  id: '@jupyternaut/persona:skills-command',
+  description: 'Register the /skills chat command.',
+  autoStart: true,
+  requires: [IChatCommandRegistry, ISkillRegistry, IPersonaRegistry],
+  optional: [IChatTracker],
+  activate: (
+    app: JupyterFrontEnd,
+    registry: IChatCommandRegistry,
+    skillRegistry: ISkillRegistry,
+    personaRegistry: IPersonaRegistry,
+    chatTracker: IChatTracker | null
+  ) => {
+    const findModel = (chatName: string) =>
+      chatTracker?.find(c => c.model.name === chatName)?.model;
+
+    const isDefault = (chatName: string) => {
+      const model = findModel(chatName);
+      if (!model) {
+        return false;
+      }
+      const persona = personaRegistry.get(model);
+      return persona ? !persona.requireMention : false;
+    };
+
+    const sendSystemMessage = (chatName: string, body: string) => {
+      const model = findModel(chatName);
+      if (model) {
+        personaRegistry.get(model)?.sendSystemMessage(body);
+      }
+    };
+
+    registry.addProvider(
+      new SkillsCommandProvider({
+        skillRegistry,
+        commands: app.commands,
+        isDefault,
+        sendSystemMessage
+      })
+    );
+  }
+};
+
 /**
  * A plugin to provide the agent manager factory and completion provider.
  * These objects require the secrets manager token with the same namespace.
@@ -695,7 +791,9 @@ export default [
   // Persona
   personaRegistry,
   persona,
+  chatComponentsCallbacks,
   mentionCommandPlugin,
+  skillsCommandPlugin,
   // Settings
   settingsModel,
   settingsPanelPlugin,

package/src/persona.ts

@@ -25,8 +25,6 @@ import {
   modelSupportsPdf
 } from '@jupyternaut/agent';
 
-import type { IObservableDisposable } from '@lumino/disposable';
-
 import { ISignal, Signal } from '@lumino/signaling';
 
 import type { ModelMessage, UserContent } from 'ai';
@@ -173,20 +171,21 @@ export class Persona implements IPersona {
     this._providerRegistry = options.providerRegistry;
     this._documentManager = options.documentManager;
 
-    for (const message of options.model.messages) {
-      this._respondedToIds.add(message.id);
-    }
-
     this._agent.agentEvent.connect(this._onAgentEvent, this);
     this._agent.activeProviderChanged.connect(
       this._onActiveProviderChanged,
       this
     );
-    this._model.messagesUpdated.connect(this._onMessagesUpdated, this);
-    (this._model as unknown as IObservableDisposable).disposed.connect(
-      this.dispose,
-      this
-    );
+
+    // Wait for the chat to be ready before connect to message update.
+    this._model.ready.then(() => {
+      for (const message of this._model.messages) {
+        this._respondedToIds.add(message.id);
+      }
+      this._model.messagesUpdated.connect(this._onMessagesUpdated, this);
+    });
+
+    this._model.disposed.connect(this.dispose, this);
   }
 
   dispose(): void {
@@ -378,7 +377,14 @@ export class Persona implements IPersona {
   ): void {
     const streamingMessage = this._streamingMessage.get(event.data.messageId);
     if (streamingMessage) {
-      streamingMessage.update({ body: event.data.fullContent });
+      if (!this._model.updateMessage) {
+        streamingMessage.update({ body: event.data.fullContent });
+      } else {
+        this._model.updateMessage(streamingMessage.id, {
+          ...streamingMessage.content,
+          body: event.data.fullContent
+        });
+      }
     }
   }
 
@@ -387,7 +393,15 @@ export class Persona implements IPersona {
   ): void {
     const streamingMessage = this._streamingMessage.get(event.data.messageId);
     if (streamingMessage) {
-      streamingMessage.update({ body: event.data.content });
+      if (!this._model.updateMessage) {
+        streamingMessage.update({ body: event.data.content });
+      } else {
+        this._model.updateMessage(streamingMessage.id, {
+          ...streamingMessage.content,
+          body: event.data.content
+        });
+      }
+
       this._streamingMessage.delete(event.data.messageId);
     }
   }
@@ -545,35 +559,48 @@ export class Persona implements IPersona {
     }
     context.status = status;
     const displayName = context.title ?? context.toolName;
-    message.update({
-      mime_model: {
-        data: {
-          'application/vnd.jupyter.chat.components': 'grouped-tool-calls'
-        },
-        metadata: {
-          toolCalls: [
-            {
-              toolCallId: context.toolCallId,
-              title: context.summary
-                ? `${displayName} : ${context.summary}`
-                : displayName,
-              kind: context.toolName,
-              status: context.status,
-              rawInput: context.input,
-              rawOutput: output,
-              sessionId: this._model.name,
-              permissionStatus:
-                status === 'awaiting_approval' ? 'pending' : 'resolved',
-              ...(status === 'awaiting_approval' && {
-                permissionOptions: [
-                  { optionId: 'approve', name: 'Approve', kind: 'allow_once' },
-                  { optionId: 'reject', name: 'Reject', kind: 'reject_once' }
-                ]
-              })
-            }
-          ]
-        }
+    const mime_model = {
+      data: {
+        'application/vnd.jupyter.chat.components': 'grouped-tool-calls'
+      },
+      metadata: {
+        toolCalls: [
+          {
+            toolCallId: context.toolCallId,
+            title: context.summary
+              ? `${displayName} : ${context.summary}`
+              : displayName,
+            kind: context.toolName,
+            status: context.status,
+            rawInput: context.input,
+            rawOutput: output,
+            sessionId: this._model.name,
+            permissionStatus:
+              status === 'awaiting_approval' ? 'pending' : 'resolved',
+            ...(status === 'awaiting_approval' && {
+              permissionOptions: [
+                { optionId: 'approve', name: 'Approve', kind: 'allow_once' },
+                { optionId: 'reject', name: 'Reject', kind: 'reject_once' }
+              ]
+            })
+          }
+        ]
       }
+    };
+    if (!this._model.updateMessage) {
+      message.update({ mime_model });
+    } else {
+      this._model.updateMessage(message.id, {
+        ...message.content,
+        mime_model
+      });
+    }
+  }
+
+  sendSystemMessage(body: string): void {
+    this._model.sendMessage({
+      body,
+      sender: this._persona
     });
   }
 

package/src/tokens.ts

@@ -67,6 +67,10 @@ export interface IPersona {
    * Called after restoring a saved chat.
    */
   rebuildHistory(): Promise<void>;
+  /**
+   * Adds an assistant message to the chat (used by chat commands).
+   */
+  sendSystemMessage(body: string): void;
 }
 
 /**