@jupyterlite/ai 0.17.0 → 0.19.0

package/lib/components/usage-display.js

@@ -1,5 +1,5 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { ReactWidget, UseSignal } from '@jupyterlab/ui-components';
-import React from 'react';
 /**
  * React component that displays usage information.
  * Shows input/output token counts and optional estimated context usage.
@@ -21,69 +21,58 @@ export const UsageDisplay = ({ tokenUsageChanged, settingsModel, initialTokenUsa
         borderRadius: '4px',
         whiteSpace: 'nowrap'
     };
-    return (React.createElement(UseSignal, { signal: settingsModel.stateChanged, initialArgs: undefined }, () => {
-        const config = settingsModel.config;
-        const showTokenUsage = config.showTokenUsage;
-        const showContextUsage = config.showContextUsage;
-        if (!showTokenUsage && !showContextUsage) {
-            return null;
-        }
-        return (React.createElement(UseSignal, { signal: tokenUsageChanged, initialArgs: initialTokenUsage }, (_, tokenUsage) => {
-            if (!tokenUsage) {
+    return (_jsx(UseSignal, { signal: settingsModel.stateChanged, initialArgs: undefined, children: () => {
+            const config = settingsModel.config;
+            const showTokenUsage = config.showTokenUsage;
+            const showContextUsage = config.showContextUsage;
+            if (!showTokenUsage && !showContextUsage) {
                 return null;
             }
-            const total = tokenUsage.inputTokens + tokenUsage.outputTokens;
-            const hasKnownContextWindow = showContextUsage && tokenUsage.contextWindow !== undefined;
-            const contextUsagePercent = tokenUsage.lastRequestInputTokens !== undefined &&
-                tokenUsage.contextWindow !== undefined &&
-                tokenUsage.contextWindow > 0
-                ? Math.max(0, Math.min(100, (tokenUsage.lastRequestInputTokens /
-                    tokenUsage.contextWindow) *
-                    100))
-                : undefined;
-            const hasContextEstimate = hasKnownContextWindow &&
-                contextUsagePercent !== undefined &&
-                tokenUsage.lastRequestInputTokens !== undefined;
-            const contextLabel = hasContextEstimate
-                ? `${formatContextPercent(contextUsagePercent)}%`
-                : hasKnownContextWindow
-                    ? '0%'
-                    : '?';
-            const contextTitle = hasContextEstimate
-                ? trans.__('Context Usage (estimated): %1% (%2 / %3 tokens)', formatContextPercent(contextUsagePercent), tokenUsage.lastRequestInputTokens.toLocaleString(), tokenUsage.contextWindow.toLocaleString())
-                : hasKnownContextWindow
-                    ? trans.__('Context usage estimate will appear after the next request. Showing 0% until then. Context window: %1 tokens', tokenUsage.contextWindow.toLocaleString())
-                    : trans.__('Context Usage unavailable. Configure a context window for the active provider/model to enable estimation.');
-            return (React.createElement("div", { style: {
-                    display: 'flex',
-                    alignItems: 'center',
-                    gap: '6px'
-                } },
-                showTokenUsage && (React.createElement("span", { style: badgeStyle, title: trans.__('Token Usage - Sent: %1, Received: %2, Total: %3', tokenUsage.inputTokens.toLocaleString(), tokenUsage.outputTokens.toLocaleString(), total.toLocaleString()) },
-                    React.createElement("span", { style: {
+            return (_jsx(UseSignal, { signal: tokenUsageChanged, initialArgs: initialTokenUsage, children: (_, tokenUsage) => {
+                    if (!tokenUsage) {
+                        return null;
+                    }
+                    const total = tokenUsage.inputTokens + tokenUsage.outputTokens;
+                    const hasKnownContextWindow = showContextUsage && tokenUsage.contextWindow !== undefined;
+                    const contextUsagePercent = tokenUsage.lastRequestInputTokens !== undefined &&
+                        tokenUsage.contextWindow !== undefined &&
+                        tokenUsage.contextWindow > 0
+                        ? Math.max(0, Math.min(100, (tokenUsage.lastRequestInputTokens /
+                            tokenUsage.contextWindow) *
+                            100))
+                        : undefined;
+                    const hasContextEstimate = hasKnownContextWindow &&
+                        contextUsagePercent !== undefined &&
+                        tokenUsage.lastRequestInputTokens !== undefined;
+                    const contextLabel = hasContextEstimate
+                        ? `${formatContextPercent(contextUsagePercent)}%`
+                        : hasKnownContextWindow
+                            ? '0%'
+                            : '?';
+                    const contextTitle = hasContextEstimate
+                        ? trans.__('Context Usage (estimated): %1% (%2 / %3 tokens)', formatContextPercent(contextUsagePercent), tokenUsage.lastRequestInputTokens.toLocaleString(), tokenUsage.contextWindow.toLocaleString())
+                        : hasKnownContextWindow
+                            ? trans.__('Context usage estimate will appear after the next request. Showing 0% until then. Context window: %1 tokens', tokenUsage.contextWindow.toLocaleString())
+                            : trans.__('Context Usage unavailable. Configure a context window for the active provider/model to enable estimation.');
+                    return (_jsxs("div", { style: {
                             display: 'flex',
                             alignItems: 'center',
-                            gap: '2px'
-                        } },
-                        React.createElement("span", null, "\u2191"),
-                        React.createElement("span", null, tokenUsage.inputTokens.toLocaleString())),
-                    React.createElement("span", { style: {
-                            display: 'flex',
-                            alignItems: 'center',
-                            gap: '2px'
-                        } },
-                        React.createElement("span", null, "\u2193"),
-                        React.createElement("span", null, tokenUsage.outputTokens.toLocaleString())))),
-                showContextUsage && (React.createElement("span", { style: badgeStyle, title: contextTitle },
-                    React.createElement("span", { style: {
-                            display: 'flex',
-                            alignItems: 'center',
-                            gap: '2px'
-                        } },
-                        React.createElement("span", null, "ctx"),
-                        React.createElement("span", null, contextLabel))))));
-        }));
-    }));
+                            gap: '6px'
+                        }, children: [showTokenUsage && (_jsxs("span", { style: badgeStyle, title: trans.__('Token Usage - Sent: %1, Received: %2, Total: %3', tokenUsage.inputTokens.toLocaleString(), tokenUsage.outputTokens.toLocaleString(), total.toLocaleString()), children: [_jsxs("span", { style: {
+                                            display: 'flex',
+                                            alignItems: 'center',
+                                            gap: '2px'
+                                        }, children: [_jsx("span", { children: "\u2191" }), _jsx("span", { children: tokenUsage.inputTokens.toLocaleString() })] }), _jsxs("span", { style: {
+                                            display: 'flex',
+                                            alignItems: 'center',
+                                            gap: '2px'
+                                        }, children: [_jsx("span", { children: "\u2193" }), _jsx("span", { children: tokenUsage.outputTokens.toLocaleString() })] })] })), showContextUsage && (_jsx("span", { style: badgeStyle, title: contextTitle, children: _jsxs("span", { style: {
+                                        display: 'flex',
+                                        alignItems: 'center',
+                                        gap: '2px'
+                                    }, children: [_jsx("span", { children: "ctx" }), _jsx("span", { children: contextLabel })] }) }))] }));
+                } }));
+        } }));
 };
 /**
  * JupyterLab widget wrapper for the UsageDisplay component.
@@ -103,7 +92,7 @@ export class UsageWidget extends ReactWidget {
      * @returns The UsageDisplay React element
      */
     render() {
-        return React.createElement(UsageDisplay, { ...this._options });
+        return _jsx(UsageDisplay, { ...this._options });
     }
     _options;
 }

