@jupyternaut/persona 0.0.0 → 0.20.0

package/lib/widgets/provider-config-dialog.js

@@ -0,0 +1,384 @@
+import { getProviderModelInfo } from '@jupyternaut/agent';
+import ExpandMore from '@mui/icons-material/ExpandMore';
+import Delete from '@mui/icons-material/Delete';
+import Visibility from '@mui/icons-material/Visibility';
+import VisibilityOff from '@mui/icons-material/VisibilityOff';
+import { Accordion, AccordionDetails, AccordionSummary, Autocomplete, Box, Button, Chip, Dialog, DialogActions, DialogContent, DialogTitle, FormControl, FormControlLabel, IconButton, InputAdornment, InputLabel, List, ListItem, ListItemText, MenuItem, Select, Slider, Switch, TextField, Typography } from '@mui/material';
+import React from 'react';
+/**
+ * Default parameter values for provider configuration
+ */
+const DEFAULT_TEMPERATURE = 0.7;
+const DEFAULT_MAX_TURNS = 25;
+const DOMAIN_FIELD_MAP = {
+    'webSearch.allowedDomains': {
+        section: 'webSearch',
+        key: 'allowedDomains'
+    },
+    'webSearch.blockedDomains': {
+        section: 'webSearch',
+        key: 'blockedDomains'
+    },
+    'webFetch.allowedDomains': {
+        section: 'webFetch',
+        key: 'allowedDomains'
+    },
+    'webFetch.blockedDomains': {
+        section: 'webFetch',
+        key: 'blockedDomains'
+    }
+};
+function createEmptyDomainInputs() {
+    return {
+        'webSearch.allowedDomains': '',
+        'webSearch.blockedDomains': '',
+        'webFetch.allowedDomains': '',
+        'webFetch.blockedDomains': ''
+    };
+}
+function toRecord(value) {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        return value;
+    }
+    return {};
+}
+function toStringArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter((item) => typeof item === 'string');
+}
+function sanitizeCustomSettingsForProvider(customSettings, capabilities) {
+    const result = { ...customSettings };
+    const webSearch = toRecord(customSettings.webSearch);
+    const webFetch = toRecord(customSettings.webFetch);
+    const supportsWebSearch = !!capabilities?.webSearch;
+    const supportsWebFetch = !!capabilities?.webFetch;
+    if (supportsWebSearch && webSearch.enabled === true) {
+        result.webSearch = webSearch;
+    }
+    else {
+        delete result.webSearch;
+    }
+    if (supportsWebFetch && webFetch.enabled === true) {
+        result.webFetch = webFetch;
+    }
+    else {
+        delete result.webFetch;
+    }
+    return result;
+}
+export const ProviderConfigDialog = ({ open, onClose, onSave, initialConfig, mode, providerRegistry, handleSecretField, trans }) => {
+    const [name, setName] = React.useState(initialConfig?.name || '');
+    const [provider, setProvider] = React.useState(initialConfig?.provider || 'anthropic');
+    const [model, setModel] = React.useState(initialConfig?.model || '');
+    const [apiKey, setApiKey] = React.useState(initialConfig?.apiKey || '');
+    const [baseURL, setBaseURL] = React.useState(initialConfig?.baseURL || '');
+    const [showApiKey, setShowApiKey] = React.useState(false);
+    const [customSettings, setCustomSettings] = React.useState(initialConfig?.customSettings || {});
+    const [domainInputs, setDomainInputs] = React.useState(createEmptyDomainInputs());
+    const [parameters, setParameters] = React.useState(initialConfig?.parameters || {});
+    const [expandedAdvanced, setExpandedAdvanced] = React.useState(false);
+    const selectedProviderInfo = React.useMemo(() => providerRegistry.getProviderInfo(provider), [providerRegistry, provider]);
+    const providerToolCapabilities = selectedProviderInfo?.providerToolCapabilities;
+    const selectedModelInfo = React.useMemo(() => getProviderModelInfo(selectedProviderInfo, model), [selectedProviderInfo, model]);
+    const webSearchImplementation = providerToolCapabilities?.webSearch?.implementation;
+    const supportsWebSearch = !!providerToolCapabilities?.webSearch;
+    const supportsWebFetch = !!providerToolCapabilities?.webFetch;
+    const webSearchSettings = React.useMemo(() => toRecord(customSettings.webSearch), [customSettings]);
+    const webFetchSettings = React.useMemo(() => toRecord(customSettings.webFetch), [customSettings]);
+    // Get provider options from registry
+    const providerOptions = React.useMemo(() => {
+        const providers = providerRegistry.providers;
+        return Object.keys(providers).map(id => {
+            const info = providers[id];
+            return {
+                value: id,
+                label: info.name,
+                models: info.defaultModels,
+                apiKeyRequirement: info.apiKeyRequirement,
+                supportsBaseURL: info.supportsBaseURL,
+                description: info.description,
+                baseUrls: info.baseUrls
+            };
+        });
+    }, [providerRegistry]);
+    const selectedProvider = providerOptions.find(p => p.value === provider);
+    React.useEffect(() => {
+        if (open) {
+            // Reset form when dialog opens
+            const initialProvider = initialConfig?.provider || 'anthropic';
+            const initialProviderInfo = providerRegistry.getProviderInfo(initialProvider);
+            setName(initialConfig?.name || '');
+            setProvider(initialProvider);
+            setModel(initialConfig?.model || initialProviderInfo?.defaultModels[0] || '');
+            setApiKey(initialConfig?.apiKey || '');
+            setBaseURL(initialConfig?.baseURL || '');
+            setParameters(initialConfig?.parameters || {});
+            setCustomSettings(initialConfig?.customSettings || {});
+            setDomainInputs(createEmptyDomainInputs());
+            setShowApiKey(false);
+            setExpandedAdvanced(false);
+        }
+        else {
+            // Reset expanded state when dialog closes
+            setDomainInputs(createEmptyDomainInputs());
+            setExpandedAdvanced(false);
+        }
+    }, [open, initialConfig, providerRegistry]);
+    const handleRef = React.useCallback((node) => {
+        if (open && node) {
+            handleSecretField(node, provider, 'apiKey');
+        }
+    }, [provider, handleSecretField, open]);
+    const handleProviderChange = React.useCallback((newProvider) => {
+        const newProviderInfo = providerRegistry.getProviderInfo(newProvider);
+        setProvider(newProvider);
+        setModel(newProviderInfo?.defaultModels[0] || '');
+    }, [providerRegistry]);
+    const updateCustomSetting = React.useCallback((section, key, value) => {
+        setCustomSettings(prev => {
+            const next = { ...prev };
+            const sectionSettings = { ...toRecord(next[section]) };
+            const shouldDelete = value === undefined ||
+                value === null ||
+                value === '' ||
+                (Array.isArray(value) && value.length === 0);
+            if (shouldDelete) {
+                delete sectionSettings[key];
+            }
+            else {
+                sectionSettings[key] = value;
+            }
+            if (Object.keys(sectionSettings).length === 0) {
+                delete next[section];
+            }
+            else {
+                next[section] = sectionSettings;
+            }
+            return next;
+        });
+    }, []);
+    const addDomainValue = React.useCallback((fieldId) => {
+        const valueToAdd = domainInputs[fieldId].trim();
+        if (!valueToAdd) {
+            return;
+        }
+        const { section, key } = DOMAIN_FIELD_MAP[fieldId];
+        const currentValues = toStringArray(toRecord(customSettings[section])[key]);
+        if (currentValues.includes(valueToAdd)) {
+            setDomainInputs(prev => ({
+                ...prev,
+                [fieldId]: ''
+            }));
+            return;
+        }
+        const nextValues = [...currentValues, valueToAdd];
+        updateCustomSetting(section, key, nextValues);
+        setDomainInputs(prev => ({
+            ...prev,
+            [fieldId]: ''
+        }));
+    }, [customSettings, domainInputs, updateCustomSetting]);
+    const removeDomainValue = React.useCallback((fieldId, valueToRemove) => {
+        const { section, key } = DOMAIN_FIELD_MAP[fieldId];
+        const currentValues = toStringArray(toRecord(customSettings[section])[key]);
+        const nextValues = currentValues.filter(value => value !== valueToRemove);
+        updateCustomSetting(section, key, nextValues.length > 0 ? nextValues : undefined);
+    }, [customSettings, updateCustomSetting]);
+    const renderDomainList = React.useCallback((fieldId, label, placeholder, values) => {
+        const domainValues = toStringArray(values);
+        return (React.createElement(Box, null,
+            React.createElement(Typography, { variant: "body2", gutterBottom: true }, label),
+            React.createElement(List, { dense: true, sx: {
+                    mb: 1,
+                    maxHeight: 160,
+                    overflow: 'auto',
+                    border: 1,
+                    borderColor: 'divider',
+                    borderRadius: 1
+                } }, domainValues.length === 0 ? (React.createElement(ListItem, null,
+                React.createElement(ListItemText, { secondary: trans.__('No domains added.'), slotProps: {
+                        secondary: {
+                            color: 'text.secondary'
+                        }
+                    } }))) : (domainValues.map(value => (React.createElement(ListItem, { key: value, secondaryAction: React.createElement(IconButton, { onClick: () => removeDomainValue(fieldId, value), size: "small" },
+                    React.createElement(Delete, { fontSize: "small" })) },
+                React.createElement(ListItemText, { primary: value })))))),
+            React.createElement(TextField, { fullWidth: true, size: "small", label: trans.__('Add Domain'), value: domainInputs[fieldId], onChange: e => setDomainInputs(prev => ({
+                    ...prev,
+                    [fieldId]: e.target.value
+                })), onKeyDown: e => {
+                    if (e.key === 'Enter') {
+                        e.preventDefault();
+                        addDomainValue(fieldId);
+                    }
+                }, placeholder: placeholder, helperText: trans.__('Press Enter to add one domain.') })));
+    }, [addDomainValue, domainInputs, removeDomainValue, trans]);
+    const handleSave = () => {
+        if (!name.trim() || !provider || !model) {
+            return;
+        }
+        // Only include parameters if at least one is set
+        const hasParameters = Object.keys(parameters).some(key => parameters[key] !== undefined);
+        const sanitizedCustomSettings = sanitizeCustomSettingsForProvider(customSettings, providerToolCapabilities);
+        const config = {
+            name: name.trim(),
+            provider: provider,
+            model,
+            ...(apiKey && { apiKey }),
+            ...(baseURL && { baseURL }),
+            ...(hasParameters && { parameters }),
+            ...(Object.keys(sanitizedCustomSettings).length > 0 && {
+                customSettings: sanitizedCustomSettings
+            })
+        };
+        onSave(config);
+        onClose();
+    };
+    const isValid = name.trim() &&
+        provider &&
+        model &&
+        (selectedProvider?.apiKeyRequirement !== 'required' || apiKey);
+    return (React.createElement(Dialog, { open: open, onClose: onClose, maxWidth: "md", fullWidth: true },
+        React.createElement(DialogTitle, null, mode === 'add'
+            ? trans.__('Add New Provider')
+            : trans.__('Edit Provider')),
+        React.createElement(DialogContent, null,
+            React.createElement(Box, { sx: { display: 'flex', flexDirection: 'column', gap: 2, pt: 1 } },
+                React.createElement(TextField, { fullWidth: true, label: trans.__('Provider Name'), value: name, onChange: e => setName(e.target.value), placeholder: trans.__('e.g., My Anthropic Config, Work Provider'), helperText: trans.__('A friendly name to identify this provider configuration'), required: true }),
+                React.createElement(FormControl, { fullWidth: true, required: true },
+                    React.createElement(InputLabel, null, trans.__('Provider Type')),
+                    React.createElement(Select, { value: provider, label: trans.__('Provider Type'), onChange: e => handleProviderChange(e.target.value) }, providerOptions.map(option => (React.createElement(MenuItem, { key: option.value, value: option.value },
+                        React.createElement(Box, null,
+                            React.createElement(Box, { sx: { display: 'flex', alignItems: 'center', gap: 1 } },
+                                option.label,
+                                option.apiKeyRequirement === 'required' && (React.createElement(Chip, { size: "small", label: trans.__('API Key'), color: "default", variant: "outlined" }))),
+                            option.description && (React.createElement(Typography, { variant: "caption", color: "text.secondary" }, option.description)))))))),
+                React.createElement(Autocomplete, { freeSolo: true, fullWidth: true, options: selectedProvider?.models ?? [], value: model, onChange: (_, value) => {
+                        setModel(typeof value === 'string' ? value : '');
+                    }, inputValue: model, onInputChange: (_, value) => {
+                        setModel(value);
+                    }, renderInput: params => (React.createElement(TextField, { ...params, fullWidth: true, label: trans.__('Model'), placeholder: trans.__('Select or type a model ID'), required: true, helperText: trans.__('Choose from the list or enter a custom model ID') })), clearOnBlur: false }),
+                selectedProvider &&
+                    selectedProvider?.apiKeyRequirement !== 'none' && (React.createElement(TextField, { fullWidth: true, inputRef: handleRef, label: selectedProvider?.apiKeyRequirement === 'required'
+                        ? trans.__('API Key')
+                        : trans.__('API Key (Optional)'), type: showApiKey ? 'text' : 'password', value: apiKey, onChange: e => setApiKey(e.target.value), placeholder: trans.__('Enter your API key...'), required: selectedProvider?.apiKeyRequirement === 'required', InputProps: {
+                        endAdornment: (React.createElement(InputAdornment, { position: "end" },
+                            React.createElement(IconButton, { onClick: () => setShowApiKey(!showApiKey), edge: "end" }, showApiKey ? React.createElement(VisibilityOff, null) : React.createElement(Visibility, null))))
+                    } })),
+                selectedProvider?.supportsBaseURL && (React.createElement(Autocomplete, { freeSolo: true, fullWidth: true, options: (selectedProvider.baseUrls ?? []).map(option => option.url), value: baseURL || '', onChange: (_, value) => {
+                        if (value && typeof value === 'string') {
+                            setBaseURL(value);
+                        }
+                    }, inputValue: baseURL || '', renderOption: (props, option) => {
+                        const urlOption = (selectedProvider.baseUrls ?? []).find(u => u.url === option);
+                        return (React.createElement(Box, { component: "li", ...props, key: option },
+                            React.createElement(Box, null,
+                                React.createElement(Typography, { variant: "body2" }, option),
+                                urlOption?.description && (React.createElement(Typography, { variant: "caption", color: "text.secondary" }, urlOption.description)))));
+                    }, renderInput: params => (React.createElement(TextField, { ...params, fullWidth: true, label: trans.__('Base URL'), placeholder: "https://api.example.com/v1", onChange: e => setBaseURL(e.target.value) })), clearOnBlur: false })),
+                React.createElement(Accordion, { expanded: expandedAdvanced, onChange: (_, isExpanded) => setExpandedAdvanced(isExpanded), sx: {
+                        mt: 2,
+                        bgcolor: 'transparent',
+                        boxShadow: 'none',
+                        border: 1,
+                        borderColor: 'divider',
+                        borderRadius: 1
+                    } },
+                    React.createElement(AccordionSummary, { expandIcon: React.createElement(ExpandMore, null) },
+                        React.createElement(Typography, { variant: "subtitle1", fontWeight: "medium" }, trans.__('Advanced Settings'))),
+                    React.createElement(AccordionDetails, { sx: { bgcolor: 'transparent' } },
+                        React.createElement(Box, { sx: { display: 'flex', flexDirection: 'column', gap: 2 } },
+                            React.createElement(Box, null,
+                                React.createElement(Typography, { gutterBottom: true }, trans.__('Temperature: %1', parameters.temperature ?? trans.__('Default'))),
+                                React.createElement(Slider, { value: parameters.temperature ?? DEFAULT_TEMPERATURE, onChange: (_, value) => setParameters({
+                                        ...parameters,
+                                        temperature: value
+                                    }), min: 0, max: 2, step: 0.1, valueLabelDisplay: "auto" }),
+                                React.createElement(Typography, { variant: "caption", color: "text.secondary" }, trans.__('Temperature for the model (lower values are more deterministic)'))),
+                            React.createElement(TextField, { fullWidth: true, label: trans.__('Max Tokens (Optional)'), type: "number", value: parameters.maxOutputTokens ?? '', onChange: e => setParameters({
+                                    ...parameters,
+                                    maxOutputTokens: e.target.value
+                                        ? Number(e.target.value)
+                                        : undefined
+                                }), placeholder: trans.__('Leave empty for provider default'), helperText: trans.__('Maximum length of AI responses'), slotProps: { htmlInput: { min: 1 } } }),
+                            React.createElement(TextField, { fullWidth: true, label: trans.__('Max Turns (Optional)'), type: "number", value: parameters.maxTurns ?? '', onChange: e => setParameters({
+                                    ...parameters,
+                                    maxTurns: e.target.value
+                                        ? Number(e.target.value)
+                                        : undefined
+                                }), placeholder: trans.__('Default: %1', DEFAULT_MAX_TURNS), helperText: trans.__('Maximum number of tool execution turns'), slotProps: { htmlInput: { min: 1, max: 100 } } }),
+                            React.createElement(TextField, { fullWidth: true, label: trans.__('Context Window (Optional)'), type: "number", value: parameters.contextWindow ?? '', onChange: e => setParameters({
+                                    ...parameters,
+                                    contextWindow: e.target.value
+                                        ? Number(e.target.value)
+                                        : undefined
+                                }), placeholder: selectedModelInfo?.contextWindow !== undefined
+                                    ? trans.__('Default: %1', selectedModelInfo.contextWindow.toLocaleString())
+                                    : trans.__('e.g., 128000'), helperText: selectedModelInfo?.contextWindow !== undefined &&
+                                    parameters.contextWindow === undefined
+                                    ? trans.__('Using provider metadata default of %1 tokens for this model unless you override it here.', selectedModelInfo.contextWindow.toLocaleString())
+                                    : trans.__('Model context window size in tokens (used for context usage estimation)'), slotProps: { htmlInput: { min: 1 } } }),
+                            React.createElement(Typography, { variant: "body2", color: "text.secondary", sx: { mt: 2, mb: 1 } }, trans.__('Completion Options')),
+                            React.createElement(FormControlLabel, { control: React.createElement(Switch, { checked: parameters.supportsFillInMiddle ?? false, onChange: e => setParameters({
+                                        ...parameters,
+                                        supportsFillInMiddle: e.target.checked
+                                    }) }), label: trans.__('Fill-in-the-middle support') }),
+                            React.createElement(FormControlLabel, { control: React.createElement(Switch, { checked: parameters.useFilterText ?? false, onChange: e => setParameters({
+                                        ...parameters,
+                                        useFilterText: e.target.checked
+                                    }) }), label: trans.__('Use filter text') }),
+                            (supportsWebSearch || supportsWebFetch) && (React.createElement(React.Fragment, null,
+                                React.createElement(Typography, { variant: "body2", color: "text.secondary", sx: { mt: 2, mb: 1 } }, trans.__('Provider Web Tools')),
+                                supportsWebSearch && (React.createElement(React.Fragment, null,
+                                    React.createElement(FormControlLabel, { control: React.createElement(Switch, { checked: webSearchSettings.enabled === true, onChange: e => updateCustomSetting('webSearch', 'enabled', e.target.checked) }), label: trans.__('Enable Web Search') }),
+                                    webSearchSettings.enabled === true && (React.createElement(Box, { sx: {
+                                            pl: 2,
+                                            borderLeft: 2,
+                                            borderColor: 'divider',
+                                            display: 'flex',
+                                            flexDirection: 'column',
+                                            gap: 1.5
+                                        } },
+                                        (webSearchImplementation === 'openai' ||
+                                            webSearchImplementation === 'anthropic') &&
+                                            renderDomainList('webSearch.allowedDomains', trans.__('Allowed Domains'), trans.__('example.com'), webSearchSettings.allowedDomains),
+                                        webSearchImplementation === 'openai' && (React.createElement(React.Fragment, null,
+                                            React.createElement(FormControl, { fullWidth: true },
+                                                React.createElement(InputLabel, null, trans.__('Search Context Size')),
+                                                React.createElement(Select, { value: webSearchSettings.searchContextSize ??
+                                                        'medium', label: trans.__('Search Context Size'), onChange: e => updateCustomSetting('webSearch', 'searchContextSize', e.target.value) },
+                                                    React.createElement(MenuItem, { value: "low" }, trans.__('Low')),
+                                                    React.createElement(MenuItem, { value: "medium" }, trans.__('Medium')),
+                                                    React.createElement(MenuItem, { value: "high" }, trans.__('High')))),
+                                            React.createElement(FormControlLabel, { control: React.createElement(Switch, { checked: webSearchSettings.externalWebAccess !==
+                                                        false, onChange: e => updateCustomSetting('webSearch', 'externalWebAccess', e.target.checked) }), label: trans.__('Use External Web Access') }))),
+                                        webSearchImplementation === 'anthropic' && (React.createElement(React.Fragment, null,
+                                            React.createElement(TextField, { fullWidth: true, label: trans.__('Web Search Max Uses'), type: "number", value: webSearchSettings.maxUses ?? '', onChange: e => updateCustomSetting('webSearch', 'maxUses', e.target.value
+                                                    ? Number(e.target.value)
+                                                    : undefined), slotProps: { htmlInput: { min: 1 } } }),
+                                            renderDomainList('webSearch.blockedDomains', trans.__('Blocked Domains'), trans.__('spam.example.com'), webSearchSettings.blockedDomains))))))),
+                                supportsWebFetch && (React.createElement(React.Fragment, null,
+                                    React.createElement(FormControlLabel, { control: React.createElement(Switch, { checked: webFetchSettings.enabled === true, onChange: e => updateCustomSetting('webFetch', 'enabled', e.target.checked) }), label: trans.__('Enable Web Fetch') }),
+                                    webFetchSettings.enabled === true && (React.createElement(Box, { sx: {
+                                            pl: 2,
+                                            borderLeft: 2,
+                                            borderColor: 'divider',
+                                            display: 'flex',
+                                            flexDirection: 'column',
+                                            gap: 1.5
+                                        } },
+                                        React.createElement(TextField, { fullWidth: true, label: trans.__('Web Fetch Max Uses'), type: "number", value: webFetchSettings.maxUses ?? '', onChange: e => updateCustomSetting('webFetch', 'maxUses', e.target.value
+                                                ? Number(e.target.value)
+                                                : undefined), slotProps: { htmlInput: { min: 1 } } }),
+                                        React.createElement(TextField, { fullWidth: true, label: trans.__('Web Fetch Max Content Tokens'), type: "number", value: webFetchSettings.maxContentTokens ?? '', onChange: e => updateCustomSetting('webFetch', 'maxContentTokens', e.target.value
+                                                ? Number(e.target.value)
+                                                : undefined), slotProps: { htmlInput: { min: 1 } } }),
+                                        renderDomainList('webFetch.allowedDomains', trans.__('Allowed Domains'), trans.__('docs.example.com'), webFetchSettings.allowedDomains),
+                                        renderDomainList('webFetch.blockedDomains', trans.__('Blocked Domains'), trans.__('spam.example.com'), webFetchSettings.blockedDomains),
+                                        React.createElement(FormControlLabel, { control: React.createElement(Switch, { checked: webFetchSettings.citationsEnabled === true, onChange: e => updateCustomSetting('webFetch', 'citationsEnabled', e.target.checked) }), label: trans.__('Enable Citations') })))))))))))),
+        React.createElement(DialogActions, null,
+            React.createElement(Button, { onClick: onClose }, trans.__('Cancel')),
+            React.createElement(Button, { onClick: handleSave, variant: "contained", disabled: !isValid }, mode === 'add' ? trans.__('Add Provider') : trans.__('Save Changes')))));
+};

