@jupyternaut/persona 0.0.0 → 0.20.0

package/lib/process-attachments.js

@@ -0,0 +1,287 @@
+import { PathExt } from '@jupyterlab/coreutils';
+export async function processAttachments(attachments, documentManager, body, supportsImages, supportsPdf, supportsAudio) {
+    const textContents = [];
+    const includedParts = [];
+    const omittedNames = [];
+    if (!documentManager) {
+        return body;
+    }
+    for (const attachment of attachments) {
+        try {
+            if (attachment.type === 'notebook' && attachment.cells?.length) {
+                const cellContents = await readNotebookCells(attachment, documentManager);
+                if (cellContents) {
+                    textContents.push(cellContents);
+                }
+            }
+            else {
+                let mimetype = attachment.mimetype;
+                const fileExtension = PathExt.extname(attachment.value).toLowerCase();
+                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/')) {
+                    if (supportsImages) {
+                        const data = await readBinaryAttachment(attachment, documentManager);
+                        if (data) {
+                            includedParts.push({
+                                type: 'file',
+                                data,
+                                mediaType: mimetype
+                            });
+                        }
+                    }
+                    else {
+                        omittedNames.push(PathExt.basename(attachment.value));
+                    }
+                }
+                else if (mimetype === 'application/pdf') {
+                    if (supportsPdf) {
+                        const data = await readBinaryAttachment(attachment, documentManager);
+                        if (data) {
+                            includedParts.push({
+                                type: 'file',
+                                data,
+                                mediaType: mimetype,
+                                filename: PathExt.basename(attachment.value)
+                            });
+                        }
+                    }
+                    else {
+                        omittedNames.push(PathExt.basename(attachment.value));
+                    }
+                }
+                else if (mimetype?.startsWith('audio/')) {
+                    if (supportsAudio) {
+                        const data = await readBinaryAttachment(attachment, documentManager);
+                        if (data) {
+                            includedParts.push({
+                                type: 'file',
+                                data,
+                                mediaType: mimetype,
+                                filename: PathExt.basename(attachment.value)
+                            });
+                        }
+                    }
+                    else {
+                        omittedNames.push(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);
+            textContents.push(`**File: ${attachment.value}** (Could not read file)`);
+        }
+    }
+    let textPart = body;
+    if (textContents.length > 0) {
+        textPart += '\n\n--- Attached Files ---\n' + textContents.join('\n\n');
+    }
+    if (omittedNames.length > 0) {
+        textPart += `\n[Attachments omitted (not supported by this model): ${omittedNames.join(', ')}.]`;
+    }
+    return includedParts.length > 0
+        ? [{ type: 'text', text: textPart }, ...includedParts]
+        : textPart;
+}
+async function readBinaryAttachment(attachment, documentManager) {
+    try {
+        const diskModel = await documentManager.services.contents.get(attachment.value, { content: true });
+        if (diskModel?.content && diskModel.format === 'base64') {
+            return diskModel.content.replace(/\s/g, '');
+        }
+        return null;
+    }
+    catch (error) {
+        console.warn(`Failed to read binary attachment ${attachment.value}:`, error);
+        return null;
+    }
+}
+async function readNotebookCells(attachment, documentManager) {
+    if (attachment.type !== 'notebook' || !attachment.cells) {
+        return null;
+    }
+    try {
+        const widget = documentManager.findWidget(attachment.value);
+        let cellData;
+        let kernelLang = 'text';
+        const ymodel = widget?.context.model.sharedModel;
+        if (ymodel) {
+            const nb = ymodel.toJSON();
+            cellData = nb.cells;
+            const lang = nb.metadata.language_info?.name ||
+                nb.metadata.kernelspec?.language ||
+                'text';
+            kernelLang = String(lang);
+        }
+        else {
+            const model = await documentManager.services.contents.get(attachment.value, { content: true });
+            if (!model || model.type !== 'notebook') {
+                return null;
+            }
+            cellData = model.content.cells ?? [];
+            kernelLang =
+                model.content.metadata.language_info?.name ||
+                    model.content.metadata.kernelspec?.language ||
+                    'text';
+        }
+        const selectedCells = attachment.cells
+            .map(cellInfo => {
+            const cell = cellData.find(c => c.id === cellInfo.id);
+            if (!cell) {
+                return null;
+            }
+            const code = cell.source || '';
+            const cellType = cell.cell_type;
+            const lang = cellType === 'code' ? kernelLang : cellType;
+            let outputs = '';
+            if (cellType === 'code' && Array.isArray(cell.outputs)) {
+                const outputsArray = cell.outputs;
+                outputs = outputsArray
+                    .map(output => {
+                    if (output.output_type === 'stream') {
+                        return output.text;
+                    }
+                    else if (output.output_type === 'error') {
+                        const err = output;
+                        return `${err.ename}: ${err.evalue}\n${(err.traceback || []).join('\n')}`;
+                    }
+                    else if (output.output_type === 'execute_result' ||
+                        output.output_type === 'display_data') {
+                        const data = output.data;
+                        if (!data) {
+                            return '';
+                        }
+                        try {
+                            return extractDisplay(data);
+                        }
+                        catch (e) {
+                            console.error('Cannot extract cell output', e);
+                            return '';
+                        }
+                    }
+                    return '';
+                })
+                    .filter(Boolean)
+                    .join('\n---\n');
+                if (outputs.length > 2000) {
+                    outputs = outputs.slice(0, 2000) + '\n...[truncated]';
+                }
+            }
+            return (`**Cell [${cellInfo.id}] (${cellType}):**\n` +
+                `\`\`\`${lang}\n${code}\n\`\`\`` +
+                (outputs ? `\n**Outputs:**\n\`\`\`text\n${outputs}\n\`\`\`` : ''));
+        })
+            .filter(Boolean)
+            .join('\n\n');
+        return `**Notebook: ${attachment.value}**\n${selectedCells}`;
+    }
+    catch (error) {
+        console.warn(`Failed to read notebook cells from ${attachment.value}:`, error);
+        return null;
+    }
+}
+async function readFileAttachment(attachment, documentManager) {
+    if (attachment.type !== 'file' && attachment.type !== 'notebook') {
+        return null;
+    }
+    try {
+        const widget = documentManager.findWidget(attachment.value);
+        if (widget?.context?.model) {
+            const ymodel = widget.context.model.sharedModel;
+            if (typeof ymodel.getSource === 'function') {
+                const source = ymodel.getSource();
+                return typeof source === 'string'
+                    ? source
+                    : JSON.stringify(source, null, 2);
+            }
+        }
+        const diskModel = await documentManager.services.contents.get(attachment.value, { content: true });
+        if (!diskModel?.content) {
+            return null;
+        }
+        if (diskModel.type === 'file') {
+            return diskModel.content;
+        }
+        if (diskModel.type === 'notebook') {
+            const cleaned = {
+                ...diskModel,
+                cells: diskModel.content.cells.map((cell) => ({
+                    ...cell,
+                    outputs: [],
+                    execution_count: null
+                }))
+            };
+            return JSON.stringify(cleaned);
+        }
+        return null;
+    }
+    catch (error) {
+        console.warn(`Failed to read file ${attachment.value}:`, error);
+        return null;
+    }
+}
+function extractDisplay(data) {
+    const DISPLAY_PRIORITY = [
+        'application/vnd.jupyter.widget-view+json',
+        'application/javascript',
+        'text/html',
+        'image/svg+xml',
+        'image/png',
+        'image/jpeg',
+        'text/markdown',
+        'text/latex',
+        'text/plain'
+    ];
+    for (const mime of DISPLAY_PRIORITY) {
+        if (!(mime in data)) {
+            continue;
+        }
+        const value = data[mime];
+        if (!value) {
+            continue;
+        }
+        switch (mime) {
+            case 'application/vnd.jupyter.widget-view+json':
+                return `Widget: ${value.model_id ?? 'unknown model'}`;
+            case 'image/png':
+                return `![image](data:image/png;base64,${String(value).slice(0, 100)}...)`;
+            case 'image/jpeg':
+                return `![image](data:image/jpeg;base64,${String(value).slice(0, 100)}...)`;
+            case 'image/svg+xml':
+                return String(value).slice(0, 500) + '...\n[svg truncated]';
+            case 'text/html':
+                return (String(value).slice(0, 1000) +
+                    (String(value).length > 1000 ? '\n...[truncated]' : ''));
+            case 'text/markdown':
+            case 'text/latex':
+            case 'text/plain': {
+                let text = Array.isArray(value) ? value.join('') : String(value);
+                if (text.length > 2000) {
+                    text = text.slice(0, 2000) + '\n...[truncated]';
+                }
+                return text;
+            }
+            default:
+                return JSON.stringify(value).slice(0, 2000);
+        }
+    }
+    return JSON.stringify(data).slice(0, 2000);
+}

package/lib/tokens.d.ts

@@ -0,0 +1,101 @@
+import { IChatModel, IUser } from '@jupyter/chat';
+import { IDocumentManager } from '@jupyterlab/docmanager';
+import type { IAgentManager, IAISettingsModel, IProviderRegistry } from '@jupyternaut/agent';
+import { Token } from '@lumino/coreutils';
+import { ISignal } from '@lumino/signaling';
+export declare const DEFAULT_PERSONA: IUser;
+/**
+ * Command IDs namespace
+ */
+export declare namespace CommandIds {
+    const openSettings = "@jupyternaut/persona:open-settings";
+    const refreshSkills = "@jupyternaut/persona:refresh-skills";
+}
+/**
+ * Public interface for a persona handler attached to a chat session.
+ *
+ * A persona handler links an `IAgentManager` to an `IChatModel`, listening for
+ * persona mentions and generating AI responses. Third-party extensions can
+ * consume `IPersonaHandlerRegistry` to obtain `IPersonaHandler` instances and
+ * interact with the agent (e.g. to read the active provider or update tools).
+ */
+export interface IPersona {
+    /**
+     * The agent manager used by this handler to generate AI responses.
+     */
+    readonly agentManager: IAgentManager;
+    /**
+     * The chat model this handler is attached to.
+     */
+    readonly model: IChatModel;
+    /**
+     * Whether the persona is currently generating a response.
+     */
+    readonly isBusy: boolean;
+    /**
+     * A signal emitted when the busy state changes.
+     */
+    readonly busyChanged: ISignal<IPersona, boolean>;
+    /**
+     * Whether a mention is required to trigger a response.
+     * When false, the persona responds to all non-bot messages.
+     * Defaults to true.
+     */
+    requireMention: boolean;
+    /**
+     * Dispose of the handler and release its resources.
+     */
+    dispose(): void;
+    /**
+     * Rebuilds the agent history from the current chat messages.
+     * Called after restoring a saved chat.
+     */
+    rebuildHistory(): Promise<void>;
+}
+/**
+ * Registry mapping chat models to their persona.
+ *
+ * Provided by `@jupyternaut/persona`. Other extensions (e.g. `@jupyterlite/ai`)
+ * can consume this token to access the agent manager associated with a given chat.
+ */
+export interface IPersonaRegistry {
+    /**
+     * Returns the persona registered for a given chat model, if any.
+     */
+    get(model: IChatModel): IPersona | undefined;
+    /**
+     * Registers a persona for a given chat model.
+     */
+    register(model: IChatModel, agentManager: IAgentManager): void;
+    /**
+     * Removes the persona registered for a given chat model.
+     */
+    unregister(model: IChatModel): void;
+    /**
+     * A signal emitting whenever a new persona is registered.
+     */
+    readonly personaAdded: ISignal<IPersonaRegistry, IPersona>;
+}
+/**
+ * The options to build a persona registry.
+ */
+export interface IPersonaRegistryOptions {
+    /**
+     * The persona used by the registry.
+     */
+    persona: IUser;
+    /**
+     * The agent settings model, used to process attachments in persona.
+     */
+    settingsModel: IAISettingsModel;
+    /**
+     * The optional provider registry, used to process attachments in persona.
+     */
+    providerRegistry?: IProviderRegistry;
+    /**
+     * The optional document manager, used to process attachments in persona.
+     */
+    documentManager?: IDocumentManager;
+}
+export declare const IPersonaRegistry: Token<IPersonaRegistry>;
+//# sourceMappingURL=tokens.d.ts.map

package/lib/tokens.js

@@ -0,0 +1,20 @@
+import { AI_AVATAR } from '@jupyternaut/agent';
+import { Token } from '@lumino/coreutils';
+export const DEFAULT_PERSONA = {
+    username: 'jupyternaut-frontend',
+    display_name: 'Jupyternaut',
+    initials: 'JF',
+    color: '#2196F3',
+    avatar_url: AI_AVATAR,
+    bot: true,
+    mention_name: 'jupyternaut-frontend'
+};
+/**
+ * Command IDs namespace
+ */
+export var CommandIds;
+(function (CommandIds) {
+    CommandIds.openSettings = '@jupyternaut/persona:open-settings';
+    CommandIds.refreshSkills = '@jupyternaut/persona:refresh-skills';
+})(CommandIds || (CommandIds = {}));
+export const IPersonaRegistry = new Token('@jupyternaut/persona:IPersonaHandlerRegistry');

package/lib/widgets/ai-settings.d.ts

@@ -0,0 +1,54 @@
+import type { IAgentManagerFactory, IAISecretsAccess, IAISettingsModel, IProviderRegistry } from '@jupyternaut/agent';
+import { IThemeManager } from '@jupyterlab/apputils';
+import { ReactWidget } from '@jupyterlab/ui-components';
+import type { TranslationBundle } from '@jupyterlab/translation';
+import React from 'react';
+/**
+ * A JupyterLab widget for AI settings configuration
+ */
+export declare class AISettingsWidget extends ReactWidget {
+    /**
+     * Construct a new AI settings widget
+     * @param options - The options for initializing the widget
+     */
+    constructor(options: AISettingsWidget.IOptions);
+    /**
+     * Render the AI settings component
+     * @returns A React element containing the AI settings interface
+     */
+    protected render(): React.ReactElement;
+    private _settingsModel;
+    private _agentManagerFactory?;
+    private _themeManager?;
+    private _providerRegistry;
+    private _secretsAccess?;
+    private _trans;
+    private _mcpServerRenderer?;
+}
+/**
+ * Namespace for AISettingsWidget types and interfaces
+ */
+export declare namespace AISettingsWidget {
+    /**
+     * Options interface for constructing an AISettingsWidget
+     */
+    interface IOptions {
+        settingsModel: IAISettingsModel;
+        agentManagerFactory?: IAgentManagerFactory;
+        themeManager?: IThemeManager;
+        providerRegistry: IProviderRegistry;
+        /**
+         * Access to provider secrets in the shared namespace.
+         */
+        secretsAccess: IAISecretsAccess;
+        /**
+         * The application language translation bundle.
+         */
+        trans: TranslationBundle;
+        /**
+         * The renderer for the MCP settings.
+         */
+        mcpServerRenderer?: React.ComponentType<any>;
+    }
+}
+//# sourceMappingURL=ai-settings.d.ts.map