package/lib/diff-manager.d.ts

@@ -1,5 +1,6 @@
+import type { IDiffManager, IShowCellDiffParams, IShowFileDiffParams } from '@jupyternaut/agent';
 import { CommandRegistry } from '@lumino/commands';
-import type { IAISettingsModel, IDiffManager, IShowCellDiffParams, IShowFileDiffParams } from './tokens';
+import type { IAISettingsModel } from './tokens';
 /**
  * Implementation of the diff manager
  */
@@ -22,3 +23,4 @@ export declare class DiffManager implements IDiffManager {
     private _commands;
     private _settingsModel;
 }
+//# sourceMappingURL=diff-manager.d.ts.map

package/lib/index.d.ts

@@ -1,7 +1,8 @@
+import { IAgentManagerFactory, IDiffManager, IProviderRegistry, IToolRegistry, ISkillRegistry } from '@jupyternaut/agent';
 import { JupyterFrontEndPlugin } from '@jupyterlab/application';
 import { IChatCommandRegistry, IChatTracker, IInputToolbarRegistryFactory } from '@jupyter/chat';
-import { IAgentManagerFactory, IAISettingsModel, IChatModelHandler, IDiffManager, IProviderRegistry, IToolRegistry, ISkillRegistry } from './tokens';
+import { IAISettingsModel, IChatModelHandler } from './tokens';
 declare const _default: (JupyterFrontEndPlugin<IProviderRegistry> | JupyterFrontEndPlugin<void> | JupyterFrontEndPlugin<IChatCommandRegistry> | JupyterFrontEndPlugin<IChatModelHandler> | JupyterFrontEndPlugin<IChatTracker> | JupyterFrontEndPlugin<IAgentManagerFactory> | JupyterFrontEndPlugin<IAISettingsModel> | JupyterFrontEndPlugin<IDiffManager> | JupyterFrontEndPlugin<ISkillRegistry> | JupyterFrontEndPlugin<IToolRegistry> | JupyterFrontEndPlugin<IInputToolbarRegistryFactory>)[];
 export default _default;
 export * from './tokens';
