@jupyterlite/ai 0.15.0 → 0.17.0

package/lib/components/usage-display.js

@@ -0,0 +1,109 @@
+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.
+ * Only renders when token or context usage display is enabled in settings.
+ */
+export const UsageDisplay = ({ tokenUsageChanged, settingsModel, initialTokenUsage, translator: trans }) => {
+    const formatContextPercent = (value) => {
+        return Math.round(value).toLocaleString();
+    };
+    const badgeStyle = {
+        display: 'flex',
+        alignItems: 'center',
+        gap: '6px',
+        fontSize: '12px',
+        color: 'var(--jp-ui-font-color2)',
+        padding: '4px 8px',
+        backgroundColor: 'var(--jp-layout-color1)',
+        border: '1px solid var(--jp-border-color1)',
+        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 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: {
+                            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))))));
+        }));
+    }));
+};
+/**
+ * JupyterLab widget wrapper for the UsageDisplay component.
+ * Extends ReactWidget to integrate with the JupyterLab widget system.
+ */
+export class UsageWidget extends ReactWidget {
+    /**
+     * Creates a new UsageWidget instance.
+     * @param options - Configuration options containing required models
+     */
+    constructor(options) {
+        super();
+        this._options = options;
+    }
+    /**
+     * Renders the React component within the widget.
+     * @returns The UsageDisplay React element
+     */
+    render() {
+        return React.createElement(UsageDisplay, { ...this._options });
+    }
+    _options;
+}

package/lib/index.js

@@ -25,7 +25,7 @@ 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 { AICompletionProvider } from './completion';
-import { clearItem, createModelSelectItem, createToolSelectItem, stopItem, CompletionStatusWidget, TokenUsageWidget } from './components';
+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';
@@ -213,6 +213,22 @@ const chatModelHandler = {
         });
     }
 };
+/**
+ * The active cell manager plugin, to allow copying code from chat to notebook.
+ */
+const activeCellManager = {
+    id: '@jupyterlite/ai:activeCellManager',
+    description: 'Add the active cell manager to the model handler',
+    autoStart: true,
+    requires: [IChatModelHandler, INotebookTracker],
+    activate: (app, modelHandler, notebookTracker) => {
+        const activeCellManager = new ActiveCellManager({
+            tracker: notebookTracker,
+            shell: app.shell
+        });
+        modelHandler.activeCellManager = activeCellManager;
+    }
+};
 /**
  * Initialization data for the extension.
  */
@@ -232,13 +248,12 @@ const plugin = {
         IThemeManager,
         ILayoutRestorer,
         ILabShell,
-        INotebookTracker,
         ITranslator,
         IComponentsRendererFactory,
         ICommandPalette,
         IDocumentManager
     ],
