@jupyterlite/ai 0.18.0 → 0.19.0

package/lib/components/stop-button.js

@@ -1,18 +1,17 @@
+import { jsx as _jsx } from "react/jsx-runtime";
 import { TooltippedIconButton } from '@jupyter/chat';
 import StopIcon from '@mui/icons-material/Stop';
-import React from 'react';
 /**
  * The stop button component.
  */
 export function StopButton(props) {
     const { translator: trans } = props;
     const tooltip = trans.__('Stop streaming');
-    return (React.createElement(TooltippedIconButton, { onClick: props.stopStreaming, tooltip: tooltip, buttonProps: {
+    return (_jsx(TooltippedIconButton, { onClick: props.stopStreaming, tooltip: tooltip, buttonProps: {
             title: tooltip
         }, sx: {
             backgroundColor: 'var(--mui-palette-error-main, #d32f2f);'
-        } },
-        React.createElement(StopIcon, null)));
+        }, children: _jsx(StopIcon, {}) }));
 }
 /**
  * Factory returning the stop button toolbar item.

package/lib/components/tool-select.d.ts

@@ -1,6 +1,7 @@
+import type { IProviderRegistry, IToolRegistry } from '@jupyternaut/agent';
 import { InputToolbarRegistry } from '@jupyter/chat';
 import type { TranslationBundle } from '@jupyterlab/translation';
-import type { IAISettingsModel, IProviderRegistry, IToolRegistry } from '../tokens';
+import type { IAISettingsModel } from '../tokens';
 /**
  * Properties for the tool select component.
  */
@@ -38,3 +39,4 @@ export declare function ToolSelect(props: IToolSelectProps): JSX.Element;
  * Factory function returning the toolbar item for tool selection.
  */
 export declare function createToolSelectItem(toolRegistry: IToolRegistry, settingsModel: IAISettingsModel, providerRegistry: IProviderRegistry, toolsEnabled: boolean | undefined, translator: TranslationBundle): InputToolbarRegistry.IToolbarItem;
+//# sourceMappingURL=tool-select.d.ts.map

package/lib/components/tool-select.js

@@ -1,9 +1,10 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { createProviderTools } from '@jupyternaut/agent';
 import { TooltippedButton } from '@jupyter/chat';
 import BuildIcon from '@mui/icons-material/Build';
 import CheckIcon from '@mui/icons-material/Check';
 import { Divider, Menu, MenuItem, Tooltip, Typography } from '@mui/material';
