@jupyterlite/ai 0.15.0 → 0.17.0

package/lib/chat-model.js

@@ -49,6 +49,31 @@ export class AIChatModel extends AbstractChatModel {
         }
         this.setReady();
     }
+    /**
+     * A signal emitting when the chat name has changed.
+     */
+    get nameChanged() {
+        return this._nameChanged;
+    }
+    /**
+     * The title of the chat.
+     */
+    get title() {
+        return this._title;
+    }
+    set title(value) {
+        this._title = value;
+        if (this.autosave) {
+            this._autosaveDebouncer.invoke();
+        }
+        this._titleChanged.emit(this._title);
+    }
+    /**
+     * A signal emitting when the chat title has changed.
+     */
+    get titleChanged() {
+        return this._titleChanged;
+    }
     /**
      * Whether to save the chat automatically.
      */
@@ -74,12 +99,6 @@ export class AIChatModel extends AbstractChatModel {
     get autosaveChanged() {
         return this._autosaveChanged;
     }
-    /**
-     * A signal emitting when the chat name has changed.
-     */
-    get nameChanged() {
-        return this._nameChanged;
-    }
     /**
      * Gets the current user information.
      */
@@ -135,10 +154,10 @@ export class AIChatModel extends AbstractChatModel {
     /**
      * Clears all messages from the chat and resets conversation state.
      */
-    clearMessages = () => {
+    clearMessages = async () => {
         this.messagesDeleted(0, this.messages.length);
         this._toolContexts.clear();
-        this._agentManager.clearHistory();
+        await this._agentManager.clearHistory();
     };
     /**
      * Adds a non-user message to the chat (used by chat commands).
@@ -192,11 +211,18 @@ export class AIChatModel extends AbstractChatModel {
             // Process attachments and add their content to the message
             let enhancedMessage = message.body;
             if (this.input.attachments.length > 0) {
-                const attachmentContents = await this._processAttachments(this.input.attachments);
+                const { textContents, binaryParts } = await Private.processAttachments(this.input.attachments, this.input.documentManager);
                 this.input.clearAttachments();
-                if (attachmentContents.length > 0) {
-                    enhancedMessage +=
-                        '\n\n--- Attached Files ---\n' + attachmentContents.join('\n\n');
+                let textPart = message.body;
+                if (textContents.length > 0) {
+                    textPart +=
+                        '\n\n--- Attached Files ---\n' + textContents.join('\n\n');
+                }
+                if (binaryParts.length > 0) {
+                    enhancedMessage = [{ type: 'text', text: textPart }, ...binaryParts];
+                }
+                else {
+                    enhancedMessage = textPart;
                 }
             }
             this.updateWriters([{ user: this._getAIUser() }]);
@@ -258,7 +284,7 @@ export class AIChatModel extends AbstractChatModel {
             return false;
         }
         const contentModel = await this._contentsManager
-            .get(filepath, { content: true })
+            .get(filepath, { content: true, type: 'file', format: 'text' })
             .catch(() => {
             if (!silent) {
                 console.log(`There is no backup for chat '${this.name}'`);
@@ -268,7 +294,13 @@ export class AIChatModel extends AbstractChatModel {
         if (!contentModel) {
             return false;
         }
-        const content = JSON.parse(contentModel.content);
+        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;
@@ -293,12 +325,33 @@ export class AIChatModel extends AbstractChatModel {
                 attachments
             };
         });
-        this.clearMessages();
+        await this.clearMessages();
         this.messagesInserted(0, messages);
         this._agentManager.setHistory(messages);
         this.autosave = content.metadata?.autosave ?? false;
+        this.title = content.metadata?.title ?? null;
         return true;
     };
+    /**
+     * Request a title to this chat, regarding the message history.
+     */
+    async requestTitle() {
+        const history = this.messages
+            .filter(msg => msg.body !== '')
+            .map(msg => `${msg.sender.username === 'ai-assistant' ? 'assistant' : 'user'}: ${msg.body}`)
+            .join('\n');
+        const messages = [
+            {
+                role: 'system',
+                content: "Generate a concise title (no more than 10 words) for the following conversation. Do not use formatting. Focus on the user's main intent."
+            },
+            {
+                role: 'user',
+                content: history
+            }
+        ];
+        return this.agentManager.textResponse(messages);
+    }
     /**
      * Serialize the model for backup
      */
@@ -342,7 +395,8 @@ export class AIChatModel extends AbstractChatModel {
             attachments,
             metadata: {
                 provider,
-                autosave: this.autosave
+                autosave: this.autosave,
+                ...(this.title ? { title: this.title } : {})
             }
         };
     }
@@ -652,49 +706,216 @@ export class AIChatModel extends AbstractChatModel {
             }
         });
     }
