@jupyterlite/ai 0.11.1 → 0.12.0

package/src/chat-model.ts

@@ -3,7 +3,7 @@ import {
   IActiveCellManager,
   IAttachment,
   IChatContext,
-  IChatMessage,
+  IMessageContent,
   INewMessage,
   IUser
 } from '@jupyter/chat';
@@ -160,7 +160,8 @@ export class AIChatModel extends AbstractChatModel {
       messages: this.messages,
       stopStreaming: () => this.stopStreaming(),
       clearMessages: () => this.clearMessages(),
-      agentManager: this._agentManager
+      agentManager: this._agentManager,
+      addSystemMessage: (body: string) => this.addSystemMessage(body)
     };
   }
 
@@ -180,13 +181,34 @@ export class AIChatModel extends AbstractChatModel {
     this._agentManager.clearHistory();
   };
 
+  /**
+   * Adds a non-user message to the chat (used by chat commands).
+   */
+  addSystemMessage(body: string): void {
+    const message: IMessageContent = {
+      body,
+      sender: this._getAIUser(),
+      id: UUID.uuid4(),
+      time: Date.now() / 1000,
+      type: 'msg',
+      raw_time: false
+    };
+    this.messageAdded(message);
+  }
+
   /**
    * Sends a message to the AI and generates a response.
    * @param message The user message to send
    */
   async sendMessage(message: INewMessage): Promise<void> {
+    const hasBody = message.body.trim().length > 0;
+    const hasAttachments = this.input.attachments.length > 0;
+    if (!hasBody && !hasAttachments) {
+      return;
+    }
+
     // Add user message to chat
-    const userMessage: IChatMessage = {
+    const userMessage: IMessageContent = {
       body: message.body,
       sender: this.user || { username: 'user', display_name: 'User' },
       id: UUID.uuid4(),
@@ -199,7 +221,7 @@ export class AIChatModel extends AbstractChatModel {
 
     // Check if we have valid configuration
     if (!this._agentManager.hasValidConfig()) {
-      const errorMessage: IChatMessage = {
+      const errorMessage: IMessageContent = {
         body: 'Please configure your AI settings first. Open the AI Settings to set your API key and model.',
         sender: this._getAIUser(),
         id: UUID.uuid4(),
@@ -230,7 +252,7 @@ export class AIChatModel extends AbstractChatModel {
 
       await this._agentManager.generateResponse(enhancedMessage);
     } catch (error) {
-      const errorMessage: IChatMessage = {
+      const errorMessage: IMessageContent = {
         body: `Error generating AI response: ${(error as Error).message}`,
         sender: this._getAIUser(),
         id: UUID.uuid4(),
@@ -304,7 +326,7 @@ export class AIChatModel extends AbstractChatModel {
    * @param event Event containing the message start data
    */
   private _handleMessageStart(event: IAgentEvent<'message_start'>): void {
-    const aiMessage: IChatMessage = {
+    const aiMessage: IMessageContent = {
       body: '',
       sender: this._getAIUser(),
       id: event.data.messageId,
@@ -366,6 +388,19 @@ export class AIChatModel extends AbstractChatModel {
             return `query: "${parsedInput.query}"`;
           }
           break;
+        case 'discover_skills':
+          if (parsedInput.query) {
+            return `query: "${parsedInput.query}"`;
+          }
+          break;
+        case 'load_skill':
+          if (parsedInput.name) {
+            if (parsedInput.resource) {
+              return `${parsedInput.name} (${parsedInput.resource})`;
+            }
+            return parsedInput.name;
+          }
+          break;
       }
     } catch {
       // If parsing fails, return empty string
@@ -396,7 +431,7 @@ export class AIChatModel extends AbstractChatModel {
 
     this._toolContexts.set(event.data.callId, context);
 
-    const toolCallMessage: IChatMessage = {
+    const toolCallMessage: IMessageContent = {
       body: Private.buildToolCallHtml({
         toolName: context.toolName,
         input: context.input,
@@ -496,8 +531,7 @@ export class AIChatModel extends AbstractChatModel {
     }
 
     context.status = status;
-    this.messageAdded({
-      ...existingMessage,
+    existingMessage.update({
       body: Private.buildToolCallHtml({
         toolName: context.toolName,
         input: context.input,
@@ -793,7 +827,7 @@ export class AIChatModel extends AbstractChatModel {
   private _user: IUser;
   private _toolContexts: Map<string, IToolExecutionContext> = new Map();
   private _agentManager: AgentManager;
-  private _currentStreamingMessage: IChatMessage | null = null;
+  private _currentStreamingMessage: IMessageContent | null = null;
   private _nameChanged = new Signal<AIChatModel, string>(this);
   private _trans: TranslationBundle;
 }
@@ -989,6 +1023,10 @@ export namespace AIChatModel {
      * The clear messages callback.
      */
     clearMessages: () => void;
+    /**
+     * Adds an assistant/system message to the chat.
+     */
+    addSystemMessage: (body: string) => void;
     /**
      * The agent manager of the chat.
      */

package/src/index.ts

@@ -9,8 +9,10 @@ import {
   ActiveCellManager,
   AttachmentOpenerRegistry,
   chatIcon,
+  ChatCommandRegistry,
   ChatWidget,
   IAttachmentOpenerRegistry,
+  IChatCommandRegistry,
   IInputToolbarRegistryFactory,
   InputToolbarRegistry,
   MultiChatPanel
@@ -34,6 +36,8 @@ import { ISettingRegistry } from '@jupyterlab/settingregistry';
 
 import { IStatusBar } from '@jupyterlab/statusbar';
 
+import { PathExt } from '@jupyterlab/coreutils';
+
 import {
   ITranslator,
   nullTranslator,
@@ -49,11 +53,15 @@ 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 { ClearCommandProvider } from './chat-commands/clear';
+import { SkillsCommandProvider } from './chat-commands/skills';
+
 import { ProviderRegistry } from './providers/provider-registry';
 
 import { ApprovalButtons } from './approval-buttons';
@@ -65,6 +73,7 @@ import {
   IAgentManagerFactory,
   IProviderRegistry,
   IToolRegistry,
+  ISkillRegistry,
   SECRETS_NAMESPACE,
   IAISettingsModel,
   IChatModelRegistry,
@@ -92,6 +101,8 @@ import {
 
 import { AISettingsModel } from './models/settings-model';
 
+import { loadSkillsFromPaths, SkillRegistry } from './skills';
+
 import { DiffManager } from './diff-manager';
 
 import { ToolRegistry } from './tools/tool-registry';
@@ -100,6 +111,7 @@ import {
   createDiscoverCommandsTool,
   createExecuteCommandTool
 } from './tools/commands';
+import { createDiscoverSkillsTool, createLoadSkillTool } from './tools/skills';
 
 import { AISettingsWidget } from './widgets/ai-settings';
 
@@ -183,6 +195,54 @@ const genericProviderPlugin: JupyterFrontEndPlugin<void> = {
   }
 };
 
+/**
+ * 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 registry.
  */
@@ -226,7 +286,8 @@ const plugin: JupyterFrontEndPlugin<void> = {
     IRenderMimeRegistry,
     IInputToolbarRegistryFactory,
     IChatModelRegistry,
-    IAISettingsModel
+    IAISettingsModel,
+    IChatCommandRegistry
   ],
   optional: [
     IThemeManager,
@@ -241,6 +302,7 @@ const plugin: JupyterFrontEndPlugin<void> = {
     inputToolbarFactory: IInputToolbarRegistryFactory,
     modelRegistry: IChatModelRegistry,
     settingsModel: AISettingsModel,
+    chatCommandRegistry: IChatCommandRegistry,
     themeManager?: IThemeManager,
     restorer?: ILayoutRestorer,
     labShell?: ILabShell,
@@ -275,6 +337,7 @@ const plugin: JupyterFrontEndPlugin<void> = {
       themeManager: themeManager ?? null,
       inputToolbarFactory,
       attachmentOpenerRegistry,
+      chatCommandRegistry,
       createModel: async (name?: string) => {
         const model = modelRegistry.createModel(name);
         return { model };
@@ -400,6 +463,7 @@ const plugin: JupyterFrontEndPlugin<void> = {
       attachmentOpenerRegistry,
       inputToolbarFactory,
       settingsModel,
+      chatCommandRegistry,
       tracker,
       modelRegistry,
       trans,
@@ -416,6 +480,7 @@ function registerCommands(
   attachmentOpenerRegistry: IAttachmentOpenerRegistry,
   inputToolbarFactory: IInputToolbarRegistryFactory,
   settingsModel: AISettingsModel,
+  chatCommandRegistry: IChatCommandRegistry,
   tracker: WidgetTracker<MainAreaChat | ChatWidget>,
   modelRegistry: IChatModelRegistry,
   trans: TranslationBundle,
@@ -481,7 +546,8 @@ function registerCommands(
         rmRegistry,
         themeManager: themeManager ?? null,
         inputToolbarRegistry: inputToolbarFactory.create(),
-        attachmentOpenerRegistry
+        attachmentOpenerRegistry,
+        chatCommandRegistry
       });
       const widget = new MainAreaChat({
         content,
@@ -666,6 +732,7 @@ const agentManagerFactory: JupyterFrontEndPlugin<AgentManagerFactory> =
     provides: IAgentManagerFactory,
     requires: [IAISettingsModel, IProviderRegistry],
     optional: [
+      ISkillRegistry,
       ICommandPalette,
       ICompletionProviderManager,
       ILayoutRestorer,
@@ -677,7 +744,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 +755,7 @@ const agentManagerFactory: JupyterFrontEndPlugin<AgentManagerFactory> =
       const trans = (translator ?? nullTranslator).load('jupyterlite_ai');
       const agentManagerFactory = new AgentManagerFactory({
         settingsModel,
+        skillRegistry,
         secretsManager,
         token
       });
@@ -797,13 +866,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 +902,13 @@ const toolRegistry: JupyterFrontEndPlugin<IToolRegistry> = {
 
     toolRegistry.add('discover_commands', discoverCommandsTool);
     toolRegistry.add('execute_command', executeCommandTool);
+    if (skillRegistry) {
+      toolRegistry.add(
+        'discover_skills',
+        createDiscoverSkillsTool(skillRegistry)
+      );
+      toolRegistry.add('load_skill', createLoadSkillTool(skillRegistry));
+    }
 
     return toolRegistry;
   }
@@ -900,6 +994,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 +1141,17 @@ export default [
   genericProviderPlugin,
   settingsModel,
   diffManager,
+  chatCommandRegistryPlugin,
+  clearCommandPlugin,
+  skillRegistryPlugin,
+  skillsCommandPlugin,
   chatModelRegistry,
   plugin,
   toolRegistry,
   agentManagerFactory,
   inputToolbarFactory,
-  completionStatus
+  completionStatus,
+  skillsPlugin
 ];
 
 // Export extension points for other extensions to use

package/src/models/settings-model.ts

@@ -60,6 +60,8 @@ export interface IAIConfig {
   showCellDiff: boolean;
   showFileDiff: boolean;
   diffDisplayMode: 'split' | 'unified';
+  // Paths to directories containing agent skills
+  skillsPaths: string[];
 }
 
 export class AISettingsModel extends VDomModel {
@@ -78,6 +80,7 @@ export class AISettingsModel extends VDomModel {
     showCellDiff: true,
     showFileDiff: true,
     diffDisplayMode: 'split',
+    skillsPaths: ['.agents/skills', '_agents/skills'],
     commandsRequiringApproval: [
       'notebook:restart-run-all',
       'notebook:run-cell',
@@ -113,7 +116,7 @@ You're designed to be a capable partner for data science, research, and developm
 
 **⚡ Kernel Management:**
 - Start new kernels with specified language or kernel name
-- Execute code directly in running kernels without creating cells
+- Execute code directly in a kernel using jupyterlab-ai-commands execution commands (not console), without creating cells
 - List running kernels and monitor their status
 - Manage kernel lifecycle (start, monitor, shutdown)
 
@@ -130,18 +133,32 @@ You're designed to be a capable partner for data science, research, and developm
 - Help with both quick fixes and long-term project planning
 
 ## How You Work
-You can actively interact with the user's JupyterLab environment using specialized tools. When asked to perform actions, you can:
-- Execute operations directly in notebooks
-- Create and modify files as needed
-- Run code and analyze results
-- Make systematic changes across multiple files
+You interact with the user's JupyterLab environment primarily through the command system:
+- Use 'discover_commands' to find available JupyterLab commands
+- Use 'execute_command' to perform operations
+- For file and notebook operations, use commands from the jupyterlab-ai-commands extension (prefixed with 'jupyterlab-ai-commands:')
+- These commands provide comprehensive file and notebook manipulation: create, read, edit files/notebooks, manage cells, run code, etc.
+- You can make systematic changes across multiple files and perform complex multi-step operations
+- Skills are available via the skills tools: discover_skills (list) and load_skill (load instructions/resources)
+
+## Tool & Skill Use Policy
+- When tools or skills are available and the task requires actions or environment-specific facts, use them instead of guessing
+- Never guess command IDs. Always use discover_commands with a relevant query before execute_command, unless you already discovered the command earlier in this conversation
+- If a preloaded skills snapshot is provided in the system prompt, use it instead of calling discover_skills to list skills
+- Only call discover_skills if the user explicitly asks for the latest list or you need to verify a skill not in the snapshot
+- When a skill is relevant, call load_skill with the skill name to load instructions; if it returns a non-empty resources array, load each listed resource with load_skill before proceeding
+- If you're unsure how to perform a request, discover relevant commands (discover_commands with task keywords)
+- Use a relevant skill even when the user doesn't explicitly mention it
+- Prefer the single most relevant tool or skill; if multiple could apply, ask a brief clarifying question
+- Ask for missing required inputs before calling a tool or skill
+- Before calling a tool or skill, briefly state why you're calling it
 
 ## Code Execution Strategy
 When asked to run code or perform computations, choose the most appropriate approach:
-- **For quick computations or one-off code execution**: Use kernel commands to start a kernel and execute code directly, without creating notebook files. This is ideal for calculations, data lookups, or testing code snippets.
+- **For quick computations or one-off code execution**: Use the kernel execution commands from jupyterlab-ai-commands to run code directly (no notebook/console). Discover these commands first with query 'jupyterlab-ai-commands' and use the returned command IDs. This is ideal for calculations, data lookups, or testing code snippets.
 - **For work that should be saved**: Create or use notebooks when the user needs a persistent record of their work, wants to iterate on code, or is building something they'll return to later.
 
-This means if the user asks you to "calculate the factorial of 100" or "check what library version is installed", run that directly in a kernel rather than creating a new notebook file.
+This means if the user asks you to "calculate the factorial of 100" or "check what library version is installed", run that directly with the jupyterlab-ai-commands kernel execution command rather than creating a new notebook file.
 
 ## Your Approach
 - **Context-aware**: You understand the user is working in a data science/research environment
@@ -150,6 +167,23 @@ This means if the user asks you to "calculate the factorial of 100" or "check wh
 - **Collaborative**: You are a pair programming partner, not just a code generator
 
 ## Communication Style & Agent Behavior
+IMPORTANT: Follow this message flow pattern for better user experience:
+
+1. FIRST: Explain what you're going to do and your approach
+2. THEN: Execute tools (these will show automatically with step numbers)
+3. FINALLY: Provide a concise summary of what was accomplished
+
+Example flow:
+- "I'll help you create a notebook with example cells. Let me first create the file structure, then add Python and Markdown cells."
+- [Tool executions happen with automatic step display]
+- "Successfully created your notebook with 3 cells: a title, code example, and visualization cell."
+
+Guidelines:
+- Start responses with your plan/approach before tool execution
+- Let the system handle tool execution display (don't duplicate details)
+- End with a brief summary of accomplishments
+- Use natural, conversational tone throughout
+
 - **Conversational**: You maintain a friendly, natural conversation flow throughout the interaction
 - **Progress Updates**: You write brief progress messages between tool uses that appear directly in the conversation
 - **No Filler**: You avoid empty acknowledgments like "Sounds good!" or "Okay, I will..." - you get straight to work
@@ -168,13 +202,28 @@ This means if the user asks you to "calculate the factorial of 100" or "check wh
 - You keep users informed of progress while staying focused on the task
 
 ## Multi-Step Task Handling
-When users request complex tasks that require multiple steps (like "create a notebook with example cells"), you use tools in sequence to accomplish the complete task. For example:
-- First use create_notebook to create the notebook
-- Then use add_code_cell or add_markdown_cell to add cells
-- Use set_cell_content to add content to cells as needed
-- Use run_cell to execute code when appropriate
-
-Always think through multi-step tasks and use tools to fully complete the user's request rather than stopping after just one action.
+When users request complex tasks, you use the command system to accomplish them:
+- For file and notebook operations, use discover_commands with query 'jupyterlab-ai-commands' to find the curated set of AI commands (~17 commands)
+- For other JupyterLab operations (terminal, launcher, UI), use specific keywords like 'terminal', 'launcher', etc.
+- IMPORTANT: Always use 'jupyterlab-ai-commands' as the query for file/notebook tasks - this returns a focused set instead of 100+ generic commands
+- For example, to create a notebook with cells:
+  1. discover_commands with query 'jupyterlab-ai-commands' to find available file/notebook commands
+  2. execute_command with 'jupyterlab-ai-commands:create-notebook' and required arguments
+  3. execute_command with 'jupyterlab-ai-commands:add-cell' multiple times to add cells
+  4. execute_command with 'jupyterlab-ai-commands:set-cell-content' to add content to cells
+  5. execute_command with 'jupyterlab-ai-commands:run-cell' when appropriate
+
+## Kernel Preference for Notebooks and Consoles
+When creating notebooks or consoles for a specific programming language, use the 'kernelPreference' argument:
+Only create consoles when the user explicitly asks for one; otherwise prefer the jupyterlab-ai-commands kernel execution commands for running code.
+- To specify by language: { "kernelPreference": { "language": "python" } } or { "kernelPreference": { "language": "julia" } }
+- To specify by kernel name: { "kernelPreference": { "name": "python3" } } or { "kernelPreference": { "name": "julia-1.10" } }
+- Example: execute_command with commandId="notebook:create-new" and args={ "kernelPreference": { "language": "python" } }
+- Example: execute_command with commandId="console:create" and args={ "kernelPreference": { "name": "python3" } }
+- Common kernel names: "python3" (Python), "julia-1.10" (Julia), "ir" (R), "xpython" (xeus-python)
+- If unsure of exact kernel name, prefer using "language" which will match any kernel supporting that language
+
+Always think through multi-step tasks and use commands to fully complete the user's request rather than stopping after just one action.
 
 You are ready to help users build something great!`,
     // Completion system prompt - also defined in schema/settings-model.json