-import React, { useCallback, useEffect, useState } from 'react';
-import { createProviderTools } from '../providers/provider-tools';
+import { useCallback, useEffect, useState } from 'react';
 const SELECT_ITEM_CLASS = 'jp-AIToolSelect-item';
 /**
  * The tool select component for choosing AI tools.
@@ -97,68 +98,54 @@ export function ToolSelect(props) {
     }, [tools, selectedToolNames.length, onToolSelectionChange]);
     // Don't render if tools are disabled or no tools available
     if (!toolsEnabled || (tools.length === 0 && providerToolNames.length === 0)) {
-        return React.createElement(React.Fragment, null);
+        return _jsx(_Fragment, {});
     }
     const selectedCount = selectedToolNames.length + providerToolNames.length;
     const totalCount = tools.length + providerToolNames.length;
-    return (React.createElement(React.Fragment, null,
-        React.createElement(TooltippedButton, { onClick: e => {
-                openMenu(e.currentTarget);
-            }, tooltip: trans.__('Tools (%1/%2 selected)', selectedCount.toString(), totalCount.toString()), buttonProps: {
-                ...(selectedCount === 0 && {
-                    variant: 'outlined'
-                }),
-                title: trans.__('Select AI Tools'),
-                onKeyDown: e => {
-                    if (e.key !== 'Enter' && e.key !== ' ') {
-                        return;
-                    }
+    return (_jsxs(_Fragment, { children: [_jsx(TooltippedButton, { onClick: e => {
                     openMenu(e.currentTarget);
-                    // Stop propagation to prevent sending message
-                    e.stopPropagation();
-                }
-            }, sx: selectedCount === 0
-                ? { backgroundColor: 'var(--jp-layout-color3)' }
-                : {} },
-            React.createElement(BuildIcon, { sx: { fontSize: 'small' } })),
-        React.createElement(Menu, { open: menuOpen, onClose: closeMenu, anchorEl: menuAnchorEl, anchorOrigin: {
-                vertical: 'top',
-                horizontal: 'right'
-            }, transformOrigin: {
-                vertical: 'bottom',
-                horizontal: 'right'
-            }, sx: {
-                '& .MuiMenuItem-root': {
-                    padding: '0.5em',
-                    paddingRight: '2em'
-                }
-            } },
-            tools.map(namedTool => (React.createElement(Tooltip, { key: namedTool.name, title: namedTool.tool.description || namedTool.name, placement: "left" },
-                React.createElement(MenuItem, { className: SELECT_ITEM_CLASS, onClick: e => {
-                        toggleTool(namedTool.name);
-                        // Prevent sending message on tool selection
+                }, tooltip: trans.__('Tools (%1/%2 selected)', selectedCount.toString(), totalCount.toString()), buttonProps: {
+                    ...(selectedCount === 0 && {
+                        variant: 'outlined'
+                    }),
+                    title: trans.__('Select AI Tools'),
+                    onKeyDown: e => {
+                        if (e.key !== 'Enter' && e.key !== ' ') {
+                            return;
+                        }
+                        openMenu(e.currentTarget);
+                        // Stop propagation to prevent sending message
                         e.stopPropagation();
-                    } },
-                    selectedToolNames.includes(namedTool.name) ? (React.createElement(CheckIcon, { sx: {
-                            marginRight: '8px',
-                            color: 'var(--jp-brand-color1, #2196F3)'
-                        } })) : (React.createElement("div", { style: { width: '24px', marginRight: '8px' } })),
-                    React.createElement(Typography, { variant: "body2" }, namedTool.name))))),
-            providerToolNames.length > 0 && tools.length > 0 && React.createElement(Divider, null),
-            providerToolNames.length > 0 && (React.createElement(MenuItem, { disabled: true },
-                React.createElement(Typography, { variant: "caption" }, trans.__('Provider Tools')))),
-            providerToolNames.map(toolName => {
-                return (React.createElement(Tooltip, { key: toolName, title: trans.__('Enabled via provider settings.'), placement: "left" },
-                    React.createElement(MenuItem, { className: SELECT_ITEM_CLASS, onClick: e => {
-                            // Keep provider-managed tools read-only from this menu.
-                            e.stopPropagation();
-                        } },
-                        React.createElement(CheckIcon, { sx: {
-                                marginRight: '8px',
-                                color: 'text.disabled'
-                            } }),
-                        React.createElement(Typography, { variant: "body2" }, toolName))));
-            }))));
+                    }
+                }, sx: selectedCount === 0
+                    ? { backgroundColor: 'var(--jp-layout-color3)' }
+                    : {}, children: _jsx(BuildIcon, { sx: { fontSize: 'small' } }) }), _jsxs(Menu, { open: menuOpen, onClose: closeMenu, anchorEl: menuAnchorEl, anchorOrigin: {
+                    vertical: 'top',
+                    horizontal: 'right'
+                }, transformOrigin: {
+                    vertical: 'bottom',
+                    horizontal: 'right'
+                }, sx: {
+                    '& .MuiMenuItem-root': {
+                        padding: '0.5em',
+                        paddingRight: '2em'
+                    }
+                }, children: [tools.map(namedTool => (_jsx(Tooltip, { title: namedTool.tool.description || namedTool.name, placement: "left", children: _jsxs(MenuItem, { className: SELECT_ITEM_CLASS, onClick: e => {
+                                toggleTool(namedTool.name);
+                                // Prevent sending message on tool selection
+                                e.stopPropagation();
+                            }, children: [selectedToolNames.includes(namedTool.name) ? (_jsx(CheckIcon, { sx: {
+                                        marginRight: '8px',
+                                        color: 'var(--jp-brand-color1, #2196F3)'
+                                    } })) : (_jsx("div", { style: { width: '24px', marginRight: '8px' } })), _jsx(Typography, { variant: "body2", children: namedTool.name })] }) }, namedTool.name))), providerToolNames.length > 0 && tools.length > 0 && _jsx(Divider, {}), providerToolNames.length > 0 && (_jsx(MenuItem, { disabled: true, children: _jsx(Typography, { variant: "caption", children: trans.__('Provider Tools') }) })), providerToolNames.map(toolName => {
+                        return (_jsx(Tooltip, { title: trans.__('Enabled via provider settings.'), placement: "left", children: _jsxs(MenuItem, { className: SELECT_ITEM_CLASS, onClick: e => {
+                                    // Keep provider-managed tools read-only from this menu.
+                                    e.stopPropagation();
+                                }, children: [_jsx(CheckIcon, { sx: {
+                                            marginRight: '8px',
+                                            color: 'text.disabled'
+                                        } }), _jsx(Typography, { variant: "body2", children: toolName })] }) }, toolName));
+                    })] })] }));
 }
 /**
  * Factory function returning the toolbar item for tool selection.
@@ -183,7 +170,7 @@ export function createToolSelectItem(toolRegistry, settingsModel, providerRegist
                 toolsEnabled,
                 translator
             };
-            return React.createElement(ToolSelect, { ...toolSelectProps });
+            return _jsx(ToolSelect, { ...toolSelectProps });
         },
         position: 1
     };

package/lib/components/usage-display.d.ts

@@ -1,8 +1,9 @@
+import type { ITokenUsage } from '@jupyternaut/agent';
 import { ReactWidget } from '@jupyterlab/ui-components';
 import type { TranslationBundle } from '@jupyterlab/translation';
-import React from 'react';
 import { ISignal } from '@lumino/signaling';
-import type { IAISettingsModel, ITokenUsage } from '../tokens';
+import React from 'react';
+import type { IAISettingsModel } from '../tokens';
 /**
  * Props for the UsageDisplay component.
  */
@@ -47,3 +48,4 @@ export declare class UsageWidget extends ReactWidget {
     protected render(): React.ReactElement;
     private _options;
 }
+//# sourceMappingURL=usage-display.d.ts.map

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';
@@ -15,24 +16,16 @@ 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;
@@ -451,14 +444,33 @@ const plugin = {
                 : model.agentManager.rejectToolCall(toolCallId);
         }
         if (chatComponentsFactory) {
-            chatComponentsFactory.toolCallPermissionDecision =
-                toolCallPermissionDecision;
-            chatComponentsFactory.removeQueuedMessage = (targetId, messageId) => {
-                const model = tracker.find(chat => chat.model.name === targetId)?.model;
-                if (!model) {
-                    return;
+            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);
                 }
-                model.removeQueuedMessage(messageId);
             };
         }
         return tracker;
@@ -1293,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/rendered-message-outputarea.d.ts

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