-    activate: (app, rmRegistry, inputToolbarFactory, modelHandler, settingsModel, chatCommandRegistry, themeManager, restorer, labShell, notebookTracker, translator, chatComponentsFactory, palette, documentManager) => {
+    activate: (app, rmRegistry, inputToolbarFactory, modelHandler, settingsModel, chatCommandRegistry, themeManager, restorer, labShell, translator, chatComponentsFactory, palette, documentManager) => {
         const trans = (translator ?? nullTranslator).load('jupyterlite_ai');
         // Create attachment opener registry to handle file attachments
         const attachmentOpenerRegistry = new AttachmentOpenerRegistry();
@@ -253,16 +268,6 @@ const plugin = {
                 void app.commands.execute(CommandIds.openSettings);
             }
         };
-        // Create ActiveCellManager if notebook tracker is available, and add it to the
-        // model registry.
-        let activeCellManager;
-        if (notebookTracker) {
-            activeCellManager = new ActiveCellManager({
-                tracker: notebookTracker,
-                shell: app.shell
-            });
-        }
-        modelHandler.activeCellManager = activeCellManager;
         // Creating the tracker for the chat widgets
         const namespace = 'ai-chat';
         const tracker = new WidgetTracker({ namespace });
@@ -338,7 +343,7 @@ const plugin = {
             app.commands.commandChanged.connect(onCommandChanged);
             chatPanel.disposed.connect(disconnectSettingsButtonListener);
         }
-        let tokenUsageWidget = null;
+        let usageWidget = null;
         chatPanel.chatOpened.connect((_, widget) => {
             const model = widget.model;
             // Add the widget to the tracker.
@@ -346,19 +351,29 @@ const plugin = {
             function saveTracker() {
                 tracker.save(widget);
             }
+            function updateToolbarTitleOverlay() {
+                const titleNode = chatPanel.current?.toolbar.node
+                    .getElementsByClassName('jp-chat-sidepanel-widget-title')
+                    .item(0);
+                if (titleNode) {
+                    titleNode.setAttribute('title', model.title ?? model.name);
+                }
+            }
+            model.titleChanged.connect(updateToolbarTitleOverlay);
+            updateToolbarTitleOverlay();
             // Update the tracker if the model name changed.
             model.nameChanged.connect(saveTracker);
             // Update the tracker if the active provider changed.
             model.agentManager.activeProviderChanged.connect(saveTracker);
             // Update the token usage widget.
-            tokenUsageWidget?.dispose();
-            tokenUsageWidget = new TokenUsageWidget({
+            usageWidget?.dispose();
+            usageWidget = new UsageWidget({
                 tokenUsageChanged: model.tokenUsageChanged,
                 settingsModel,
                 initialTokenUsage: model.agentManager.tokenUsage,
                 translator: trans
             });
-            chatPanel.current?.toolbar.insertBefore('markRead', 'token-usage', tokenUsageWidget);
+            chatPanel.current?.toolbar.insertBefore('markRead', 'usage', usageWidget);
             if (model.saveAvailable) {
                 const saveChatButton = new SaveComponentWidget({
                     model,
@@ -386,6 +401,7 @@ const plugin = {
                 chatPanel: widget
             });
             widget.disposed.connect(() => {
+                model.titleChanged.disconnect(updateToolbarTitleOverlay);
                 model.nameChanged.disconnect(saveTracker);
                 model.agentManager.activeProviderChanged.disconnect(saveTracker);
                 model.writersChanged?.disconnect(writersChanged);
@@ -514,6 +530,49 @@ function registerCommands(app, rmRegistry, chatPanel, attachmentOpenerRegistry,
                 model.nameChanged.disconnect(saveTracker);
                 model.agentManager.activeProviderChanged.disconnect(saveTracker);
             });
+            return widget;
+        };
+        const focusOnChat = (area, widget) => {
+            if (area === 'main' && widget) {
+                app.shell.activateById(widget.id);
+            }
+            else {
+                app.shell.activateById(chatPanel.id);
+            }
+        };
+        const applyInputArgs = (model, args) => {
+            const input = typeof args.input === 'string' ? args.input : undefined;
+            const autoSend = args.autoSend === true;
+            const shouldFocus = args.focus !== false;
+            if (input !== undefined) {
+                model.input.value = input;
+            }
+            if (autoSend && input !== undefined) {
+                model.input.send(model.input.value);
+            }
+            if (shouldFocus) {
+                model.input.focus();
+            }
+        };
+        const findChatWidget = (name, provider) => {
+            if (!name && !provider) {
+                return;
+            }
+            return tracker.find(widget => {
+                const model = widget.model;
+                return ((!name || widget.model.name === name) &&
+                    (!provider || model.agentManager.activeProvider === provider));
+            });
+        };
+        const disposeSideChatModel = (model) => {
+            const loadedName = chatPanel
+                .getLoadedModelNames()
+                .find(name => chatPanel.getLoadedModel(name) === model);
+            if (!loadedName) {
+                return false;
+            }
+            chatPanel.disposeLoadedModel(loadedName);
+            return true;
         };
         commands.addCommand(CommandIds.openChat, {
             label: trans.__('Open a chat'),
@@ -543,12 +602,18 @@ function registerCommands(app, rmRegistry, chatPanel, attachmentOpenerRegistry,
                 if (!model) {
                     return false;
                 }
+                const shouldFocus = args.focus === true;
+                let widget;
                 if (area === 'main') {
-                    openInMain(model);
+                    widget = openInMain(model);
                 }
                 else {
-                    chatPanel.open({ model });
+                    widget = chatPanel.open({ model });
+                }
+                if (shouldFocus) {
+                    focusOnChat(area, widget);
                 }
+                applyInputArgs(model, { ...args, focus: shouldFocus });
                 return true;
             },
             describedBy: {
@@ -567,6 +632,116 @@ function registerCommands(app, rmRegistry, chatPanel, attachmentOpenerRegistry,
                         provider: {
                             type: 'string',
                             description: trans.__('The provider/model to use with this chat')
+                        },
+                        input: {
+                            type: 'string',
+                            description: trans.__('The input text to prefill in the chat')
+                        },
+                        focus: {
+                            type: 'boolean',
+                            description: trans.__('Whether to focus the chat input after opening it')
+                        },
+                        autoSend: {
+                            type: 'boolean',
+                            description: trans.__('Whether to auto-send the provided input after opening the chat')
+                        }
+                    }
+                }
+            }
+        });
+        commands.addCommand(CommandIds.openOrRevealChat, {
+            label: trans.__('Open or reveal the chat panel'),
+            execute: async (args) => {
+                const area = args.area === 'main' ? 'main' : 'side';
+                const provider = args.provider ?? undefined;
+                const name = args.name ?? undefined;
+                const shouldFocus = args.focus === true;
+                let existingWidget = findChatWidget(name, provider);
+                if (!existingWidget && !name) {
+                    const providerConfig = provider
+                        ? settingsModel.getProvider(provider)
+                        : settingsModel.getDefaultProvider();
+                    existingWidget = findChatWidget(undefined, providerConfig?.id);
+                }
+                // If the side chat model is loaded but not currently displayed, reveal it first.
+                if (!existingWidget && name) {
+                    const loadedModel = chatPanel.getLoadedModel(name);
+                    if (loadedModel) {
+                        existingWidget = chatPanel.open({ model: loadedModel });
+                    }
+                }
+                if (!existingWidget) {
+                    return commands.execute(CommandIds.openChat, {
+                        ...args,
+                        focus: shouldFocus
+                    });
+                }
+                const currentArea = existingWidget instanceof MainAreaChat ? 'main' : 'side';
+                if (currentArea !== area) {
+                    const targetName = existingWidget.model.name;
+                    const moved = (await commands.execute(CommandIds.moveChat, {
+                        name: targetName,
+                        area
+                    }));
+                    if (!moved) {
+                        return false;
+                    }
+                    const movedWidget = findChatWidget(targetName);
+                    if (!movedWidget) {
+                        return false;
+                    }
+                    if (area === 'side') {
+                        chatPanel.open({ model: movedWidget.model });
+                    }
+                    if (shouldFocus) {
+                        focusOnChat(area, movedWidget);
+                    }
+                    applyInputArgs(movedWidget.model, {
+                        ...args,
+                        focus: shouldFocus
+                    });
+                    return true;
+                }
+                if (area === 'side') {
+                    chatPanel.open({ model: existingWidget.model });
+                }
+                if (shouldFocus) {
+                    focusOnChat(area, existingWidget);
+                }
+                applyInputArgs(existingWidget.model, {
+                    ...args,
+                    focus: shouldFocus
+                });
+                return true;
+            },
+            describedBy: {
+                args: {
+                    type: 'object',
+                    properties: {
+                        area: {
+                            type: 'string',
+                            enum: ['main', 'side'],
+                            description: trans.__('The name of the area to open or reveal the chat in')
+                        },
+                        name: {
+                            type: 'string',
+                            description: trans.__('The name of the chat')
+                        },
+                        provider: {
+                            type: 'string',
+                            description: trans.__('The provider/model to use with this chat')
+                        },
+                        input: {
+                            type: 'string',
+                            description: trans.__('The input text to prefill in the chat')
+                        },
+                        focus: {
+                            type: 'boolean',
+                            description: trans.__('Whether to focus the chat input after opening it')
+                        },
+                        autoSend: {
+                            type: 'boolean',
+                            description: trans.__('Whether to auto-send the provided input after opening the chat')
                         }
                     }
                 }
@@ -615,7 +790,8 @@ function registerCommands(app, rmRegistry, chatPanel, attachmentOpenerRegistry,
                     activeProvider: previousModel.agentManager.activeProvider,
                     tokenUsage: previousModel.agentManager.tokenUsage,
                     messages: previousModel.messages,
-                    autosave: previousModel.autosave
+                    autosave: previousModel.autosave,
+                    title: previousModel.title
                 });
                 // Wait (with timeout) for the tracker to have updated the previous widget.
                 const status = await Promise.any([
@@ -630,6 +806,14 @@ function registerCommands(app, rmRegistry, chatPanel, attachmentOpenerRegistry,
                 }
                 if (area === 'main') {
                     openInMain(model);
+                    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();
+                        }
+                    }
                 }
                 else {
                     previousWidget?.dispose();
@@ -1118,6 +1302,7 @@ export default [
     skillRegistryPlugin,
     skillsCommandPlugin,
     chatModelHandler,
+    activeCellManager,
     plugin,
     toolRegistry,
     agentManagerFactory,

package/lib/models/settings-model.js

@@ -13,6 +13,7 @@ export class AISettingsModel extends VDomModel {
         toolsEnabled: true,
         sendWithShiftEnter: false,
         showTokenUsage: false,
+        showContextUsage: false,
         showCellDiff: true,
         showFileDiff: true,
         diffDisplayMode: 'split',

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

@@ -3,6 +3,7 @@ import { createGoogleGenerativeAI } from '@ai-sdk/google';
 import { createMistral } from '@ai-sdk/mistral';
 import { createOpenAI } from '@ai-sdk/openai';
 import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
+import { BUILT_IN_PROVIDER_MODEL_INFO } from './generated-context-windows';
 /**
  * Anthropic provider
  */
@@ -26,6 +27,7 @@ export const anthropicProvider = {
         'claude-sonnet-4-0',
         'claude-sonnet-4-20250514'
     ],
+    modelInfo: BUILT_IN_PROVIDER_MODEL_INFO.anthropic,
     supportsBaseURL: true,
     supportsHeaders: true,
     providerToolCapabilities: {
@@ -72,6 +74,7 @@ export const googleProvider = {
         'gemini-flash-latest',
         'gemini-flash-lite-latest'
     ],
+    modelInfo: BUILT_IN_PROVIDER_MODEL_INFO.google,
     supportsBaseURL: true,
     factory: (options) => {
         if (!options.apiKey) {
@@ -107,6 +110,7 @@ export const mistralProvider = {
         'codestral-latest',
         'devstral-latest'
     ],
+    modelInfo: BUILT_IN_PROVIDER_MODEL_INFO.mistral,
     supportsBaseURL: true,
     factory: (options) => {
         if (!options.apiKey) {
@@ -175,6 +179,7 @@ export const openaiProvider = {
         'gpt-3.5-turbo',
         'gpt-3.5-turbo-0125'
     ],
+    modelInfo: BUILT_IN_PROVIDER_MODEL_INFO.openai,
     supportsBaseURL: true,
     supportsHeaders: true,
     providerToolCapabilities: {

package/lib/providers/generated-context-windows.d.ts

@@ -0,0 +1,8 @@
+/**
+ * This file is generated by `jlpm sync:model-context-windows`.
+ * Source: https://models.dev/api.json
+ * Backed by: https://github.com/anomalyco/models.dev
+ * Generated: 2026-04-08T16:23:34.080Z
+ */
+import type { IProviderModelInfo } from '../tokens';
+export declare const BUILT_IN_PROVIDER_MODEL_INFO: Record<string, Record<string, IProviderModelInfo>>;

package/lib/providers/generated-context-windows.js

@@ -0,0 +1,96 @@
+/**
+ * This file is generated by `jlpm sync:model-context-windows`.
+ * Source: https://models.dev/api.json
+ * Backed by: https://github.com/anomalyco/models.dev
+ * Generated: 2026-04-08T16:23:34.080Z
+ */
+export const BUILT_IN_PROVIDER_MODEL_INFO = {
+    anthropic: {
+        'claude-opus-4-6': { contextWindow: 1000000 },
+        'claude-sonnet-4-6': { contextWindow: 1000000 },
+        'claude-opus-4-5': { contextWindow: 200000 },
+        'claude-opus-4-5-20251101': { contextWindow: 200000 },
+        'claude-sonnet-4-5': { contextWindow: 200000 },
+        'claude-sonnet-4-5-20250929': { contextWindow: 200000 },
+        'claude-haiku-4-5': { contextWindow: 200000 },
+        'claude-haiku-4-5-20251001': { contextWindow: 200000 },
+        'claude-opus-4-1': { contextWindow: 200000 },
+        'claude-opus-4-1-20250805': { contextWindow: 200000 },
+        'claude-opus-4-0': { contextWindow: 200000 },
+        'claude-opus-4-20250514': { contextWindow: 200000 },
+        'claude-sonnet-4-0': { contextWindow: 200000 },
+        'claude-sonnet-4-20250514': { contextWindow: 200000 }
+    },
+    google: {
+        'gemini-3.1-pro-preview': { contextWindow: 1048576 },
+        'gemini-3.1-pro-preview-customtools': { contextWindow: 1048576 },
+        'gemini-3.1-flash-image-preview': { contextWindow: 131072 },
+        'gemini-3.1-flash-lite-preview': { contextWindow: 1048576 },
+        'gemini-3-flash-preview': { contextWindow: 1048576 },
+        'gemini-2.5-pro': { contextWindow: 1048576 },
+        'gemini-2.5-flash': { contextWindow: 1048576 },
+        'gemini-2.5-flash-image': { contextWindow: 32768 },
+        'gemini-2.5-flash-lite': { contextWindow: 1048576 },
+        'gemini-flash-latest': { contextWindow: 1048576 },
+        'gemini-flash-lite-latest': { contextWindow: 1048576 }
+    },
+    mistral: {
+        'mistral-large-latest': { contextWindow: 262144 },
+        'mistral-medium-latest': { contextWindow: 128000 },
+        'mistral-medium-2508': { contextWindow: 262144 },
+        'mistral-small-latest': { contextWindow: 256000 },
+        'mistral-small-2506': { contextWindow: 128000 },
+        'ministral-3b-latest': { contextWindow: 128000 },
+        'ministral-8b-latest': { contextWindow: 128000 },
+        'magistral-small-latest': { contextWindow: 128000 },
+        'magistral-medium-latest': { contextWindow: 128000 },
+        'pixtral-large-latest': { contextWindow: 128000 },
+        'codestral-latest': { contextWindow: 256000 },
+        'devstral-latest': { contextWindow: 262144 },
+        'devstral-2512': { contextWindow: 262144 }
+    },
+    openai: {
+        'gpt-5.4': { contextWindow: 1050000 },
+        'gpt-5.4-mini': { contextWindow: 400000 },
+        'gpt-5.4-nano': { contextWindow: 400000 },
+        'gpt-5.2': { contextWindow: 400000 },
+        'gpt-5.2-2025-12-11': { contextWindow: 400000 },
+        'gpt-5.2-chat-latest': { contextWindow: 128000 },
+        'gpt-5.2-pro': { contextWindow: 400000 },
+        'gpt-5.2-pro-2025-12-11': { contextWindow: 400000 },
+        'gpt-5.2-codex': { contextWindow: 400000 },
+        'gpt-5.1': { contextWindow: 400000 },
+        'gpt-5.1-2025-11-13': { contextWindow: 400000 },
+        'gpt-5.1-chat-latest': { contextWindow: 128000 },
+        'gpt-5': { contextWindow: 400000 },
+        'gpt-5-2025-08-07': { contextWindow: 400000 },
+        'gpt-5-chat-latest': { contextWindow: 400000 },
+        'gpt-5-mini': { contextWindow: 400000 },
+        'gpt-5-mini-2025-08-07': { contextWindow: 400000 },
+        'gpt-5-nano': { contextWindow: 400000 },
+        'gpt-5-nano-2025-08-07': { contextWindow: 400000 },
+        'o4-mini': { contextWindow: 200000 },
+        'o4-mini-2025-04-16': { contextWindow: 200000 },
+        'o3-pro': { contextWindow: 200000 },
+        o3: { contextWindow: 200000 },
+        'o3-2025-04-16': { contextWindow: 200000 },
+        'o3-mini': { contextWindow: 200000 },
+        'o3-mini-2025-01-31': { contextWindow: 200000 },
+        o1: { contextWindow: 200000 },
+        'o1-2024-12-17': { contextWindow: 200000 },
+        'gpt-4.1': { contextWindow: 1047576 },
+        'gpt-4.1-2025-04-14': { contextWindow: 1047576 },
+        'gpt-4.1-mini': { contextWindow: 1047576 },
+        'gpt-4.1-mini-2025-04-14': { contextWindow: 1047576 },
+        'gpt-4.1-nano': { contextWindow: 1047576 },
+        'gpt-4.1-nano-2025-04-14': { contextWindow: 1047576 },
+        'gpt-4o': { contextWindow: 128000 },
+        'gpt-4o-2024-05-13': { contextWindow: 128000 },
+        'gpt-4o-2024-08-06': { contextWindow: 128000 },
+        'gpt-4o-2024-11-20': { contextWindow: 128000 },
+        'gpt-4o-mini': { contextWindow: 128000 },
+        'gpt-4o-mini-2024-07-18': { contextWindow: 128000 },
+        'gpt-3.5-turbo': { contextWindow: 16385 },
+        'gpt-3.5-turbo-0125': { contextWindow: 16385 }
+    }
+};

package/lib/providers/model-info.d.ts

@@ -0,0 +1,3 @@
+import type { IProviderConfig, IProviderInfo, IProviderModelInfo, IProviderRegistry } from '../tokens';
+export declare function getProviderModelInfo(providerInfo: IProviderInfo | null | undefined, model: string | undefined): IProviderModelInfo | undefined;
+export declare function getEffectiveContextWindow(providerConfig: IProviderConfig | undefined, providerRegistry?: IProviderRegistry): number | undefined;

package/lib/providers/model-info.js

@@ -0,0 +1,58 @@
+const DATE_SUFFIX = /^(.*)-\d{4}-\d{2}-\d{2}$/;
+const SHORT_VERSION_SUFFIX = /^(.*)-\d{4}$/;
+// Treat rolling aliases and dated releases as the same model family so they
+// can share provider metadata such as context windows.
+function normalizeModelId(modelId) {
+    if (modelId.endsWith('-latest')) {
+        return modelId.slice(0, -7);
+    }
+    const dateSuffixMatch = modelId.match(DATE_SUFFIX);
+    if (dateSuffixMatch) {
+        return dateSuffixMatch[1];
+    }
+    const shortVersionSuffixMatch = modelId.match(SHORT_VERSION_SUFFIX);
+    if (shortVersionSuffixMatch) {
+        return shortVersionSuffixMatch[1];
+    }
+    return modelId;
+}
+function getCandidateModelIds(modelId) {
+    const candidates = [modelId];
+    const normalizedModelId = normalizeModelId(modelId);
+    candidates.push(normalizedModelId);
+    if (normalizedModelId !== modelId) {
+        candidates.push(`${normalizedModelId}-latest`);
+    }
+    return [...new Set(candidates)];
+}
+export function getProviderModelInfo(providerInfo, model) {
+    if (!providerInfo || !model) {
+        return undefined;
+    }
+    const modelInfo = providerInfo.modelInfo;
+    if (!modelInfo) {
+        return undefined;
+    }
+    for (const candidateId of getCandidateModelIds(model)) {
+        if (modelInfo[candidateId]) {
+            return modelInfo[candidateId];
+        }
+    }
+    const normalizedModelId = normalizeModelId(model);
+    // As a last resort, match any known model entry that normalizes to the same
+    // base ID, even if the exact alias/version string differs.
+    return Object.entries(modelInfo).find(([candidateId]) => {
+        return normalizeModelId(candidateId) === normalizedModelId;
+    })?.[1];
+}
+export function getEffectiveContextWindow(providerConfig, providerRegistry) {
+    if (!providerConfig) {
+        return undefined;
+    }
+    if (providerConfig.parameters?.contextWindow !== undefined) {
+        return providerConfig.parameters.contextWindow;
+    }
+    const providerInfo = providerRegistry?.getProviderInfo(providerConfig.provider);
+    return getProviderModelInfo(providerInfo, providerConfig.model)
+        ?.contextWindow;
+}