package/package.json

@@ -1,10 +1,114 @@
 {
   "name": "@jupyternaut/persona",
-  "version": "0.0.0",
-  "description": "Placeholder",
-  "main": "index.js",
-  "scripts": {},
-  "keywords": [],
-  "author": "",
-  "license": "BSD-3-Clause"
+  "version": "0.20.0",
+  "description": "AI code completions and chat for JupyterLite",
+  "keywords": [
+    "jupyter",
+    "jupyterlab",
+    "jupyterlab-extension"
+  ],
+  "homepage": "https://github.com/jupyterlite/ai",
+  "bugs": {
+    "url": "https://github.com/jupyterlite/ai/issues"
+  },
+  "license": "BSD-3-Clause",
+  "author": "JupyterLite Contributors",
+  "files": [
+    "lib/**/*.{d.ts,eot,gif,html,jpg,js,js.map,json,png,svg,woff2,ttf,md}",
+    "style/**/*.{css,js,eot,gif,html,jpg,json,png,svg,woff2,ttf}",
+    "src/**/*.{ts,tsx}",
+    "schema/*.json"
+  ],
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "style": "style/index.css",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jupyterlite/ai.git",
+    "directory": "packages/ai"
+  },
+  "scripts": {
+    "build": "echo 'Building @jupyternaut/persona' && jlpm build:lib && jlpm build:labextension:dev",
+    "build:dev": "echo 'Building @jupyternaut/persona' && jlpm build:lib && jlpm build:labextension:dev",
+    "build:prod": "echo 'Building @jupyternaut/persona' && jlpm clean && jlpm build:lib:prod && jlpm build:labextension",
+    "build:labextension": "jupyter-builder build .",
+    "build:labextension:dev": "jupyter-builder build --development True .",
+    "build:lib": "tsc --sourceMap",
+    "build:lib:prod": "tsc",
+    "clean": "jlpm clean:lib",
+    "clean:lib": "rimraf lib tsconfig.tsbuildinfo",
+    "install:extension": "jlpm build",
+    "watch": "run-p watch:src watch:labextension",
+    "watch:src": "tsc -w --sourceMap",
+    "watch:labextension": "jupyter-builder watch ."
+  },
+  "dependencies": {
+    "@jupyter/chat": "^0.25.0",
+    "@jupyter/ydoc": "^4.0.0",
+    "@jupyterlab/application": "^4.5.8",
+    "@jupyterlab/apputils": "^4.6.8",
+    "@jupyterlab/completer": "^4.5.8",
+    "@jupyterlab/coreutils": "^6.5.8",
+    "@jupyterlab/docmanager": "^4.5.8",
+    "@jupyterlab/docregistry": "^4.5.8",
+    "@jupyterlab/nbformat": "^4.5.8",
+    "@jupyterlab/notebook": "^4.5.8",
+    "@jupyterlab/rendermime": "^4.5.8",
+    "@jupyterlab/settingregistry": "^4.5.8",
+    "@jupyterlab/statusbar": "^4.5.8",
+    "@jupyterlab/translation": "^4.5.8",
+    "@jupyterlab/ui-components": "^4.5.8",
+    "@jupyternaut/agent": "^0.20.0",
+    "@lumino/commands": "^2.3.2",
+    "@lumino/coreutils": "^2.2.1",
+    "@lumino/disposable": "^2.1.4",
+    "@lumino/polling": "^2.1.4",
+    "@lumino/signaling": "^2.1.4",
+    "@mui/icons-material": "^7",
+    "@mui/material": "^7",
+    "ai": "^7.0.106",
+    "jupyter-mcp-manager": "^0.2.0",
+    "jupyter-secrets-manager": "^0.5.0",
+    "react": "^18.3.1"
+  },
+  "devDependencies": {
+    "@jupyter/builder": "^1.2.2",
+    "@jupyterlab/testutils": "^4.0.0",
+    "@types/json-schema": "^7.0.11",
+    "@types/node": "^24.3.0",
+    "@types/react": "^18.0.26",
+    "@types/react-addons-linked-state-mixin": "^0.14.22",
+    "css-loader": "^6.7.1",
+    "npm-run-all2": "^7.0.1",
+    "rimraf": "^5.0.1",
+    "source-map-loader": "^1.0.2",
+    "typescript": "~5.8.0"
+  },
+  "sideEffects": [
+    "style/*.css",
+    "style/index.js"
+  ],
+  "styleModule": "style/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "jupyterlab": {
+    "extension": true,
+    "outputDir": "../../python/jupyternaut-persona/jupyternaut_persona/labextension",
+    "schemaDir": "schema",
+    "sharedPackages": {
+      "@emotion/react": {
+        "bundled": true,
+        "singleton": true
+      },
+      "@jupyternaut/agent": {
+        "bundled": true,
+        "singleton": true
+      },
+      "jupyter-mcp-manager": {
+        "bundled": false,
+        "singleton": true
+      }
+    }
+  }
 }