-export * from './icons';
+//# sourceMappingURL=index.d.ts.map

package/lib/index.js

@@ -1,3 +1,4 @@
+import { anthropicProvider, createBrowserFetchTool, createDiscoverCommandsTool, createDiscoverSkillsTool, createExecuteCommandTool, createLoadSkillTool, genericProvider, googleProvider, loadSkillsFromPaths, mistralProvider, openaiProvider, AgentManagerFactory, IAgentManagerFactory, IDiffManager, IProviderRegistry, IToolRegistry, ISkillRegistry, ProviderRegistry, SECRETS_NAMESPACE, SkillRegistry, ToolRegistry } from '@jupyternaut/agent';
 import { ILabShell, ILayoutRestorer } from '@jupyterlab/application';
 import { ActiveCellManager, AttachmentOpenerRegistry, chatIcon, ChatCommandRegistry, ChatWidget, IChatCommandRegistry, IChatTracker, IInputToolbarRegistryFactory, InputToolbarRegistry, MultiChatPanel } from '@jupyter/chat';
 import { ICommandPalette, IThemeManager, showDialog, showErrorMessage, WidgetTracker } from '@jupyterlab/apputils';
@@ -11,28 +12,20 @@ import { IStatusBar } from '@jupyterlab/statusbar';
 import { PathExt } from '@jupyterlab/coreutils';
 import { ITranslator, nullTranslator } from '@jupyterlab/translation';
 import { fileUploadIcon, saveIcon, settingsIcon, Toolbar, ToolbarButton } from '@jupyterlab/ui-components';
-import { PromiseDelegate, UUID } from '@lumino/coreutils';
+import { UUID } from '@lumino/coreutils';
 import { DisposableSet } from '@lumino/disposable';
 import { IComponentsRendererFactory } from 'jupyter-chat-components';
 import { ISecretsManager, SecretsManager } from 'jupyter-secrets-manager';
-import { AgentManagerFactory } from './agent';
 import { RenderedMessageOutputAreaCompat } from './rendered-message-outputarea';
 import { ClearCommandProvider } from './chat-commands/clear';
 import { SkillsCommandProvider } from './chat-commands/skills';
-import { ProviderRegistry } from './providers/provider-registry';
 import { SaveComponentWidget } from './components/save-button';
 import { ChatModelHandler } from './chat-model-handler';
-import { CommandIds, IAgentManagerFactory, IAISettingsModel, IChatModelHandler, IDiffManager, IProviderRegistry, IToolRegistry, ISkillRegistry, SECRETS_NAMESPACE } from './tokens';
-import { anthropicProvider, googleProvider, mistralProvider, openaiProvider, genericProvider } from './providers/built-in-providers';
+import { CommandIds, IAISettingsModel, IChatModelHandler } from './tokens';
 import { AICompletionProvider } from './completion';
 import { clearItem, createModelSelectItem, createToolSelectItem, stopItem, CompletionStatusWidget, UsageWidget } from './components';
 import { AISettingsModel } from './models/settings-model';
