@jupyterlite/ai 0.14.0 → 0.16.0

package/lib/chat-model-handler.d.ts

@@ -1,17 +1,15 @@
 import { ActiveCellManager } from '@jupyter/chat';
-import { TranslationBundle } from '@jupyterlab/translation';
-import { AgentManagerFactory } from './agent';
-import { AIChatModel } from './chat-model';
-import { AISettingsModel } from './models/settings-model';
-import { IChatModelHandler, IProviderRegistry, ITokenUsage, IToolRegistry } from './tokens';
 import { IDocumentManager } from '@jupyterlab/docmanager';
 import { IRenderMimeRegistry } from '@jupyterlab/rendermime';
+import { Contents } from '@jupyterlab/services';
+import { AIChatModel } from './chat-model';
+import type { IAgentManagerFactory, IAISettingsModel, IChatModelHandler, ICreateChatOptions, IProviderRegistry, IToolRegistry } from './tokens';
 /**
  * The chat model handler.
  */
 export declare class ChatModelHandler implements IChatModelHandler {
     constructor(options: ChatModelHandler.IOptions);
-    createModel(name: string, activeProvider: string, tokenUsage?: ITokenUsage): AIChatModel;
+    createModel(options: ICreateChatOptions): AIChatModel;
     /**
      * Getter/setter for the active cell manager.
      */
@@ -24,7 +22,7 @@ export declare class ChatModelHandler implements IChatModelHandler {
     private _providerRegistry?;
     private _rmRegistry;
     private _activeCellManager?;
-    private _trans;
+    private _contentsManager?;
 }
 export declare namespace ChatModelHandler {
     interface IOptions {
@@ -35,11 +33,11 @@ export declare namespace ChatModelHandler {
         /**
          * The agent manager factory.
          */
-        agentManagerFactory: AgentManagerFactory;
+        agentManagerFactory: IAgentManagerFactory;
         /**
          * AI settings model for configuration
          */
-        settingsModel: AISettingsModel;
+        settingsModel: IAISettingsModel;
         /**
          * Optional tool registry for managing available tools
          */
@@ -57,8 +55,8 @@ export declare namespace ChatModelHandler {
          */
         activeCellManager?: ActiveCellManager | undefined;
         /**
-         * The application language translation bundle.
+         * The contents manager.
          */
-        trans: TranslationBundle;
+        contentsManager?: Contents.IManager;
     }
 }

package/lib/chat-model-handler.js

@@ -11,9 +11,10 @@ export class ChatModelHandler {
         this._providerRegistry = options.providerRegistry;
         this._rmRegistry = options.rmRegistry;
         this._activeCellManager = options.activeCellManager;
-        this._trans = options.trans;
+        this._contentsManager = options.contentsManager;
     }
-    createModel(name, activeProvider, tokenUsage) {
+    createModel(options) {
+        const { name, activeProvider, tokenUsage, messages, autosave } = options;
         // Create Agent Manager first so it can be shared
         const agentManager = this._agentManagerFactory.createAgent({
             settingsModel: this._settingsModel,
@@ -30,8 +31,12 @@ export class ChatModelHandler {
             agentManager,
             activeCellManager: this._activeCellManager,
             documentManager: this._docManager,
-            trans: this._trans
+            contentsManager: this._contentsManager
         });
+        messages?.forEach(message => {
+            model.messageAdded({ ...message.content });
+        });
+        model.autosave = autosave ?? false;
         model.name = name;
         return model;
     }
@@ -51,5 +56,5 @@ export class ChatModelHandler {
     _providerRegistry;
     _rmRegistry;
     _activeCellManager;
-    _trans;
+    _contentsManager;
 }

package/lib/chat-model.d.ts

@@ -1,10 +1,8 @@
-import { AbstractChatModel, IActiveCellManager, IChatContext, INewMessage, IUser } from '@jupyter/chat';
+import { AbstractChatModel, IActiveCellManager, IAttachment, IChatContext, IMessageContent, INewMessage, IUser } from '@jupyter/chat';
 import { IDocumentManager } from '@jupyterlab/docmanager';
-import { TranslationBundle } from '@jupyterlab/translation';
+import { Contents } from '@jupyterlab/services';
 import { ISignal } from '@lumino/signaling';
-import { AgentManager } from './agent';
-import { AISettingsModel } from './models/settings-model';
-import { ITokenUsage } from './tokens';
+import type { IAgentManager, IAISettingsModel, ITokenUsage } from './tokens';
 /**
  * AI Chat Model implementation that provides chat functionality tool integration,
  * and MCP server support.
@@ -20,6 +18,15 @@ export declare class AIChatModel extends AbstractChatModel {
      */
     get name(): string;
     set name(value: string);
+    /**
+     * Whether to save the chat automatically.
+     */
+    get autosave(): boolean;
+    set autosave(value: boolean);
+    /**
+     * A signal emitting when the autosave flag changed.
+     */
+    get autosaveChanged(): ISignal<AIChatModel, boolean>;
     /**
      * A signal emitting when the chat name has changed.
      */
@@ -31,11 +38,19 @@ export declare class AIChatModel extends AbstractChatModel {
     /**
      * A signal emitting when the token usage changed.
      */
-    get tokenUsageChanged(): ISignal<AgentManager, ITokenUsage>;
+    get tokenUsageChanged(): ISignal<IAgentManager, ITokenUsage>;
     /**
      * Get the agent manager associated to the model.
      */
-    get agentManager(): AgentManager;
+    get agentManager(): IAgentManager;
+    /**
+     * Whether save/restore is available.
+     */
+    get saveAvailable(): boolean;
+    /**
+     * Dispose of the model.
+     */
+    dispose(): void;
     /**
      * Creates a chat context for the current conversation.
      */
@@ -57,6 +72,21 @@ export declare class AIChatModel extends AbstractChatModel {
      * @param message The user message to send
      */
     sendMessage(message: INewMessage): Promise<void>;
+    /**
+     * Save the chat as json file.
+     */
+    save: () => Promise<void>;
+    /**
+     * Restore the chat from a json file.
+     *
+     * @param silent - Whether a log should be displayed in the console if the
+     * restoration is not possible.
+     */
+    restore: (filepath: string, silent?: boolean) => Promise<boolean>;
+    /**
+     * Serialize the model for backup
+     */
+    private _serializeModel;
     /**
      * Gets the AI user information for system messages.
      */
@@ -149,7 +179,10 @@ export declare class AIChatModel extends AbstractChatModel {
     private _agentManager;
     private _currentStreamingMessage;
     private _nameChanged;
-    private _trans;
+    private _contentsManager?;
+    private _autosave;
+    private _autosaveChanged;
+    private _autosaveDebouncer;
 }
 /**
  * Namespace containing types and interfaces for AIChatModel.
@@ -166,11 +199,11 @@ export declare namespace AIChatModel {
         /**
          * Settings model for AI configuration
          */
-        settingsModel: AISettingsModel;
+        settingsModel: IAISettingsModel;
         /**
          * Optional agent manager for handling AI agent lifecycle
          */
-        agentManager: AgentManager;
+        agentManager: IAgentManager;
         /**
          * Optional active cell manager for Jupyter integration
          */
@@ -180,9 +213,13 @@ export declare namespace AIChatModel {
          */
         documentManager?: IDocumentManager;
         /**
-         * The application language translation bundle.
+         * The contents manager.
+         */
+        contentsManager?: Contents.IManager;
+        /**
+         * Whether to restore or not the message (default to true)
          */
-        trans: TranslationBundle;
+        restore?: boolean;
     }
     /**
      * The chat context for toolbar buttons.
@@ -203,6 +240,40 @@ export declare namespace AIChatModel {
         /**
          * The agent manager of the chat.
          */
-        agentManager: AgentManager;
+        agentManager: IAgentManager;
     }
+    /**
+     * The exported chat format.
+     */
+    type ExportedChat = {
+        /**
+         * Message list (user are only string to avoid duplication).
+         */
+        messages: IMessageContent<string, string>[];
+        /**
+         * The user list.
+         */
+        users: {
+            [id: string]: IUser;
+        };
+        /**
+         * The attachments of the chat.
+         */
+        attachments?: {
+            [id: string]: IAttachment;
+        };
+        /**
+         * The metadata associated to the chat.
+         */
+        metadata?: {
+            /**
+             * Provider of the chat.
+             */
+            provider?: string;
+            /**
+             * Whether the chat is automatically saved.
+             */
+            autosave?: boolean;
+        };
+    };
 }

package/lib/chat-model.js

@@ -2,6 +2,7 @@ import { AbstractChatModel } from '@jupyter/chat';
 import { PathExt } from '@jupyterlab/coreutils';
 import * as nbformat from '@jupyterlab/nbformat';
 import { UUID } from '@lumino/coreutils';
+import { Debouncer } from '@lumino/polling';
 import { Signal } from '@lumino/signaling';
 import { AI_AVATAR } from './icons';
 /**
@@ -25,12 +26,12 @@ export class AIChatModel extends AbstractChatModel {
         this._settingsModel = options.settingsModel;
         this._user = options.user;
         this._agentManager = options.agentManager;
-        this._trans = options.trans;
+        this._contentsManager = options.contentsManager;
         // Listen for agent events
         this._agentManager.agentEvent.connect(this._onAgentEvent, this);
         // Listen for settings changes to update chat behavior
         this._settingsModel.stateChanged.connect(this._onSettingsChanged, this);
-        this.setReady();
+        this._autosaveDebouncer = new Debouncer(this.save, 3000);
     }
     /**
      * Override the getter/setter of the name to add a signal when renaming a chat.
@@ -41,6 +42,37 @@ export class AIChatModel extends AbstractChatModel {
     set name(value) {
         super.name = value;
         this._nameChanged.emit(value);
+        if (!this.messages.length) {
+            const directory = this._settingsModel.config.chatBackupDirectory;
+            const filepath = PathExt.join(directory, `${this.name}.chat`);
+            this.restore(filepath, true);
+        }
+        this.setReady();
+    }
+    /**
+     * Whether to save the chat automatically.
+     */
+    get autosave() {
+        return this._autosave;
+    }
+    set autosave(value) {
+        this._autosave = value;
+        this._autosaveChanged.emit(value);
+        if (value) {
+            this.messagesUpdated.connect(this._autosaveDebouncer.invoke, this._autosaveDebouncer);
+            this.messageChanged.connect(this._autosaveDebouncer.invoke, this._autosaveDebouncer);
+            this._autosaveDebouncer.invoke();
+        }
+        else {
+            this.messagesUpdated.disconnect(this._autosaveDebouncer.invoke, this._autosaveDebouncer);
+            this.messageChanged.disconnect(this._autosaveDebouncer.invoke, this._autosaveDebouncer);
+        }
+    }
+    /**
+     * A signal emitting when the autosave flag changed.
+     */
+    get autosaveChanged() {
+        return this._autosaveChanged;
     }
     /**
      * A signal emitting when the chat name has changed.
@@ -66,6 +98,19 @@ export class AIChatModel extends AbstractChatModel {
     get agentManager() {
         return this._agentManager;
     }
+    /**
+     * Whether save/restore is available.
+     */
+    get saveAvailable() {
+        return !!this._contentsManager;
+    }
+    /**
+     * Dispose of the model.
+     */
+    dispose() {
+        this.messagesUpdated.disconnect(this._autosaveDebouncer.invoke, this._autosaveDebouncer);
+        super.dispose();
+    }
     /**
      * Creates a chat context for the current conversation.
      */
@@ -172,6 +217,141 @@ export class AIChatModel extends AbstractChatModel {
             this.updateWriters([]);
         }
     }
+    /**
+     * Save the chat as json file.
+     */
+    save = async () => {
+        if (!this._contentsManager) {
+            return;
+        }
+        const directory = this._settingsModel.config.chatBackupDirectory;
+        const filepath = PathExt.join(directory, `${this.name}.chat`);
+        const content = JSON.stringify(this._serializeModel());
+        await this._contentsManager
+            .get(filepath, { content: false })
+            .catch(async () => {
+            await this._contentsManager
+                ?.get(directory, { content: false })
+                .catch(async () => {
+                const dir = await this._contentsManager.newUntitled({
+                    type: 'directory'
+                });
+                await this._contentsManager.rename(dir.path, directory);
+            });
+            const file = await this._contentsManager.newUntitled({ ext: '.chat' });
+            await this._contentsManager?.rename(file.path, filepath);
+        });
+        await this._contentsManager.save(filepath, {
+            content,
+            type: 'file',
+            format: 'text'
+        });
+    };
+    /**
+     * Restore the chat from a json file.
+     *
+     * @param silent - Whether a log should be displayed in the console if the
+     * restoration is not possible.
+     */
+    restore = async (filepath, silent = false) => {
+        if (!this._contentsManager) {
+            return false;
+        }
+        const contentModel = await this._contentsManager
+            .get(filepath, { content: true, type: 'file', format: 'text' })
+            .catch(() => {
+            if (!silent) {
+                console.log(`There is no backup for chat '${this.name}'`);
+            }
+            return;
+        });
+        if (!contentModel) {
+            return false;
+        }
+        let content;
+        try {
+            content = JSON.parse(contentModel.content);
+        }
+        catch (e) {
+            throw `Error when parsing the chat ${filepath}\n${e}`;
+        }
+        if (content.metadata?.provider) {
+            if (this._settingsModel.getProvider(content.metadata.provider)) {
+                this._agentManager.activeProvider = content.metadata.provider;
+            }
+            else if (!silent) {
+                console.log(`Provider '${content.metadata.provider}' doesn't exist, it can't be restored.`);
+            }
+        }
+        else if (!silent) {
+            console.log(`Provider not providing when restoring ${filepath}.`);
+        }
+        const messages = content.messages.map(message => {
+            let attachments = [];
+            if (content.attachments && message.attachments) {
+                attachments =
+                    message.attachments.map(index => content.attachments[index]) ?? [];
+            }
+            return {
+                ...message,
+                sender: content.users[message.sender] ?? { username: 'unknown' },
+                mentions: message.mentions?.map(mention => content.users[mention]),
+                attachments
+            };
+        });
+        this.clearMessages();
+        this.messagesInserted(0, messages);
+        this._agentManager.setHistory(messages);
+        this.autosave = content.metadata?.autosave ?? false;
+        return true;
+    };
+    /**
+     * Serialize the model for backup
+     */
+    _serializeModel() {
+        const provider = this._agentManager.activeProvider;
+        const messages = [];
+        const users = {};
+        const attachmentMap = new Map(); // JSON → index
+        const attachmentsList = []; // Actual attachments
+        this.messages.forEach(message => {
+            let attachmentIndexes = [];
+            if (message.attachments) {
+                attachmentIndexes = message.attachments.map(attachment => {
+                    const attachmentJson = JSON.stringify(attachment);
+                    let index;
+                    if (attachmentMap.has(attachmentJson)) {
+                        index = attachmentMap.get(attachmentJson);
+                    }
+                    else {
+                        index = attachmentsList.length;
+                        attachmentMap.set(attachmentJson, index);
+                        attachmentsList.push(attachment);
+                    }
+                    return index.toString();
+                });
+            }
+            messages.push({
+                ...message.content,
+                sender: message.sender.username,
+                mentions: message.mentions?.map(user => user.username),
+                attachments: attachmentIndexes
+            });
+            if (!users[message.sender.username]) {
+                users[message.sender.username] = message.sender;
+            }
+        });
+        const attachments = Object.fromEntries(attachmentsList.map((item, index) => [index, item]));
+        return {
+            messages,
+            users,
+            attachments,
+            metadata: {
+                provider,
+                autosave: this.autosave
+            }
+        };
+    }
     /**
      * Gets the AI user information for system messages.
      */
@@ -352,13 +532,18 @@ export class AIChatModel extends AbstractChatModel {
         };
         this._toolContexts.set(event.data.callId, context);
         const toolCallMessage = {
-            body: Private.buildToolCallHtml({
-                toolName: context.toolName,
-                input: context.input,
-                status: context.status,
-                summary: context.summary,
-                trans: this._trans
-            }),
+            body: '',
+            mime_model: {
+                data: {
+                    'application/vnd.jupyter.chat.components': 'tool-call'
+                },
+                metadata: {
+                    toolName: context.toolName,
+                    input: context.input,
+                    status: context.status,
+                    summary: context.summary
+                }
+            },
             sender: this._getAIUser(),
             id: messageId,
             time: Date.now() / 1000,
@@ -383,7 +568,8 @@ export class AIChatModel extends AbstractChatModel {
             });
             for (const bundle of mimeBundles) {
                 this.messageAdded({
-                    body: bundle,
+                    body: '',
+                    mime_model: bundle,
                     sender: this._getAIUser(),
                     id: UUID.uuid4(),
                     time: Date.now() / 1000,
@@ -456,15 +642,20 @@ export class AIChatModel extends AbstractChatModel {
         }
         context.status = status;
         existingMessage.update({
-            body: Private.buildToolCallHtml({
-                toolName: context.toolName,
-                input: context.input,
-                status: context.status,
-                summary: context.summary,
-                output,
-                approvalId: context.approvalId,
-                trans: this._trans
-            })
+            mime_model: {
+                data: {
+                    'application/vnd.jupyter.chat.components': 'tool-call'
+                },
+                metadata: {
+                    toolName: context.toolName,
+                    input: context.input,
+                    status: context.status,
+                    summary: context.summary,
+                    output,
+                    targetId: this.name,
+                    approvalId: context.approvalId
+                }
+            }
         });
     }
     /**
@@ -695,7 +886,10 @@ export class AIChatModel extends AbstractChatModel {
     _agentManager;
     _currentStreamingMessage = null;
     _nameChanged = new Signal(this);
-    _trans;
+    _contentsManager;
+    _autosave = false;
+    _autosaveChanged = new Signal(this);
+    _autosaveDebouncer;
 }
 var Private;
 (function (Private) {
@@ -780,120 +974,4 @@ var Private;
         }
     }
     Private.formatToolOutput = formatToolOutput;
-    function escapeHtml(value) {
-        // Prefer the same native escaping approach used in JupyterLab itself
-        // (e.g. `@jupyterlab/completer`).
-        if (typeof document !== 'undefined') {
-            const node = document.createElement('span');
-            node.textContent = value;
-            return node.innerHTML;
-        }
-        // Fallback
-        return value
-            .replace(/&/g, '&')
-            .replace(/</g, '&lt;')
-            .replace(/>/g, '&gt;')
-            .replace(/"/g, '&quot;')
-            .replace(/'/g, '&#39;');
-    }
-    Private.escapeHtml = escapeHtml;
-    const STATUS_CONFIG = {
-        pending: {
-            cssClass: 'jp-ai-tool-pending',
-            statusClass: 'jp-ai-tool-status-pending'
-        },
-        awaiting_approval: {
-            cssClass: 'jp-ai-tool-pending',
-            statusClass: 'jp-ai-tool-status-approval',
-            open: true
-        },
-        approved: {
-            cssClass: 'jp-ai-tool-pending',
-            statusClass: 'jp-ai-tool-status-completed'
-        },
-        rejected: {
-            cssClass: 'jp-ai-tool-error',
-            statusClass: 'jp-ai-tool-status-error'
-        },
-        completed: {
-            cssClass: 'jp-ai-tool-completed',
-            statusClass: 'jp-ai-tool-status-completed'
-        },
-        error: {
-            cssClass: 'jp-ai-tool-error',
-            statusClass: 'jp-ai-tool-status-error'
-        }
-    };
-    /**
-     * Returns the translated status text for a given tool status.
-     */
-    const getStatusText = (status, trans) => {
-        switch (status) {
-            case 'pending':
-                return trans.__('Running...');
-            case 'awaiting_approval':
-                return trans.__('Awaiting Approval');
-            case 'approved':
-                return trans.__('Approved - Executing...');
-            case 'rejected':
-                return trans.__('Rejected');
-            case 'completed':
-                return trans.__('Completed');
-            case 'error':
-                return trans.__('Error');
-        }
-    };
-    /**
-     * Builds HTML for a tool call display.
-     */
-    function buildToolCallHtml(options) {
-        const { toolName, input, status, summary, output, approvalId, trans } = options;
-        const config = STATUS_CONFIG[status];
-        const statusText = getStatusText(status, trans);
-        const escapedToolName = escapeHtml(toolName);
-        const escapedInput = escapeHtml(input);
-        const openAttr = config.open ? ' open' : '';
-        const summaryHtml = summary
-            ? `<span class="jp-ai-tool-summary">${escapeHtml(summary)}</span>`
-            : '';
-        let bodyContent = `
-<div class="jp-ai-tool-section">
-<div class="jp-ai-tool-label">${trans.__('Input')}</div>
-<pre class="jp-ai-tool-code"><code>${escapedInput}</code></pre>
-</div>`;
-        // Add approval buttons if awaiting approval
-        if (status === 'awaiting_approval' && approvalId) {
-            bodyContent += `
-<div class="jp-ai-tool-approval-buttons jp-ai-approval-id--${approvalId}">
-<button class="jp-ai-approval-btn jp-ai-approval-approve">${trans.__('Approve')}</button>
-<button class="jp-ai-approval-btn jp-ai-approval-reject">${trans.__('Reject')}</button>
-</div>`;
-        }
-        // Add output/result section if provided
-        if (output !== undefined) {
-            const escapedOutput = escapeHtml(output);
-            const label = status === 'error' ? trans.__('Error') : trans.__('Result');
-            bodyContent += `
-<div class="jp-ai-tool-section">
-<div class="jp-ai-tool-label">${label}</div>
-<pre class="jp-ai-tool-code"><code>${escapedOutput}</code></pre>
-</div>`;
-        }
-        const HTMLContent = `<details class="jp-ai-tool-call ${config.cssClass}"${openAttr}>
-<summary class="jp-ai-tool-header">
-<div class="jp-ai-tool-icon">⚡</div>
-<div class="jp-ai-tool-title">${escapedToolName}${summaryHtml}</div>
-<div class="jp-ai-tool-status ${config.statusClass}">${statusText}</div>
-</summary>
-<div class="jp-ai-tool-body">${bodyContent}
-</div>
-</details>`;
-        return {
-            trusted: true,
-            data: {
-                'text/html': HTMLContent
-            }
-        };
-    }
-    Private.buildToolCallHtml = buildToolCallHtml;
 })(Private || (Private = {}));

package/lib/completion/completion-provider.d.ts

@@ -1,7 +1,6 @@
 import { CompletionHandler, IInlineCompletionContext, IInlineCompletionList, IInlineCompletionProvider } from '@jupyterlab/completer';
 import { ISecretsManager } from 'jupyter-secrets-manager';
-import { AISettingsModel } from '../models/settings-model';
-import { type IProviderRegistry } from '../tokens';
+import { type IAISettingsModel, type IProviderRegistry } from '../tokens';
 /**
  * Configuration interface for provider-specific completion behavior
  */
@@ -68,7 +67,7 @@ export declare namespace AICompletionProvider {
         /**
          * The AI settings model.
          */
-        settingsModel: AISettingsModel;
+        settingsModel: IAISettingsModel;
         /**
          * The provider registry
          */