@jupyterlite/ai 0.14.0 → 0.16.0

package/lib/tokens.d.ts

@@ -1,12 +1,12 @@
-import { ActiveCellManager } from '@jupyter/chat';
+import { ActiveCellManager, IMessage, IMessageContent } from '@jupyter/chat';
+import { VDomRenderer } from '@jupyterlab/apputils';
+import { IRenderMimeRegistry } from '@jupyterlab/rendermime';
 import { Token } from '@lumino/coreutils';
 import type { IDisposable } from '@lumino/disposable';
 import { ISignal } from '@lumino/signaling';
 import type { Tool, LanguageModel } from 'ai';
-import { AgentManager } from './agent';
-import type { AISettingsModel } from './models/settings-model';
+import { ISecretsManager } from 'jupyter-secrets-manager';
 import type { IModelOptions } from './providers/models';
-import { AgentManagerFactory } from './agent';
 import { AIChatModel } from './chat-model';
 import type { ISkillDefinition, ISkillRegistration, ISkillResourceResult, ISkillSummary } from './skills/types';
 export type { ISkillDefinition, ISkillRegistration, ISkillResourceResult, ISkillSummary } from './skills/types';
@@ -19,24 +19,17 @@ export declare namespace CommandIds {
     const openChat = "@jupyterlite/ai:open-chat";
     const moveChat = "@jupyterlite/ai:move-chat";
     const refreshSkills = "@jupyterlite/ai:refresh-skills";
+    const saveChat = "@jupyterlite/ai:save-chat";
+    const restoreChat = "@jupyterlite/ai:restore-chat";
 }
 /**
  * Type definition for a tool
  */
 export type ITool = Tool;
 /**
- * Interface for token usage statistics from AI model interactions
+ * A map containing tools.
  */
-export interface ITokenUsage {
-    /**
-     * Number of input tokens consumed (prompt tokens)
-     */
-    inputTokens: number;
-    /**
-     * Number of output tokens generated (completion tokens)
-     */
-    outputTokens: number;
-}
+export type ToolMap = Record<string, ITool>;
 /**
  * Interface for a named tool (tool with a name identifier)
  */