-import { loadSkillsFromPaths, SkillRegistry } from './skills';
 import { DiffManager } from './diff-manager';
-import { ToolRegistry } from './tools/tool-registry';
-import { createDiscoverCommandsTool, createExecuteCommandTool } from './tools/commands';
-import { createDiscoverSkillsTool, createLoadSkillTool } from './tools/skills';
-import { createBrowserFetchTool } from './tools/web';
 import { AISettingsWidget } from './widgets/ai-settings';
 import { MainAreaChat } from './widgets/main-area-chat';
 var Private;
@@ -386,12 +379,10 @@ const plugin = {
                 // Check if AI is currently writing (streaming)
                 const aiWriting = writers.some(writer => writer.user.username === 'ai-assistant');
                 if (aiWriting) {
-                    widget.inputToolbarRegistry?.hide('send');
                     widget.inputToolbarRegistry?.show('stop');
                 }
                 else {
                     widget.inputToolbarRegistry?.hide('stop');
-                    widget.inputToolbarRegistry?.show('send');
                 }
             }
             model.writersChanged?.connect(writersChanged);
@@ -439,19 +430,48 @@ const plugin = {
         });
         registerCommands(app, rmRegistry, chatPanel, attachmentOpenerRegistry, inputToolbarFactory, settingsModel, chatCommandRegistry, tracker, modelHandler, trans, themeManager, labShell, palette, documentManager);
         /**
-         * The callback to approve or reject a tool.
+         * The callback for grouped tool calls permission decisions.
          */
-        function toolCallApproval(targetId, approvalId, isApproved) {
-            const model = tracker.find(chat => chat.model.name === targetId)?.model;
+        function toolCallPermissionDecision(sessionId, toolCallId, optionId) {
+            const model = tracker.find(chat => chat.model.name === sessionId)
+                ?.model;
             if (!model) {
                 return;
             }
+            const isApproved = optionId === 'approve';
             isApproved
-                ? model.agentManager.approveToolCall(approvalId)
-                : model.agentManager.rejectToolCall(approvalId);
+                ? model.agentManager.approveToolCall(toolCallId)
+                : model.agentManager.rejectToolCall(toolCallId);
         }
         if (chatComponentsFactory) {
-            chatComponentsFactory.toolCallApproval = toolCallApproval;
+            chatComponentsFactory.groupedToolCallCallbacks = {
+                ...chatComponentsFactory.groupedToolCallCallbacks,
+                toolCallPermissionDecision
+            };
+            chatComponentsFactory.queueMessageCallbacks = {
+                ...chatComponentsFactory.queueMessageCallbacks,
+                removeQueuedMessage: (targetId, messageId) => {
+                    const model = tracker.find(chat => chat.model.name === targetId)?.model;
+                    if (!model) {
+                        return;
+                    }
+                    model.removeQueuedMessage(messageId);
+                },
+                reorderQueuedMessages: (targetId, messageIds) => {
+                    const model = tracker.find(chat => chat.model.name === targetId)?.model;
+                    if (!model) {
+                        return;
+                    }
+                    model.reorderQueuedMessages(messageIds);
+                },
+                editQueuedMessage: (targetId, messageId, newBody) => {
+                    const model = tracker.find(chat => chat.model.name === targetId)?.model;
+                    if (!model) {
+                        return;
+                    }
+                    model.editQueuedMessage(messageId, newBody);
+                }
+            };
         }
         return tracker;
     }