+    // Private fields
+    _settingsModel;
+    _user;
+    _toolContexts = new Map();
+    _agentManager;
+    _currentStreamingMessage = null;
+    _nameChanged = new Signal(this);
+    _contentsManager;
+    _autosave = false;
+    _autosaveChanged = new Signal(this);
+    _autosaveDebouncer;
+    _title = null;
+    _titleChanged = new Signal(this);
+}
+var Private;
+(function (Private) {
+    const isPlainObject = (value) => {
+        return typeof value === 'object' && value !== null && !Array.isArray(value);
+    };
+    const isDisplayOutput = (value) => {
+        if (!isPlainObject(value)) {
+            return false;
+        }
+        const output = value;
+        return (nbformat.isDisplayData(output) ||
+            nbformat.isDisplayUpdate(output) ||
+            nbformat.isExecuteResult(output));
+    };
+    const toMimeBundle = (value, trustedMimeTypes) => {
+        const data = value.data;
+        if (!isPlainObject(data) || Object.keys(data).length === 0) {
+            return null;
+        }
+        return {
+            data: data,
+            ...(isPlainObject(value.metadata)
+                ? { metadata: value.metadata }
+                : {}),
+            // MIME auto-rendering only runs for explicitly configured command IDs.
+            // Trust handling is configurable to keep risky MIME execution opt-in.
+            ...(Object.keys(data).some(m => trustedMimeTypes.has(m))
+                ? { trusted: true }
+                : {})
+        };
+    };
+    /**
+     * Normalize arbitrary tool payloads into canonical display outputs.
+     *
+     * Tool outputs are not guaranteed to be raw Jupyter IOPub messages; they are
+     * often wrapped objects (for example `{ success, result: { outputs: [...] } }`).
+     */
+    const toDisplayOutputs = (value) => {
+        if (isDisplayOutput(value)) {
+            return [value];
+        }
+        if (Array.isArray(value)) {
+            return value.filter(isDisplayOutput);
+        }
+        if (!isPlainObject(value)) {
+            return [];
+        }
+        if (Array.isArray(value.outputs)) {
+            return value.outputs.filter(isDisplayOutput);
+        }
+        if ('result' in value) {
+            return toDisplayOutputs(value.result);
+        }
+        return [];
+    };
+    /**
+     * Extract rendermime-ready mime bundles from arbitrary tool results.
+     */
+    function extractMimeBundlesFromUnknown(content, options = {}) {
+        const bundles = [];
+        const outputs = toDisplayOutputs(content);
+        const trustedMimeTypes = new Set(options.trustedMimeTypes ?? []);
+        for (const output of outputs) {
+            const bundle = toMimeBundle(output, trustedMimeTypes);
+            if (bundle) {
+                bundles.push(bundle);
+            }
+        }
+        return bundles;
+    }
+    Private.extractMimeBundlesFromUnknown = extractMimeBundlesFromUnknown;
+    function formatToolOutput(outputData) {
+        if (typeof outputData === 'string') {
+            return outputData;
+        }
+        try {
+            return JSON.stringify(outputData, null, 2);
+        }
+        catch {
+            return '[Complex object - cannot serialize]';
+        }
+    }
+    Private.formatToolOutput = formatToolOutput;
     /**
-     * Processes file attachments and returns their content as formatted strings.
+     * Processes file attachments and returns text contents and binary parts separately.
      * @param attachments Array of file attachments to process
-     * @returns Array of formatted attachment contents
+     * @param documentManager Optional document manager for file operations
+     * @returns Text contents and binary parts
      */
-    async _processAttachments(attachments) {
-        const contents = [];
+    async function processAttachments(attachments, documentManager) {
+        const textContents = [];
+        const binaryParts = [];
+        if (!documentManager) {
+            return { textContents, binaryParts };
+        }
         for (const attachment of attachments) {
             try {
                 if (attachment.type === 'notebook' && attachment.cells?.length) {
-                    const cellContents = await this._readNotebookCells(attachment);
+                    const cellContents = await readNotebookCells(attachment, documentManager);
                     if (cellContents) {
-                        contents.push(cellContents);
+                        textContents.push(cellContents);
                     }
                 }
                 else {
-                    const fileContent = await this._readFileAttachment(attachment);
-                    if (fileContent) {
-                        const fileExtension = PathExt.extname(attachment.value).toLowerCase();
-                        const language = fileExtension === '.ipynb' ? 'json' : '';
-                        contents.push(`**File: ${attachment.value}**\n\`\`\`${language}\n${fileContent}\n\`\`\``);
+                    let mimetype = attachment.mimetype;
+                    const fileExtension = PathExt.extname(attachment.value).toLowerCase();
+                    // Fetch mimetype from server metadata if not provided
+                    if (!mimetype) {
+                        try {
+                            const diskModel = await documentManager.services.contents.get(attachment.value, { content: false });
+                            mimetype = diskModel?.mimetype;
+                        }
+                        catch (e) {
+                            console.warn(`Failed to fetch metadata for ${attachment.value}:`, e);
+                        }
+                    }
+                    if (mimetype?.startsWith('image/')) {
+                        const data = await readBinaryAttachment(attachment, documentManager);
+                        if (data) {
+                            binaryParts.push({
+                                type: 'image',
+                                image: data,
+                                mediaType: mimetype
+                            });
+                        }
+                    }
+                    else if (mimetype === 'application/pdf') {
+                        const data = await readBinaryAttachment(attachment, documentManager);
+                        if (data) {
+                            binaryParts.push({
+                                type: 'file',
+                                data,
+                                mediaType: mimetype,
+                                filename: PathExt.basename(attachment.value)
+                            });
+                        }
+                    }
+                    else {
+                        const fileContent = await readFileAttachment(attachment, documentManager);
+                        if (fileContent) {
+                            const language = fileExtension === '.ipynb' ||
+                                mimetype === 'application/x-ipynb+json'
+                                ? 'json'
+                                : '';
+                            textContents.push(`**File: ${attachment.value}**\n\`\`\`${language}\n${fileContent}\n\`\`\``);
+                        }
                     }
                 }
             }
             catch (error) {
                 console.warn(`Failed to read attachment ${attachment.value}:`, error);
-                contents.push(`**File: ${attachment.value}** (Could not read file)`);
+                textContents.push(`**File: ${attachment.value}** (Could not read file)`);
             }
         }
-        return contents;
+        return { textContents, binaryParts };
     }
+    Private.processAttachments = processAttachments;
+    /**
+     * Reads a binary attachment and returns its base64-encoded content.
+     * @param attachment The attachment to read
+     * @param documentManager Optional document manager for file operations
+     * @returns Base64 string or null if unable to read
+     */
+    async function readBinaryAttachment(attachment, documentManager) {
+        if (!documentManager) {
+            return null;
+        }
+        try {
+            const diskModel = await documentManager.services.contents.get(attachment.value, { content: true });
+            if (diskModel?.content && diskModel.format === 'base64') {
+                // Strip whitespace/newlines
+                return diskModel.content.replace(/\s/g, '');
+            }
+            return null;
+        }
+        catch (error) {
+            console.warn(`Failed to read binary attachment ${attachment.value}:`, error);
+            return null;
+        }
+    }
+    Private.readBinaryAttachment = readBinaryAttachment;
     /**
      * Reads the content of a notebook cell.
      * @param attachment The notebook attachment to read
+     * @param documentManager Optional document manager for file operations
      * @returns Cell content as string or null if unable to read
      */
-    async _readNotebookCells(attachment) {
-        if (attachment.type !== 'notebook' || !attachment.cells) {
+    async function readNotebookCells(attachment, documentManager) {
+        if (attachment.type !== 'notebook' ||
+            !attachment.cells ||
+            !documentManager) {
             return null;
         }
         try {
             // Try reading from live notebook if open
-            const widget = this.input.documentManager?.findWidget(attachment.value);
+            const widget = documentManager.findWidget(attachment.value);
             let cellData;
             let kernelLang = 'text';
             const ymodel = widget?.context.model.sharedModel;
@@ -708,7 +929,7 @@ export class AIChatModel extends AbstractChatModel {
             }
             else {
                 // Fallback: reading from disk
-                const model = await this.input.documentManager?.services.contents.get(attachment.value);
+                const model = await documentManager.services.contents.get(attachment.value);
                 if (!model || model.type !== 'notebook') {
                     return null;
                 }
@@ -823,19 +1044,22 @@ export class AIChatModel extends AbstractChatModel {
             return null;
         }
     }
+    Private.readNotebookCells = readNotebookCells;
     /**
      * Reads the content of a file attachment.
      * @param attachment The file attachment to read
+     * @param documentManager Optional document manager for file operations
      * @returns File content as string or null if unable to read
      */
-    async _readFileAttachment(attachment) {
+    async function readFileAttachment(attachment, documentManager) {
         // Handle both 'file' and 'notebook' types since both have a 'value' path
-        if (attachment.type !== 'file' && attachment.type !== 'notebook') {
+        if ((attachment.type !== 'file' && attachment.type !== 'notebook') ||
+            !documentManager) {
             return null;
         }
         try {
             // Try reading from an open widget first
-            const widget = this.input.documentManager?.findWidget(attachment.value);
+            const widget = documentManager.findWidget(attachment.value);
             if (widget && widget.context && widget.context.model) {
                 const model = widget.context.model;
                 const ymodel = model.sharedModel;
@@ -847,7 +1071,7 @@ export class AIChatModel extends AbstractChatModel {
                 }
             }
             // If not open, load from disk
-            const diskModel = await this.input.documentManager?.services.contents.get(attachment.value);
+            const diskModel = await documentManager.services.contents.get(attachment.value);
             if (!diskModel?.content) {
                 return null;
             }
@@ -873,99 +1097,5 @@ export class AIChatModel extends AbstractChatModel {
             return null;
         }
     }
-    // Private fields
-    _settingsModel;
-    _user;
-    _toolContexts = new Map();
-    _agentManager;
-    _currentStreamingMessage = null;
-    _nameChanged = new Signal(this);
-    _contentsManager;
-    _autosave = false;
-    _autosaveChanged = new Signal(this);
-    _autosaveDebouncer;
-}
-var Private;
-(function (Private) {
-    const isPlainObject = (value) => {
-        return typeof value === 'object' && value !== null && !Array.isArray(value);
-    };
-    const isDisplayOutput = (value) => {
-        if (!isPlainObject(value)) {
-            return false;
-        }
-        const output = value;
-        return (nbformat.isDisplayData(output) ||
-            nbformat.isDisplayUpdate(output) ||
-            nbformat.isExecuteResult(output));
-    };
-    const toMimeBundle = (value, trustedMimeTypes) => {
-        const data = value.data;
-        if (!isPlainObject(data) || Object.keys(data).length === 0) {
-            return null;
-        }
-        return {
-            data: data,
-            ...(isPlainObject(value.metadata)
-                ? { metadata: value.metadata }
-                : {}),
-            // MIME auto-rendering only runs for explicitly configured command IDs.
-            // Trust handling is configurable to keep risky MIME execution opt-in.
-            ...(Object.keys(data).some(m => trustedMimeTypes.has(m))
-                ? { trusted: true }
-                : {})
-        };
-    };
-    /**
-     * Normalize arbitrary tool payloads into canonical display outputs.
-     *
-     * Tool outputs are not guaranteed to be raw Jupyter IOPub messages; they are
-     * often wrapped objects (for example `{ success, result: { outputs: [...] } }`).
-     */
-    const toDisplayOutputs = (value) => {
-        if (isDisplayOutput(value)) {
-            return [value];
-        }
-        if (Array.isArray(value)) {
-            return value.filter(isDisplayOutput);
-        }
-        if (!isPlainObject(value)) {
-            return [];
-        }
-        if (Array.isArray(value.outputs)) {
-            return value.outputs.filter(isDisplayOutput);
-        }
-        if ('result' in value) {
-            return toDisplayOutputs(value.result);
-        }
-        return [];
-    };
-    /**
-     * Extract rendermime-ready mime bundles from arbitrary tool results.
-     */
-    function extractMimeBundlesFromUnknown(content, options = {}) {
-        const bundles = [];
-        const outputs = toDisplayOutputs(content);
-        const trustedMimeTypes = new Set(options.trustedMimeTypes ?? []);
-        for (const output of outputs) {
-            const bundle = toMimeBundle(output, trustedMimeTypes);
-            if (bundle) {
-                bundles.push(bundle);
-            }
-        }
-        return bundles;
-    }
-    Private.extractMimeBundlesFromUnknown = extractMimeBundlesFromUnknown;
-    function formatToolOutput(outputData) {
-        if (typeof outputData === 'string') {
-            return outputData;
-        }
-        try {
-            return JSON.stringify(outputData, null, 2);
-        }
-        catch {
-            return '[Complex object - cannot serialize]';
-        }
-    }
-    Private.formatToolOutput = formatToolOutput;
+    Private.readFileAttachment = readFileAttachment;
 })(Private || (Private = {}));

package/lib/components/clear-button.d.ts

@@ -7,7 +7,7 @@ export interface IClearButtonProps extends InputToolbarRegistry.IToolbarItemProp
     /**
      * The function to clear messages.
      */
-    clearMessages: () => void;
+    clearMessages: () => Promise<void>;
     /**
      * The application language translator.
      */

package/lib/components/clear-button.js

@@ -21,7 +21,7 @@ export function clearItem(translator) {
     return {
         element: (props) => {
             const { model } = props;
-            const clearMessages = () => model.chatContext.clearMessages();
+            const clearMessages = async () => await model.chatContext.clearMessages();
             const clearProps = {
                 ...props,
                 clearMessages,

package/lib/components/index.d.ts

@@ -2,5 +2,5 @@ export * from './clear-button';
 export * from './completion-status';
 export * from './model-select';
 export * from './stop-button';
-export * from './token-usage-display';
+export * from './usage-display';
 export * from './tool-select';

package/lib/components/index.js

@@ -2,5 +2,5 @@ export * from './clear-button';
 export * from './completion-status';
 export * from './model-select';
 export * from './stop-button';
-export * from './token-usage-display';
+export * from './usage-display';
 export * from './tool-select';

package/lib/components/{token-usage-display.d.ts → usage-display.d.ts}

@@ -4,9 +4,9 @@ import React from 'react';
 import { ISignal } from '@lumino/signaling';
 import type { IAISettingsModel, ITokenUsage } from '../tokens';
 /**
- * Props for the TokenUsageDisplay component.
+ * Props for the UsageDisplay component.
  */
-export interface ITokenUsageDisplayProps {
+export interface IUsageDisplayProps {
     /**
      * The token usage changed signal
      */
@@ -25,24 +25,24 @@ export interface ITokenUsageDisplayProps {
     translator: TranslationBundle;
 }
 /**
- * React component that displays token usage information.
- * Shows input/output token counts with up/down arrows.
- * Only renders when token usage display is enabled in settings.
+ * React component that displays usage information.
+ * Shows input/output token counts and optional estimated context usage.
+ * Only renders when token or context usage display is enabled in settings.
  */
-export declare const TokenUsageDisplay: React.FC<ITokenUsageDisplayProps>;
+export declare const UsageDisplay: React.FC<IUsageDisplayProps>;
 /**
- * JupyterLab widget wrapper for the TokenUsageDisplay component.
+ * JupyterLab widget wrapper for the UsageDisplay component.
  * Extends ReactWidget to integrate with the JupyterLab widget system.
  */
-export declare class TokenUsageWidget extends ReactWidget {
+export declare class UsageWidget extends ReactWidget {
     /**
-     * Creates a new TokenUsageWidget instance.
+     * Creates a new UsageWidget instance.
      * @param options - Configuration options containing required models
      */
-    constructor(options: ITokenUsageDisplayProps);
+    constructor(options: IUsageDisplayProps);
     /**
      * Renders the React component within the widget.
-     * @returns The TokenUsageDisplay React element
+     * @returns The UsageDisplay React element
      */
     protected render(): React.ReactElement;
     private _options;