@jupyterlite/ai 0.12.0 → 0.13.0

package/lib/index.js

@@ -1,6 +1,6 @@
 import { ILabShell, ILayoutRestorer } from '@jupyterlab/application';
-import { ActiveCellManager, AttachmentOpenerRegistry, chatIcon, ChatCommandRegistry, ChatWidget, IChatCommandRegistry, IInputToolbarRegistryFactory, InputToolbarRegistry, MultiChatPanel } from '@jupyter/chat';
-import { ICommandPalette, IThemeManager, WidgetTracker } from '@jupyterlab/apputils';
+import { ActiveCellManager, AttachmentOpenerRegistry, chatIcon, ChatCommandRegistry, ChatWidget, IChatCommandRegistry, IChatTracker, IInputToolbarRegistryFactory, InputToolbarRegistry, MultiChatPanel } from '@jupyter/chat';
+import { ICommandPalette, IThemeManager, showErrorMessage, WidgetTracker } from '@jupyterlab/apputils';
 import { ICompletionProviderManager } from '@jupyterlab/completer';
 import { IDocumentManager } from '@jupyterlab/docmanager';
 import { INotebookTracker } from '@jupyterlab/notebook';
@@ -14,12 +14,13 @@ import { ISecretsManager, SecretsManager } from 'jupyter-secrets-manager';
 import { PromiseDelegate, UUID } from '@lumino/coreutils';
 import { DisposableSet } from '@lumino/disposable';
 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 { ApprovalButtons } from './approval-buttons';
-import { ChatModelRegistry } from './chat-model-registry';
-import { CommandIds, IAgentManagerFactory, IProviderRegistry, IToolRegistry, ISkillRegistry, SECRETS_NAMESPACE, IAISettingsModel, IChatModelRegistry, IDiffManager } from './tokens';
+import { ChatModelHandler } from './chat-model-handler';
+import { CommandIds, IAgentManagerFactory, IProviderRegistry, IToolRegistry, ISkillRegistry, SECRETS_NAMESPACE, IAISettingsModel, IChatModelHandler, IDiffManager } from './tokens';
 import { anthropicProvider, googleProvider, mistralProvider, openaiProvider, genericProvider } from './providers/built-in-providers';
 import { AICompletionProvider } from './completion';
 import { clearItem, createModelSelectItem, createToolSelectItem, stopItem, CompletionStatusWidget, TokenUsageWidget } from './components';
@@ -29,6 +30,7 @@ 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';
 /**
@@ -143,21 +145,27 @@ const skillsCommandPlugin = {
     }
 };
 /**
- * The chat model registry.
+ * The chat model handler.
  */