@@ -502,11 +522,12 @@ function registerCommands(app, rmRegistry, chatPanel, attachmentOpenerRegistry,
             }
         });
         const openInMain = (model) => {
+            const inputToolbarRegistry = inputToolbarFactory.create();
             const content = new ChatWidget({
                 model,
                 rmRegistry,
                 themeManager: themeManager ?? null,
-                inputToolbarRegistry: inputToolbarFactory.create(),
+                inputToolbarRegistry,
                 attachmentOpenerRegistry,
                 chatCommandRegistry
             });
@@ -771,54 +792,25 @@ function registerCommands(app, rmRegistry, chatPanel, attachmentOpenerRegistry,
                     console.error('Error while moving the chat to main area: there is no reference model');
                     return false;
                 }
-                // Listen for the widget updated in tracker, to ensure the previous model name
-                // has been updated. This is required to remove the widget from the restorer
-                // when the previous widget is disposed.
-                const trackerUpdated = new PromiseDelegate();
-                const widgetUpdated = (_, widget) => {
-                    if (widget.model === previousModel) {
-                        trackerUpdated.resolve(true);
-                    }
-                };
-                tracker.widgetUpdated.connect(widgetUpdated);
-                // Rename temporary the previous model to be able to reuse this name for the new
-                // model. The previous is intended to be disposed anyway.
-                previousModel.name = UUID.uuid4();
-                // Create a new model by duplicating the previous model attributes.
-                const model = modelRegistry.createModel({
-                    name: args.name,
-                    activeProvider: previousModel.agentManager.activeProvider,
-                    tokenUsage: previousModel.agentManager.tokenUsage,
-                    messages: previousModel.messages,
-                    autosave: previousModel.autosave,
-                    title: previousModel.title
-                });
-                // Wait (with timeout) for the tracker to have updated the previous widget.
-                const status = await Promise.any([
-                    trackerUpdated.promise,
-                    new Promise(r => setTimeout(() => {
-                        r(false);
-                    }, 2000))
-                ]);
-                tracker.widgetUpdated.disconnect(widgetUpdated);
-                if (!status) {
-                    return false;
-                }
                 if (area === 'main') {
-                    openInMain(model);
+                    // Temporarily bypass model disposal to transport model to main view
+                    // to keep the conversation when switching views
+                    // TODO: Remove this code when jupyter-chat PR #423 is merged and released
+                    const originalDispose = previousModel.dispose.bind(previousModel);
+                    previousModel.dispose = () => { };
                     if (previousWidget instanceof ChatWidget) {
-                        // Clean up the side-panel model entry before disposing the previous
-                        // widget/model state.
                         if (!disposeSideChatModel(previousModel)) {
                             previousWidget.dispose();
-                            previousModel.dispose();
                         }
                     }
+                    // Restore model disposal and transport to main view
+                    previousModel.dispose = originalDispose;
+                    openInMain(previousModel);
                 }
                 else {
+                    // MainAreaChat disposal does not dispose the model internally, so this is safe.
                     previousWidget?.dispose();
-                    previousModel.dispose();
-                    chatPanel.open({ model });
+                    chatPanel.open({ model: previousModel });
                 }
                 return true;
             },
@@ -1313,4 +1305,3 @@ export default [
 ];
 // Export extension points for other extensions to use
 export * from './tokens';
-export * from './icons';

package/lib/models/settings-model.d.ts

@@ -1,6 +1,7 @@
+import type { IAIConfig, IMCPServerConfig, IProviderConfig } from '@jupyternaut/agent';
 import { VDomModel } from '@jupyterlab/ui-components';
 import { ISettingRegistry } from '@jupyterlab/settingregistry';
-import { IAIConfig, IAISettingsModel, IMCPServerConfig, IProviderConfig } from '../tokens';
+import type { IAISettingsModel } from '../tokens';
 export declare class AISettingsModel extends VDomModel implements IAISettingsModel {
     private _config;
     private _settingRegistry;
@@ -38,3 +39,4 @@ export declare namespace AISettingsModel {
         settingRegistry: ISettingRegistry;
     }
 }
+//# sourceMappingURL=settings-model.d.ts.map

package/lib/models/settings-model.js

@@ -19,6 +19,7 @@ export class AISettingsModel extends VDomModel {
         diffDisplayMode: 'split',
         skillsPaths: ['.agents/skills', '_agents/skills'],
         chatBackupDirectory: '',
+        autoTitle: false,
         commandsRequiringApproval: [
             'notebook:restart-run-all',
             'notebook:run-cell',

package/lib/rendered-message-outputarea.d.ts

@@ -22,3 +22,4 @@ export declare namespace RenderedMessageOutputAreaCompat {
         chatPanel: ChatWidget;
     }
 }
+//# sourceMappingURL=rendered-message-outputarea.d.ts.map