@@ -114,10 +107,6 @@ export interface ISkillRegistry {
  * The skill registry token.
  */
 export declare const ISkillRegistry: Token<ISkillRegistry>;
-/**
- * Token for the provider registry.
- */
-export declare const IProviderRegistry: Token<IProviderRegistry>;
 /**
  * Interface for a provider factory function that creates language models
  */
@@ -164,6 +153,12 @@ export interface IProviderToolCapabilities {
 /**
  * Provider information
  */
+export interface IProviderModelInfo {
+    /**
+     * Default context window for the model in tokens.
+     */
+    contextWindow?: number;
+}
 export interface IProviderInfo {
     /**
      * Unique identifier for the provider
@@ -184,6 +179,10 @@ export interface IProviderInfo {
      * Default model names for this provider
      */
     defaultModels: string[];
+    /**
+     * Optional per-model metadata keyed by model ID.
+     */
+    modelInfo?: Record<string, IProviderModelInfo>;
     /**
      * Whether this provider supports custom base URLs
      */
@@ -249,45 +248,323 @@ export interface IProviderRegistry {
      */
     getAvailableProviders(): string[];
 }
+/**
+ * Token for the provider registry.
+ */
+export declare const IProviderRegistry: Token<IProviderRegistry>;
+export interface IProviderParameters {
+    temperature?: number;
+    maxOutputTokens?: number;
+    maxTurns?: number;
+    contextWindow?: number;
+    supportsFillInMiddle?: boolean;
+    useFilterText?: boolean;
+}
+export interface IProviderConfig {
+    id: string;
+    name: string;
+    provider: string;
+    model: string;
+    apiKey?: string;
+    baseURL?: string;
+    headers?: Record<string, string>;
+    parameters?: IProviderParameters;
+    customSettings?: Record<string, any>;
+    [key: string]: any;
+}
+export interface IMCPServerConfig {
+    id: string;
+    name: string;
+    url: string;
+    enabled: boolean;
+    [key: string]: any;
+}
+export interface IAIConfig {
+    useSecretsManager: boolean;
+    providers: IProviderConfig[];
+    defaultProvider: string;
+    activeCompleterProvider?: string;
+    useSameProviderForChatAndCompleter: boolean;
+    mcpServers: IMCPServerConfig[];
+    contextAwareness: boolean;
+    codeExecution: boolean;
+    systemPrompt: string;
+    completionSystemPrompt: string;
+    toolsEnabled: boolean;
+    sendWithShiftEnter: boolean;
+    showTokenUsage: boolean;
+    showContextUsage: boolean;
+    commandsRequiringApproval: string[];
+    commandsAutoRenderMimeBundles: string[];
+    trustedMimeTypesForAutoRender: string[];
+    showCellDiff: boolean;
+    showFileDiff: boolean;
+    diffDisplayMode: 'split' | 'unified';
+    skillsPaths: string[];
+    chatBackupDirectory: string;
+}
+export interface IAISettingsModel extends VDomRenderer.IModel {
+    readonly config: IAIConfig;
+    updateConfig(updates: Partial<IAIConfig>): Promise<void>;
+    readonly providers: IProviderConfig[];
+    getProvider(id: string): IProviderConfig | undefined;
+    getDefaultProvider(): IProviderConfig | undefined;
+    getCompleterProvider(): IProviderConfig | undefined;
+    addProvider(providerConfig: Omit<IProviderConfig, 'id'>): Promise<string>;
+    removeProvider(id: string): Promise<void>;
+    updateProvider(id: string, updates: Partial<IProviderConfig>): Promise<void>;
+    setActiveProvider(id: string): Promise<void>;
+    setActiveCompleterProvider(id: string | undefined): Promise<void>;
+    readonly mcpServers: IMCPServerConfig[];
+    getMCPServer(id: string): IMCPServerConfig | undefined;
+    addMCPServer(serverConfig: Omit<IMCPServerConfig, 'id'>): Promise<string>;
+    removeMCPServer(id: string): Promise<void>;
+    updateMCPServer(id: string, updates: Partial<IMCPServerConfig>): Promise<void>;
+    /**
+     * Get the API key saved in the settings file for a given provider.
+     *
+     * @param id - the id of the provider.
+     */
+    getApiKey(id: string): string;
+}
 /**
  * Token for the AI settings model.
  */
-export declare const IAISettingsModel: Token<AISettingsModel>;
+export declare const IAISettingsModel: Token<IAISettingsModel>;
 /**
- * Internal interface for AI provider secret access within the shared namespace.
+ * A namespace for agent manager.
  */
-export interface IAISecretsAccess {
+export declare namespace IAgentManager {
+    /**
+     * Configuration options for the AgentManager
+     */
+    interface IOptions {
+        /**
+         * AI settings model for configuration
+         */
+        settingsModel: IAISettingsModel;
+        /**
+         * Optional tool registry for managing available tools
+         */
+        toolRegistry?: IToolRegistry;
+        /**
+         * Optional provider registry for model creation
+         */
+        providerRegistry?: IProviderRegistry;
+        /**
+         * The skill registry for discovering skills.
+         */
+        skillRegistry?: ISkillRegistry;
+        /**
+         * The secrets manager.
+         */
+        secretsManager?: ISecretsManager;
+        /**
+         * The active provider to use with this agent.
+         */
+        activeProvider?: string;
+        /**
+         * Initial token usage.
+         */
+        tokenUsage?: ITokenUsage;
+        /**
+         * JupyterLab render mime registry for discovering supported MIME types.
+         */
+        renderMimeRegistry?: IRenderMimeRegistry;
+    }
+    /**
+     * Event type mapping for type safety with inlined interface definitions
+     */
+    interface IAgentEventTypeMap {
+        message_start: {
+            messageId: string;
+        };
+        message_chunk: {
+            messageId: string;
+            chunk: string;
+            fullContent: string;
+        };
+        message_complete: {
+            messageId: string;
+            content: string;
+        };
+        tool_call_start: {
+            callId: string;
+            toolName: string;
+            input: string;
+        };
+        tool_call_complete: {
+            callId: string;
+            toolName: string;
+            outputData: unknown;
+            isError: boolean;
+        };
+        tool_approval_request: {
+            approvalId: string;
+            toolCallId: string;
+            toolName: string;
+            args: unknown;
+        };
+        tool_approval_resolved: {
+            approvalId: string;
+            approved: boolean;
+        };
+        error: {
+            error: Error;
+        };
+    }
+    /**
+     * Events emitted by the AgentManager
+     */
+    type IAgentEvent<T extends keyof IAgentEventTypeMap = keyof IAgentEventTypeMap> = T extends keyof IAgentEventTypeMap ? {
+        type: T;
+        data: IAgentEventTypeMap[T];
+    } : never;
+}
+export interface IAgentManager {
     /**
-     * Whether secrets access is currently available.
+     * The active provider for this agent.
      */
-    readonly isAvailable: boolean;
+    activeProvider: string;
     /**
-     * Get a secret value by ID.
+     * Signal emitted when agent events occur
      */
-    get(id: string): Promise<string | undefined>;
+    readonly agentEvent: ISignal<IAgentManager, IAgentManager.IAgentEvent>;
     /**
-     * Set a secret value by ID.
+     * Signal emitted when the active provider has changed.
      */
-    set(id: string, value: string): Promise<void>;
+    readonly activeProviderChanged: ISignal<IAgentManager, string | undefined>;
     /**
-     * Attach an input field to a secret ID.
+     * Gets the current token usage statistics.
      */
-    attach(id: string, input: HTMLInputElement, callback?: (value: string) => void): Promise<void>;
+    readonly tokenUsage: ITokenUsage;
+    /**
+     * Signal emitted when token usage statistics change.
+     */
+    readonly tokenUsageChanged: ISignal<IAgentManager, ITokenUsage>;
+    /**
+     * Refresh the skills snapshot and rebuild the agent if resources are ready.
+     */
+    refreshSkills(): void;
+    /**
+     * Sets the selected tools by name and reinitializes the agent.
+     * @param toolNames Array of tool names to select
+     */
+    setSelectedTools(toolNames: string[]): void;
+    /**
+     * Gets the currently selected tools as a record.
+     * @returns Record of selected tools
+     */
+    readonly selectedAgentTools: ToolMap;
+    /**
+     * Checks if the current configuration is valid for agent operations.
+     * Uses the provider registry to determine if an API key is required.
+     * @returns True if the configuration is valid, false otherwise
+     */
+    hasValidConfig(): boolean;
+    /**
+     * Clears conversation history and resets agent state.
+     */
+    clearHistory(): void;
+    /**
+     * Sets the conversation history with a list of messages from the chat.
+     * @param messages The chat messages to set as history
+     */
+    setHistory(messages: IMessageContent[]): void;
+    /**
+     * Stops the current streaming response by aborting the request.
+     */
+    stopStreaming(): void;
+    /**
+     * Approves a pending tool call.
+     * @param approvalId The approval ID to approve
+     * @param reason Optional reason for approval
+     */
+    approveToolCall(approvalId: string, reason?: string): void;
+    /**
+     * Rejects a pending tool call.
+     * @param approvalId The approval ID to reject
+     * @param reason Optional reason for rejection
+     */
+    rejectToolCall(approvalId: string, reason?: string): void;
+    /**
+     * Generates AI response to user message using the agent.
+     * Handles the complete execution cycle including tool calls.
+     * @param message The user message to respond to (may include processed attachment content)
+     */
+    generateResponse(message: string): Promise<void>;
+    /**
+     * Initializes the AI agent with current settings and tools.
+     * Sets up the agent with model configuration, tools, and MCP tools.
+     */
+    initializeAgent(mcpTools?: ToolMap): Promise<void>;
 }
 /**
  * Token for the agent manager.
  */
-export declare const IAgentManager: Token<AgentManager>;
+export declare const IAgentManager: Token<IAgentManager>;
 /**
- * The string that replaces a secret key in settings.
+ * The interface for a agent manager factory.
+ */
+export interface IAgentManagerFactory {
+    /**
+     * Create a new agent.
+     */
+    createAgent(options: IAgentManager.IOptions): IAgentManager;
+    /**
+     * Signal emitted when MCP connection status changes
+     */
+    readonly mcpConnectionChanged: ISignal<IAgentManagerFactory, boolean>;
+    /**
+     * Checks whether a specific MCP server is connected.
+     * @param serverName The name of the MCP server to check
+     * @returns True if the server is connected, false otherwise
+     */
+    isMCPServerConnected(serverName: string): boolean;
+    /**
+     * Gets the MCP tools from connected servers
+     */
+    getMCPTools(): Promise<ToolMap>;
+}
+export declare const IAgentManagerFactory: Token<IAgentManagerFactory>;
+/**
+ * The interface for the chat model handler.
  */
-export declare const SECRETS_NAMESPACE = "@jupyterlite/ai:providers";
-export declare const SECRETS_REPLACEMENT = "***";
-export declare const IAgentManagerFactory: Token<AgentManagerFactory>;
 export interface IChatModelHandler {
-    createModel(name: string, activeProvider: string, tokenUsage?: ITokenUsage): AIChatModel;
+    /**
+     * The function to create a new model.
+     */
+    createModel(options: ICreateChatOptions): AIChatModel;
+    /**
+     * The active cell manager (to copy code from chat to cell).
+     */
     activeCellManager: ActiveCellManager | undefined;
 }
+export interface ICreateChatOptions {
+    /**
+     * The name of the chat.
+     */
+    name: string;
+    /**
+     * The id of the active provider of the chat.
+     */
+    activeProvider: string;
+    /**
+     * The current token usage in this chat.
+     */
+    tokenUsage?: ITokenUsage;
+    /**
+     * The messages to ad by default.
+     */
+    messages?: IMessage[];
+    /**
+     * Whether the chat is autosaved or not.
+     */
+    autosave?: boolean;
+}
+/**
+ * Token for the chat model handler.
+ */
 export declare const IChatModelHandler: Token<IChatModelHandler>;
 /**
  * Parameters for showing cell diff
@@ -356,3 +633,51 @@ export interface IDiffManager {
  * Token for the diff manager.
  */
 export declare const IDiffManager: Token<IDiffManager>;
+/**
+ * Interface for token usage statistics from AI model interactions
+ */
+export interface ITokenUsage {
+    /**
+     * Number of input tokens consumed (prompt tokens)
+     */
+    inputTokens: number;
+    /**
+     * Number of output tokens generated (completion tokens)
+     */
+    outputTokens: number;
+    /**
+     * Estimated prompt tokens used by the most recent model request.
+     * This is based on the final step of the latest request.
+     */
+    lastRequestInputTokens?: number;
+    /**
+     * Configured context window size for the active provider/model.
+     */
+    contextWindow?: number;
+}
+/**
+ * The string that replaces a secret key in settings.
+ */
+export declare const SECRETS_NAMESPACE = "@jupyterlite/ai:providers";
+export declare const SECRETS_REPLACEMENT = "***";
+/**
+ * Internal interface for AI provider secret access within the shared namespace.
+ */
+export interface IAISecretsAccess {
+    /**
+     * Whether secrets access is currently available.
+     */
+    readonly isAvailable: boolean;
+    /**
+     * Get a secret value by ID.
+     */
+    get(id: string): Promise<string | undefined>;
+    /**
+     * Set a secret value by ID.
+     */
+    set(id: string, value: string): Promise<void>;
+    /**
+     * Attach an input field to a secret ID.
+     */
+    attach(id: string, input: HTMLInputElement, callback?: (value: string) => void): Promise<void>;
+}

package/lib/tokens.js

@@ -9,19 +9,21 @@ export var CommandIds;
     CommandIds.openChat = '@jupyterlite/ai:open-chat';
     CommandIds.moveChat = '@jupyterlite/ai:move-chat';
     CommandIds.refreshSkills = '@jupyterlite/ai:refresh-skills';
+    CommandIds.saveChat = '@jupyterlite/ai:save-chat';
+    CommandIds.restoreChat = '@jupyterlite/ai:restore-chat';
 })(CommandIds || (CommandIds = {}));
 /**
  * The tool registry token.
  */
-export const IToolRegistry = new Token('@jupyterlite/ai:tool-registry', 'Tool registry for AI agent functionality');
+export const IToolRegistry = new Token('@jupyterlite/ai:IToolRegistry', 'Tool registry for AI agent functionality');
 /**
  * The skill registry token.
  */
-export const ISkillRegistry = new Token('@jupyterlite/ai:skill-registry', 'Skill registry for AI agent functionality');
+export const ISkillRegistry = new Token('@jupyterlite/ai:ISkillRegistry', 'Skill registry for AI agent functionality');
 /**
  * Token for the provider registry.
  */
-export const IProviderRegistry = new Token('@jupyterlite/ai:provider-registry', 'Registry for AI providers');
+export const IProviderRegistry = new Token('@jupyterlite/ai:IProviderRegistry', 'Registry for AI providers');
 /**
  * Token for the AI settings model.
  */
@@ -29,18 +31,21 @@ export const IAISettingsModel = new Token('@jupyterlite/ai:IAISettingsModel');
 /**
  * Token for the agent manager.
  */
-export const IAgentManager = new Token('@jupyterlite/ai:agent-manager');
-/**
- * The string that replaces a secret key in settings.
- */
-export const SECRETS_NAMESPACE = '@jupyterlite/ai:providers';
-export const SECRETS_REPLACEMENT = '***';
+export const IAgentManager = new Token('@jupyterlite/ai:IAgentManager');
 /*
- * Token for the agent manager registry.
+ * Token for the agent manager factory.
+ */
+export const IAgentManagerFactory = new Token('@jupyterlite/ai:IAgentManagerFactory');
+/**
+ * Token for the chat model handler.
  */
-export const IAgentManagerFactory = new Token('@jupyterlite/ai:agent-manager-factory');
-export const IChatModelHandler = new Token('@jupyterlite/ai:chat-model-handler');
+export const IChatModelHandler = new Token('@jupyterlite/ai:IChatModelHandler');
 /**
  * Token for the diff manager.
  */
-export const IDiffManager = new Token('@jupyterlite/ai:diff-manager');
+export const IDiffManager = new Token('@jupyterlite/ai:IDiffManager');
+/**
+ * The string that replaces a secret key in settings.
+ */
+export const SECRETS_NAMESPACE = '@jupyterlite/ai:providers';
+export const SECRETS_REPLACEMENT = '***';

package/lib/tools/commands.d.ts

@@ -1,6 +1,5 @@
 import { CommandRegistry } from '@lumino/commands';
-import { ITool } from '../tokens';
-import { AISettingsModel } from '../models/settings-model';
+import type { IAISettingsModel, ITool } from '../tokens';
 /**
  * Create a tool to discover all available commands and their metadata
  */
@@ -9,4 +8,4 @@ export declare function createDiscoverCommandsTool(commands: CommandRegistry): I
  * Create a tool to execute a specific JupyterLab command.
  * Commands in the settings' commandsRequiringApproval list will need approval.
  */
-export declare function createExecuteCommandTool(commands: CommandRegistry, settingsModel: AISettingsModel): ITool;
+export declare function createExecuteCommandTool(commands: CommandRegistry, settingsModel: IAISettingsModel): ITool;

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

@@ -2,9 +2,7 @@ import { IThemeManager } from '@jupyterlab/apputils';
 import { ReactWidget } from '@jupyterlab/ui-components';
 import type { TranslationBundle } from '@jupyterlab/translation';
 import React from 'react';
-import { AgentManagerFactory } from '../agent';
-import { AISettingsModel } from '../models/settings-model';
-import { type IAISecretsAccess, type IProviderRegistry } from '../tokens';
+import { type IAgentManagerFactory, type IAISecretsAccess, type IAISettingsModel, type IProviderRegistry } from '../tokens';
 /**
  * A JupyterLab widget for AI settings configuration
  */
@@ -34,8 +32,8 @@ export declare namespace AISettingsWidget {
      * Options interface for constructing an AISettingsWidget
      */
     interface IOptions {
-        settingsModel: AISettingsModel;
-        agentManagerFactory?: AgentManagerFactory;
+        settingsModel: IAISettingsModel;
+        agentManagerFactory?: IAgentManagerFactory;
         themeManager?: IThemeManager;
         providerRegistry: IProviderRegistry;
         /**

package/lib/widgets/ai-settings.js

@@ -13,6 +13,7 @@ import MoreVert from '@mui/icons-material/MoreVert';
 import Settings from '@mui/icons-material/Settings';
 import { Alert, Box, Button, Card, CardContent, Chip, Dialog, DialogActions, DialogContent, DialogTitle, Divider, FormControl, FormControlLabel, IconButton, InputLabel, List, ListItem, ListItemText, Menu, MenuItem, Select, Switch, Tab, Tabs, TextField, ThemeProvider, Tooltip, Typography, createTheme } from '@mui/material';
 import React, { useEffect, useMemo, useState } from 'react';
+import { getEffectiveContextWindow } from '../providers/model-info';
 import { SECRETS_REPLACEMENT } from '../tokens';
 import { ProviderConfigDialog } from './provider-config-dialog';
 /**
@@ -409,6 +410,7 @@ const AISettingsComponent = ({ model, agentManagerFactory, themeManager, provide
                             const providerInfo = providerRegistry.getProviderInfo(provider.provider);
                             const providerToolCapabilities = providerInfo?.providerToolCapabilities;
                             const params = provider.parameters;
+                            const effectiveContextWindow = getEffectiveContextWindow(provider, providerRegistry);
                             const webSearchEnabled = !!providerToolCapabilities?.webSearch &&
                                 provider.customSettings?.webSearch?.enabled === true;
                             const webFetchEnabled = !!providerToolCapabilities?.webFetch &&
@@ -444,6 +446,7 @@ const AISettingsComponent = ({ model, agentManagerFactory, themeManager, provide
                                         (params?.temperature !== undefined ||
                                             params?.maxOutputTokens !== undefined ||
                                             params?.maxTurns !== undefined ||
+                                            effectiveContextWindow !== undefined ||
                                             webSearchEnabled ||
                                             webFetchEnabled) && (React.createElement(Box, { sx: {
                                                 display: 'flex',
@@ -454,6 +457,7 @@ const AISettingsComponent = ({ model, agentManagerFactory, themeManager, provide
                                             params?.temperature !== undefined && (React.createElement(Chip, { label: trans.__('Temp: %1', params.temperature), size: "small", variant: "outlined" })),
                                             params?.maxOutputTokens !== undefined && (React.createElement(Chip, { label: trans.__('Tokens: %1', params.maxOutputTokens), size: "small", variant: "outlined" })),
                                             params?.maxTurns !== undefined && (React.createElement(Chip, { label: trans.__('Turns: %1', params.maxTurns), size: "small", variant: "outlined" })),
+                                            effectiveContextWindow !== undefined && (React.createElement(Chip, { label: trans.__('Context: %1', effectiveContextWindow), size: "small", variant: "outlined" })),
                                             webSearchEnabled && (React.createElement(Chip, { label: trans.__('Web Search'), size: "small", variant: "outlined", color: "info" })),
                                             webFetchEnabled && (React.createElement(Chip, { label: trans.__('Web Fetch'), size: "small", variant: "outlined", color: "info" }))))),
                                     React.createElement(IconButton, { onClick: e => handleMenuClick(e, provider.id), size: "small" },
@@ -483,6 +487,11 @@ const AISettingsComponent = ({ model, agentManagerFactory, themeManager, provide
                                 }), color: "primary" }), label: React.createElement(Box, null,
                                 React.createElement(Typography, { variant: "body1" }, trans.__('Show Token Usage')),
                                 React.createElement(Typography, { variant: "caption", color: "text.secondary" }, trans.__('Display token usage information in the chat toolbar'))) }),
+                        React.createElement(FormControlLabel, { control: React.createElement(Switch, { checked: config.showContextUsage, onChange: e => handleConfigUpdate({
+                                    showContextUsage: e.target.checked
+                                }), color: "primary" }), label: React.createElement(Box, null,
+                                React.createElement(Typography, { variant: "body1" }, trans.__('Show Context Usage')),
+                                React.createElement(Typography, { variant: "caption", color: "text.secondary" }, trans.__('Display estimated context usage in the chat toolbar'))) }),
                         React.createElement(FormControlLabel, { control: React.createElement(Switch, { checked: config.showCellDiff, onChange: e => handleConfigUpdate({
                                     showCellDiff: e.target.checked
                                 }), color: "primary" }), label: React.createElement(Box, null,
@@ -500,6 +509,9 @@ const AISettingsComponent = ({ model, agentManagerFactory, themeManager, provide
                                 }), color: "primary" }), label: React.createElement(Box, null,
                                 React.createElement(Typography, { variant: "body1" }, trans.__('Show File Diff')),
                                 React.createElement(Typography, { variant: "caption", color: "text.secondary" }, trans.__('Show diff view when AI modifies file content'))) }),
+                        React.createElement(TextField, { fullWidth: true, label: trans.__('Chat Backup Directory'), value: config.chatBackupDirectory, onChange: e => handleConfigUpdate({
+                                chatBackupDirectory: e.target.value
+                            }), helperText: trans.__('Directory where chat history backups are saved (relative to the server root)') }),
                         React.createElement(Divider, { sx: { my: 1 } }),
                         React.createElement(TextField, { fullWidth: true, multiline: true, rows: 3, label: trans.__('System Prompt'), value: systemPromptValue, onChange: e => handleSystemPromptChange(e.target.value), placeholder: trans.__("Define the AI's behavior and personality..."), helperText: trans.__('Instructions that define how the AI should behave and respond') }),
                         React.createElement(TextField, { fullWidth: true, multiline: true, rows: 3, label: trans.__('Completion System Prompt'), value: completionPromptValue, onChange: e => handleCompletionPromptChange(e.target.value), placeholder: trans.__('Define how the AI should generate code completions...'), helperText: trans.__('Instructions that define how the AI should generate code completions') }),

package/lib/widgets/main-area-chat.d.ts

@@ -3,11 +3,11 @@ import { MainAreaWidget } from '@jupyterlab/apputils';
 import type { TranslationBundle } from '@jupyterlab/translation';
 import { CommandRegistry } from '@lumino/commands';
 import { AIChatModel } from '../chat-model';
-import { AISettingsModel } from '../models/settings-model';
+import { type IAISettingsModel } from '../tokens';
 export declare namespace MainAreaChat {
     interface IOptions extends MainAreaWidget.IOptions<ChatWidget> {
         commands: CommandRegistry;
-        settingsModel: AISettingsModel;
+        settingsModel: IAISettingsModel;
         trans: TranslationBundle;
     }
 }
@@ -26,6 +26,5 @@ export declare class MainAreaChat extends MainAreaWidget<ChatWidget> {
      */
     get area(): string | undefined;
     private _writersChanged;
-    private _approvalButtons;
     private _outputAreaCompat;
 }