-const chatModelRegistry = {
-    id: '@jupyterlite/ai:chat-model-registry',
-    description: 'Registry for the current chat model',
+const chatModelHandler = {
+    id: '@jupyterlite/ai:chat-model-handler',
+    description: 'A handler to create current chat model',
     autoStart: true,
-    requires: [IAISettingsModel, IAgentManagerFactory, IDocumentManager],
+    requires: [
+        IAISettingsModel,
+        IAgentManagerFactory,
+        IDocumentManager,
+        IRenderMimeRegistry
+    ],
     optional: [IProviderRegistry, IToolRegistry, ITranslator],
-    provides: IChatModelRegistry,
-    activate: (app, settingsModel, agentManagerFactory, docManager, providerRegistry, toolRegistry, translator) => {
+    provides: IChatModelHandler,
+    activate: (app, settingsModel, agentManagerFactory, docManager, rmRegistry, providerRegistry, toolRegistry, translator) => {
         const trans = (translator ?? nullTranslator).load('jupyterlite_ai');
-        return new ChatModelRegistry({
+        return new ChatModelHandler({
             settingsModel,
             agentManagerFactory,
             docManager,
+            rmRegistry,
             providerRegistry,
             toolRegistry,
             trans
@@ -171,10 +179,11 @@ const plugin = {
     id: '@jupyterlite/ai:plugin',
     description: 'AI in JupyterLab',
     autoStart: true,
+    provides: IChatTracker,
     requires: [
         IRenderMimeRegistry,
         IInputToolbarRegistryFactory,
-        IChatModelRegistry,
+        IChatModelHandler,
         IAISettingsModel,
         IChatCommandRegistry
     ],
@@ -185,7 +194,7 @@ const plugin = {
         INotebookTracker,
         ITranslator
     ],
-    activate: (app, rmRegistry, inputToolbarFactory, modelRegistry, settingsModel, chatCommandRegistry, themeManager, restorer, labShell, notebookTracker, translator) => {
+    activate: (app, rmRegistry, inputToolbarFactory, modelHandler, settingsModel, chatCommandRegistry, themeManager, restorer, labShell, notebookTracker, translator) => {
         const trans = (translator ?? nullTranslator).load('jupyterlite_ai');
         // Create attachment opener registry to handle file attachments
         const attachmentOpenerRegistry = new AttachmentOpenerRegistry();
@@ -204,7 +213,10 @@ const plugin = {
                 shell: app.shell
             });
         }
-        modelRegistry.activeCellManager = activeCellManager;
+        modelHandler.activeCellManager = activeCellManager;
+        // Creating the tracker for the chat widgets
+        const namespace = 'ai-chat';
+        const tracker = new WidgetTracker({ namespace });
         // Create chat panel with drag/drop functionality
         const chatPanel = new MultiChatPanel({
             rmRegistry,
@@ -212,19 +224,35 @@ const plugin = {
             inputToolbarFactory,
             attachmentOpenerRegistry,
             chatCommandRegistry,
-            createModel: async (name) => {
-                const model = modelRegistry.createModel(name);
+            createModel: async (provider) => {
+                if (!provider) {
+                    provider = settingsModel.getDefaultProvider()?.id;
+                    if (!provider) {
+                        showErrorMessage('Error creating chat', 'Please set up a provider');
+                        app.commands.execute('@jupyterlite/ai:open-settings');
+                        return {};
+                    }
+                }
+                let name = settingsModel.getProvider(provider)?.name ?? UUID.uuid4();
+                const modelName = name;
+                const existingName = new Set(chatPanel.getLoadedModelNames());
+                tracker.forEach(widget => existingName.add(widget.model.name));
+                let i = 1;
+                while (existingName.has(name)) {
+                    name = `${modelName}-${i}`;
+                    i += 1;
+                }
+                const model = modelHandler.createModel(name, provider);
                 return { model };
             },
-            renameChat: async (oldName, newName) => {
-                const model = modelRegistry.get(oldName);
-                const concurrencyModel = modelRegistry.get(newName);
-                if (model && !concurrencyModel) {
-                    model.name = newName;
-                    return true;
-                }
-                return false;
+            getChatNames: async () => {
+                const names = {};
+                settingsModel.config.providers.forEach(provider => {
+                    names[provider.name] = provider.id;
+                });
+                return names;
             },
+            renameChat: true,
             openInMain: (name) => app.commands.execute(CommandIds.moveChat, {
                 area: 'main',
                 name
@@ -241,23 +269,29 @@ const plugin = {
             },
             tooltip: trans.__('Open AI Settings')
         }));
-        chatPanel.sectionAdded.connect((_, section) => {
-            const { widget } = section;
-            const model = section.model;
+        let tokenUsageWidget = null;
+        chatPanel.chatOpened.connect((_, widget) => {
+            const model = widget.model;
             // Add the widget to the tracker.
             tracker.add(widget);
+            function saveTracker() {
+                tracker.save(widget);
+            }
             // Update the tracker if the model name changed.
-            model.nameChanged.connect(() => tracker.save(widget));
+            model.nameChanged.connect(saveTracker);
             // Update the tracker if the active provider changed.
-            model.agentManager.activeProviderChanged.connect(() => tracker.save(widget));
-            const tokenUsageWidget = new TokenUsageWidget({
+            model.agentManager.activeProviderChanged.connect(saveTracker);
+            // Update the token usage widget.
+            tokenUsageWidget?.dispose();
+            tokenUsageWidget = new TokenUsageWidget({
                 tokenUsageChanged: model.tokenUsageChanged,
                 settingsModel,
                 initialTokenUsage: model.agentManager.tokenUsage,
                 translator: trans
             });
-            section.toolbar.insertBefore('markRead', 'token-usage', tokenUsageWidget);
-            model.writersChanged?.connect((_, writers) => {
+            chatPanel.current?.toolbar.insertBefore('markRead', 'token-usage', tokenUsageWidget);
+            // Listen for writers change to display the stop button.
+            function writersChanged(_, writers) {
                 // Check if AI is currently writing (streaming)
                 const aiWriting = writers.some(writer => writer.user.username === 'ai-assistant');
                 if (aiWriting) {
@@ -268,23 +302,28 @@ const plugin = {
                     widget.inputToolbarRegistry?.hide('stop');
                     widget.inputToolbarRegistry?.show('send');
                 }
-            });
+            }
+            model.writersChanged?.connect(writersChanged);
             // Associate an approval buttons object to the chat.
             const approvalButton = new ApprovalButtons({
                 chatPanel: widget,
                 agentManager: model.agentManager
             });
+            // Temporary compat: keep output-area CSS context for MIME renderers
+            // until jupyter-chat provides it natively.
+            const outputAreaCompat = new RenderedMessageOutputAreaCompat({
+                chatPanel: widget
+            });
             widget.disposed.connect(() => {
+                model.nameChanged.disconnect(saveTracker);
+                model.agentManager.activeProviderChanged.disconnect(saveTracker);
+                model.writersChanged?.disconnect(writersChanged);
                 // Dispose of the approval buttons widget when the chat is disposed.
                 approvalButton.dispose();
-                // Remove the model from the registry when the widget is disposed.
-                modelRegistry.remove(model.name);
+                outputAreaCompat.dispose();
             });
         });
         app.shell.add(chatPanel, 'left', { rank: 1000 });
-        // Creating the tracker for the document
-        const namespace = 'ai-chat';
-        const tracker = new WidgetTracker({ namespace });
         if (restorer) {
             restorer.add(chatPanel, chatPanel.id);
             void restorer.restore(tracker, {
@@ -302,12 +341,12 @@ const plugin = {
         }
         // Create a chat with default provider at startup.
         app.restored.then(() => {
-            if (!modelRegistry.getAll().length &&
-                settingsModel.config.defaultProvider) {
+            if (!tracker.size && settingsModel.config.defaultProvider) {
                 app.commands.execute(CommandIds.openChat);
             }
         });
-        registerCommands(app, rmRegistry, chatPanel, attachmentOpenerRegistry, inputToolbarFactory, settingsModel, chatCommandRegistry, tracker, modelRegistry, trans, themeManager, labShell);
+        registerCommands(app, rmRegistry, chatPanel, attachmentOpenerRegistry, inputToolbarFactory, settingsModel, chatCommandRegistry, tracker, modelHandler, trans, themeManager, labShell);
+        return tracker;
     }
 };
 function registerCommands(app, rmRegistry, chatPanel, attachmentOpenerRegistry, inputToolbarFactory, settingsModel, chatCommandRegistry, tracker, modelRegistry, trans, themeManager, labShell) {
@@ -373,13 +412,16 @@ function registerCommands(app, rmRegistry, chatPanel, attachmentOpenerRegistry,
             app.shell.add(widget, 'main');
             // Add the widget to the tracker.
             tracker.add(widget);
+            function saveTracker() {
+                tracker.save(widget);
+            }
             // Update the tracker if the model name changed.
-            model.nameChanged.connect(() => tracker.save(widget));
+            model.nameChanged.connect(saveTracker);
             // Update the tracker if the active provider changed.
-            model.agentManager.activeProviderChanged.connect(() => tracker.save(widget));
-            // Remove the model from the registry when the widget is disposed.
+            model.agentManager.activeProviderChanged.connect(saveTracker);
             widget.disposed.connect(() => {
-                modelRegistry.remove(model.name);
+                model.nameChanged.disconnect(saveTracker);
+                model.agentManager.activeProviderChanged.disconnect(saveTracker);
             });
         };
         commands.addCommand(CommandIds.openChat, {
@@ -387,11 +429,23 @@ function registerCommands(app, rmRegistry, chatPanel, attachmentOpenerRegistry,
             execute: async (args) => {
                 const area = args.area === 'main' ? 'main' : 'side';
                 const provider = args.provider ?? undefined;
-                // Do not open the chat if the provider in args does not exists in settings.
-                if (provider && !settingsModel.getProvider(provider)) {
+                let name = args.name ?? undefined;
+                let providerConfig = undefined;
+                if (provider) {
+                    providerConfig = settingsModel.getProvider(provider);
+                }
+                else {
+                    providerConfig = settingsModel.getDefaultProvider();
+                }
+                // Do not open the chat if the provider in args does not exists in settings or
+                // if there is no default provider.
+                if (!providerConfig) {
                     return false;
                 }
-                const model = modelRegistry.createModel(args.name ? args.name : undefined, provider);
+                if (!name) {
+                    name = providerConfig.name;
+                }
+                const model = modelRegistry.createModel(name, provider);
                 if (!model) {
                     return false;
                 }
@@ -399,7 +453,7 @@ function registerCommands(app, rmRegistry, chatPanel, attachmentOpenerRegistry,
                     openInMain(model);
                 }
                 else {
-                    chatPanel.addChat({ model });
+                    chatPanel.open({ model });
                 }
                 return true;
             },
@@ -436,7 +490,14 @@ function registerCommands(app, rmRegistry, chatPanel, attachmentOpenerRegistry,
                     console.error('Error while moving the chat to main area: the name has not been provided');
                     return false;
                 }
-                const previousModel = modelRegistry.get(args.name);
+                let previousWidget;
+                let previousModel;
+                tracker.forEach(widget => {
+                    if (widget.model.name === args.name) {
+                        previousWidget = widget;
+                        previousModel = widget.model;
+                    }
+                });
                 if (!previousModel) {
                     console.error('Error while moving the chat to main area: there is no reference model');
                     return false;
@@ -455,8 +516,10 @@ function registerCommands(app, rmRegistry, chatPanel, attachmentOpenerRegistry,
                 // 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(args.name, previousModel?.agentManager.activeProvider, previousModel?.agentManager.tokenUsage);
-                previousModel?.messages.forEach(message => model?.messageAdded(message));
+                const model = modelRegistry.createModel(args.name, previousModel.agentManager.activeProvider, previousModel.agentManager.tokenUsage);
+                previousModel?.messages.forEach(message => {
+                    model?.messageAdded({ ...message.content });
+                });
                 // Wait (with timeout) for the tracker to have updated the previous widget.
                 const status = await Promise.any([
                     trackerUpdated.promise,
@@ -472,13 +535,9 @@ function registerCommands(app, rmRegistry, chatPanel, attachmentOpenerRegistry,
                     openInMain(model);
                 }
                 else {
-                    const current = app.shell.currentWidget;
-                    // Remove the current main area chat.
-                    if (current instanceof MainAreaChat &&
-                        current.model.name === previousModel.name) {
-                        current.dispose();
-                    }
-                    chatPanel.addChat({ model });
+                    previousWidget?.dispose();
+                    previousModel.dispose();
+                    chatPanel.open({ model });
                 }
                 return true;
             },
@@ -489,7 +548,7 @@ function registerCommands(app, rmRegistry, chatPanel, attachmentOpenerRegistry,
                         area: {
                             type: 'string',
                             enum: ['main', 'side'],
-                            description: trans.__('The name of the area to move the chat to')
+                            description: trans.__('The area to move the chat to')
                         },
                         name: {
                             type: 'string',
@@ -503,7 +562,9 @@ function registerCommands(app, rmRegistry, chatPanel, attachmentOpenerRegistry,
     }
 }
 /**
- * A plugin to provide the settings model.
+ * A plugin to provide the agent manager factory, the completion provider and
+ * the settings model.
+ * All these objects require the secrets manager token with the same namespace.
  */
 const agentManagerFactory = SecretsManager.sign(SECRETS_NAMESPACE, token => ({
     id: SECRETS_NAMESPACE,
@@ -643,6 +704,7 @@ const toolRegistry = {
         const executeCommandTool = createExecuteCommandTool(app.commands, settingsModel);
         toolRegistry.add('discover_commands', discoverCommandsTool);
         toolRegistry.add('execute_command', executeCommandTool);
+        toolRegistry.add('browser_fetch', createBrowserFetchTool());
         if (skillRegistry) {
             toolRegistry.add('discover_skills', createDiscoverSkillsTool(skillRegistry));
             toolRegistry.add('load_skill', createLoadSkillTool(skillRegistry));
@@ -658,13 +720,13 @@ const inputToolbarFactory = {
     description: 'The input toolbar registry plugin.',
     autoStart: true,
     provides: IInputToolbarRegistryFactory,
-    requires: [IAISettingsModel, IToolRegistry],
+    requires: [IAISettingsModel, IToolRegistry, IProviderRegistry],
     optional: [ITranslator],
-    activate: (app, settingsModel, toolRegistry, translator) => {
+    activate: (app, settingsModel, toolRegistry, providerRegistry, translator) => {
         const trans = (translator ?? nullTranslator).load('jupyterlite_ai');
         const stopButton = stopItem(trans);
         const clearButton = clearItem(trans);
-        const toolSelectButton = createToolSelectItem(toolRegistry, settingsModel.config.toolsEnabled, trans);
+        const toolSelectButton = createToolSelectItem(toolRegistry, settingsModel, providerRegistry, settingsModel.config.toolsEnabled, trans);
         const modelSelectButton = createModelSelectItem(settingsModel, trans);
         return {
             create() {
@@ -828,7 +890,7 @@ export default [
     clearCommandPlugin,
     skillRegistryPlugin,
     skillsCommandPlugin,
-    chatModelRegistry,
+    chatModelHandler,
     plugin,
     toolRegistry,
     agentManagerFactory,

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

@@ -41,6 +41,8 @@ export interface IAIConfig {
     sendWithShiftEnter: boolean;
     showTokenUsage: boolean;
     commandsRequiringApproval: string[];
+    commandsAutoRenderMimeBundles: string[];
+    trustedMimeTypesForAutoRender: string[];
     showCellDiff: boolean;
     showFileDiff: boolean;
     diffDisplayMode: 'split' | 'unified';

package/lib/models/settings-model.js

@@ -33,6 +33,8 @@ export class AISettingsModel extends VDomModel {
             'runmenu:run-all',
             'jupyterlab-ai-commands:run-cell'
         ],
+        commandsAutoRenderMimeBundles: ['jupyterlab-ai-commands:execute-in-kernel'],
+        trustedMimeTypesForAutoRender: ['text/html'],
         systemPrompt: `You are Jupyternaut, an AI coding assistant built specifically for the JupyterLab environment.
 
 ## Your Core Mission

package/lib/providers/built-in-providers.js

@@ -32,6 +32,10 @@ export const anthropicProvider = {
     ],
     supportsBaseURL: true,
     supportsHeaders: true,
+    providerToolCapabilities: {
+        webSearch: { implementation: 'anthropic' },
+        webFetch: { implementation: 'anthropic' }
+    },
     factory: (options) => {
         if (!options.apiKey) {
             throw new Error('API key required for Anthropic');
@@ -198,6 +202,9 @@ export const openaiProvider = {
     ],
     supportsBaseURL: true,
     supportsHeaders: true,
+    providerToolCapabilities: {
+        webSearch: { implementation: 'openai' }
+    },
     factory: (options) => {
         if (!options.apiKey) {
             throw new Error('API key required for OpenAI');

package/lib/providers/provider-tools.d.ts

@@ -0,0 +1,36 @@
+import type { Tool } from 'ai';
+import type { IProviderInfo } from '../tokens';
+type ToolMap = Record<string, Tool>;
+interface IWebSearchSettings {
+    enabled?: boolean;
+    externalWebAccess?: boolean;
+    searchContextSize?: 'low' | 'medium' | 'high';
+    allowedDomains?: string[];
+    blockedDomains?: string[];
+    maxUses?: number;
+}
+interface IWebFetchSettings {
+    enabled?: boolean;
+    maxUses?: number;
+    maxContentTokens?: number;
+    allowedDomains?: string[];
+    blockedDomains?: string[];
+    citationsEnabled?: boolean;
+}
+/**
+ * Provider-level custom settings that control built-in web tools.
+ */
+export interface IProviderCustomSettings {
+    webSearch?: IWebSearchSettings;
+    webFetch?: IWebFetchSettings;
+}
+interface IProviderToolContext {
+    providerInfo?: IProviderInfo | null;
+    customSettings?: IProviderCustomSettings;
+    hasFunctionTools: boolean;
+}
+/**
+ * Create provider-defined tools from custom settings and provider capabilities.
+ */
+export declare function createProviderTools(options: IProviderToolContext): ToolMap;
+export {};

package/lib/providers/provider-tools.js

@@ -0,0 +1,93 @@
+import { anthropic } from '@ai-sdk/anthropic';
+import { openai } from '@ai-sdk/openai';
+const DEFAULT_ANTHROPIC_WEB_FETCH_MAX_USES = 2;
+const DEFAULT_ANTHROPIC_WEB_FETCH_MAX_CONTENT_TOKENS = 12000;
+function normalizeDomain(value) {
+    const normalized = (value || '').trim().toLowerCase();
+    const withoutProtocol = normalized.replace(/^https?:\/\//, '');
+    const hostname = withoutProtocol.split('/')[0].trim();
+    // Treat "*.example.com" as "example.com" for provider domain filters.
+    return hostname.startsWith('*.') ? hostname.slice(2) : hostname;
+}
+function collectDomains(value) {
+    value = value || [];
+    const values = Array.from(new Set(value.map(normalizeDomain).filter(domain => domain.length > 0)));
+    return values;
+}
+function createOpenAIWebSearchTool(webSearchSettings) {
+    const allowedDomains = collectDomains(webSearchSettings.allowedDomains);
+    return openai.tools.webSearch({
+        externalWebAccess: webSearchSettings.externalWebAccess,
+        searchContextSize: webSearchSettings.searchContextSize,
+        filters: allowedDomains.length > 0 ? { allowedDomains } : undefined
+    });
+}
+function createAnthropicWebSearchTool(webSearchSettings) {
+    const allowedDomains = collectDomains(webSearchSettings.allowedDomains);
+    const blockedDomains = collectDomains(webSearchSettings.blockedDomains);
+    return anthropic.tools.webSearch_20250305({
+        maxUses: webSearchSettings.maxUses,
+        allowedDomains: allowedDomains.length > 0 ? allowedDomains : undefined,
+        blockedDomains: blockedDomains.length > 0 ? blockedDomains : undefined
+    });
+}
+function createAnthropicWebFetchTool(webFetchSettings) {
+    const maxUses = webFetchSettings.maxUses ?? DEFAULT_ANTHROPIC_WEB_FETCH_MAX_USES;
+    const maxContentTokens = webFetchSettings.maxContentTokens ??
+        DEFAULT_ANTHROPIC_WEB_FETCH_MAX_CONTENT_TOKENS;
+    const allowedDomains = collectDomains(webFetchSettings.allowedDomains);
+    const blockedDomains = collectDomains(webFetchSettings.blockedDomains);
+    const citationsEnabled = webFetchSettings.citationsEnabled;
+    return anthropic.tools.webFetch_20250910({
+        maxUses,
+        maxContentTokens,
+        allowedDomains: allowedDomains.length > 0 ? allowedDomains : undefined,
+        blockedDomains: blockedDomains.length > 0 ? blockedDomains : undefined,
+        citations: citationsEnabled !== undefined ? { enabled: citationsEnabled } : undefined
+    });
+}
+function createWebSearchTool(implementation, webSearchSettings) {
+    switch (implementation) {
+        case 'openai':
+            return createOpenAIWebSearchTool(webSearchSettings);
+        case 'anthropic':
+            return createAnthropicWebSearchTool(webSearchSettings);
+        default:
+            throw new Error(`Unsupported web search implementation: ${implementation}`);
+    }
+}
+function createWebFetchTool(implementation, webFetchSettings) {
+    switch (implementation) {
+        case 'anthropic':
+            return createAnthropicWebFetchTool(webFetchSettings);
+        default:
+            throw new Error(`Unsupported web fetch implementation: ${implementation}`);
+    }
+}
+/**
+ * Create provider-defined tools from custom settings and provider capabilities.
+ */
+export function createProviderTools(options) {
+    const tools = {};
+    if (!options.customSettings ||
+        !options.providerInfo?.providerToolCapabilities) {
+        return tools;
+    }
+    const capabilities = options.providerInfo.providerToolCapabilities;
+    const webSearchSettings = options.customSettings.webSearch;
+    const webFetchSettings = options.customSettings.webFetch;
+    const webSearchEnabled = webSearchSettings?.enabled === true;
+    const webFetchEnabled = webFetchSettings?.enabled === true;
+    const webSearchCapability = capabilities.webSearch;
+    if (webSearchEnabled && webSearchSettings && webSearchCapability) {
+        const requiresNoFunctionTools = webSearchCapability.requiresNoFunctionTools === true;
+        if (!requiresNoFunctionTools || !options.hasFunctionTools) {
+            tools.web_search = createWebSearchTool(webSearchCapability.implementation, webSearchSettings);
+        }
+    }
+    const webFetchCapability = capabilities.webFetch;
+    if (webFetchEnabled && webFetchSettings && webFetchCapability) {
+        tools.web_fetch = createWebFetchTool(webFetchCapability.implementation, webFetchSettings);
+    }
+    return tools;
+}

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

@@ -0,0 +1,24 @@
+import { ChatWidget } from '@jupyter/chat';
+import { IDisposable } from '@lumino/disposable';
+/**
+ * Ensures chat-rendered MIME outputs also expose the OutputArea class so
+ * renderer extensions can reuse their notebook/output-area CSS rules.
+ *
+ * TODO: Remove this compatibility layer once jupyter-chat applies
+ * `jp-OutputArea` (or equivalent output-area context) to rendered MIME
+ * messages by default.
+ */
+export declare class RenderedMessageOutputAreaCompat implements IDisposable {
+    constructor(options: RenderedMessageOutputAreaCompat.IOptions);
+    get isDisposed(): boolean;
+    dispose(): void;
+    private _scheduleSync;
+    private readonly _chatPanel;
+    private _isDisposed;
+    private _raf;
+}
+export declare namespace RenderedMessageOutputAreaCompat {
+    interface IOptions {
+        chatPanel: ChatWidget;
+    }
+}

package/lib/rendered-message-outputarea.js

@@ -0,0 +1,48 @@
+const OUTPUT_AREA_CLASS = 'jp-OutputArea';
+const CHAT_RENDERED_MESSAGE_SELECTOR = `.jp-chat-rendered-message:not(.${OUTPUT_AREA_CLASS})`;
+/**
+ * Ensures chat-rendered MIME outputs also expose the OutputArea class so
+ * renderer extensions can reuse their notebook/output-area CSS rules.
+ *
+ * TODO: Remove this compatibility layer once jupyter-chat applies
+ * `jp-OutputArea` (or equivalent output-area context) to rendered MIME
+ * messages by default.
+ */
+export class RenderedMessageOutputAreaCompat {
+    constructor(options) {
+        this._chatPanel = options.chatPanel;
+        this._chatPanel.model.messagesUpdated.connect(this._scheduleSync, this);
+        this._scheduleSync();
+    }
+    get isDisposed() {
+        return this._isDisposed;
+    }
+    dispose() {
+        if (this._isDisposed) {
+            return;
+        }
+        this._isDisposed = true;
+        this._chatPanel.model.messagesUpdated.disconnect(this._scheduleSync, this);
+        if (this._raf !== 0) {
+            cancelAnimationFrame(this._raf);
+            this._raf = 0;
+        }
+    }
+    _scheduleSync() {
+        if (this._isDisposed || this._raf !== 0) {
+            return;
+        }
+        this._raf = requestAnimationFrame(() => {
+            this._raf = 0;
+            if (this._isDisposed) {
+                return;
+            }
+            this._chatPanel.node
+                .querySelectorAll(CHAT_RENDERED_MESSAGE_SELECTOR)
+                .forEach(element => element.classList.add(OUTPUT_AREA_CLASS));
+        });
+    }
+    _chatPanel;
+    _isDisposed = false;
+    _raf = 0;
+}