@codingame/monaco-vscode-api 28.4.1 → 29.1.0

package/vscode/src/vs/workbench/contrib/chat/common/languageModels.js

@@ -11,6 +11,7 @@ import '../../../../base/common/observableInternal/index.js';
 import { equals } from '../../../../base/common/objects.js';
 import Severity$1 from '../../../../base/common/severity.js';
 import { isFalsyOrWhitespace, format } from '../../../../base/common/strings.js';
+import { SubmenuAction } from '../../../../base/common/actions.js';
 import { isString, isObject } from '../../../../base/common/types.js';
 import { generateUuid } from '../../../../base/common/uuid.js';
 import { localize } from '../../../../nls.js';
@@ -117,15 +118,15 @@ const languageModelChatProviderType = {
     properties: {
         vendor: {
             type: "string",
-            description: ( localize(6991, "A globally unique vendor of language model chat provider."))
+            description: ( localize(7214, "A globally unique vendor of language model chat provider."))
         },
         displayName: {
             type: "string",
-            description: ( localize(6992, "The display name of the language model chat provider."))
+            description: ( localize(7215, "The display name of the language model chat provider."))
         },
         configuration: {
             type: "object",
-            description: ( localize(6993, "Configuration options for the language model chat provider.")),
+            description: ( localize(7216, "Configuration options for the language model chat provider.")),
             anyOf: [{
                 $ref: "http://json-schema.org/draft-07/schema#"
             }, {
@@ -137,7 +138,7 @@ const languageModelChatProviderType = {
                             properties: {
                                 secret: {
                                     type: "boolean",
-                                    description: ( localize(6994, "Whether the property is a secret."))
+                                    description: ( localize(7217, "Whether the property is a secret."))
                                 }
                             }
                         }
@@ -147,7 +148,7 @@ const languageModelChatProviderType = {
                         properties: {
                             secret: {
                                 type: "boolean",
-                                description: ( localize(6994, "Whether the property is a secret."))
+                                description: ( localize(7217, "Whether the property is a secret."))
                             }
                         }
                     }
@@ -157,19 +158,19 @@ const languageModelChatProviderType = {
         managementCommand: {
             type: "string",
             description: ( localize(
-                6995,
+                7218,
                 "A command to manage the language model chat provider, e.g. 'Manage Copilot models'. This is used in the chat model picker. If not provided, a gear icon is not rendered during vendor selection."
             )),
             deprecated: true,
             deprecationMessage: ( localize(
-                6996,
+                7219,
                 "The managementCommand property is deprecated and will be removed in a future release. Use the new configuration property instead."
             ))
         },
         when: {
             type: "string",
             description: ( localize(
-                6997,
+                7220,
                 "Condition which must be true to show this language model chat provider in the Manage Models list."
             ))
         }
@@ -178,7 +179,7 @@ const languageModelChatProviderType = {
 const languageModelChatProviderExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: "languageModelChatProviders",
     jsonSchema: {
-        description: ( localize(6998, "Contribute language model chat providers of a specific vendor.")),
+        description: ( localize(7221, "Contribute language model chat providers of a specific vendor.")),
         oneOf: [languageModelChatProviderType, {
             type: "array",
             items: languageModelChatProviderType
@@ -233,6 +234,7 @@ let LanguageModelsService = class LanguageModelsService {
         this._modelCache = ( new Map());
         this._resolveLMSequencer = ( new SequencerByKey());
         this._modelPickerUserPreferences = {};
+        this._modelConfigurations = ( new Map());
         this._onLanguageModelChange = this._store.add(( new Emitter()));
         this.onDidChangeLanguageModels = this._onLanguageModelChange.event;
         this._recentlyUsedModelIds = [];
@@ -274,18 +276,18 @@ let LanguageModelsService = class LanguageModelsService {
                 for (const item of Iterable.wrap(extension.value)) {
                     if (( this._vendors.has(item.vendor))) {
                         extension.collector.error(( localize(
-                            6999,
+                            7222,
                             "The vendor '{0}' is already registered and cannot be registered twice",
                             item.vendor
                         )));
                         continue;
                     }
                     if (isFalsyOrWhitespace(item.vendor)) {
-                        extension.collector.error(( localize(7000, "The vendor field cannot be empty.")));
+                        extension.collector.error(( localize(7223, "The vendor field cannot be empty.")));
                         continue;
                     }
                     if (item.vendor.trim() !== item.vendor) {
-                        extension.collector.error(( localize(7001, "The vendor field cannot start or end with whitespace.")));
+                        extension.collector.error(( localize(7224, "The vendor field cannot start or end with whitespace.")));
                         continue;
                     }
                     addedVendors.push(item);
@@ -503,10 +505,28 @@ let LanguageModelsService = class LanguageModelsService {
                 });
             }
             const groups = this._languageModelsConfigurationService.getLanguageModelsProviderGroups();
+            const perModelConfigurations = ( new Map());
             for (const group of groups) {
                 if (group.vendor !== vendorId) {
                     continue;
                 }
+                if (vendor.isDefault && !vendor.configuration) {
+                    if (group.settings) {
+                        for (const model of allModels) {
+                            const modelConfig = group.settings[model.metadata.id];
+                            if (modelConfig) {
+                                perModelConfigurations.set(model.identifier, {
+                                    ...modelConfig
+                                });
+                            }
+                        }
+                    }
+                    languageModelsGroups.push({
+                        group,
+                        modelIdentifiers: []
+                    });
+                    continue;
+                }
                 const configuration = await this._resolveConfiguration(group, vendor.configuration);
                 try {
                     const models = await provider.provideLanguageModelChatInfo({
@@ -521,6 +541,16 @@ let LanguageModelsService = class LanguageModelsService {
                             modelIdentifiers: ( models.map(m => m.identifier))
                         });
                     }
+                    if (group.settings) {
+                        for (const model of models) {
+                            const modelConfig = group.settings[model.metadata.id];
+                            if (modelConfig) {
+                                perModelConfigurations.set(model.identifier, {
+                                    ...modelConfig
+                                });
+                            }
+                        }
+                    }
                 } catch (error) {
                     languageModelsGroups.push({
                         group,
@@ -546,6 +576,12 @@ let LanguageModelsService = class LanguageModelsService {
             }
             this._logService.trace(`[LM] Resolved language models for vendor ${vendorId}`, allModels);
             hasChanges = hasChanges || oldModels.size > 0;
+            this._clearModelConfigurations(vendorId);
+            for (const [identifier, config] of perModelConfigurations) {
+                if (( this._modelCache.has(identifier))) {
+                    this._modelConfigurations.set(identifier, config);
+                }
+            }
             if (hasChanges) {
                 this._onLanguageModelChange.fire(vendorId);
             } else {
@@ -595,11 +631,42 @@ let LanguageModelsService = class LanguageModelsService {
         });
     }
     async sendChatRequest(modelId, from, messages, options, token) {
-        const provider = this._providers.get(this._modelCache.get(modelId)?.vendor || "");
+        const metadata = this._modelCache.get(modelId);
+        const provider = this._providers.get(metadata?.vendor || "");
         if (!provider) {
             throw ( new Error(`Chat provider for model ${modelId} is not registered.`));
         }
-        return provider.sendChatRequest(modelId, messages, from, options, token);
+        const configuration = this.getModelConfiguration(modelId);
+        const mergedOptions = configuration ? {
+            ...options,
+            configuration: {
+                ...configuration,
+                ...options.configuration
+            }
+        } : options;
+        return provider.sendChatRequest(modelId, messages, from, mergedOptions, token);
+    }
+    _resolveModelConfigurationWithDefaults(modelId, metadata) {
+        const userConfig = this._modelConfigurations.get(modelId);
+        const schema = metadata?.configurationSchema;
+        if (!schema?.properties && !userConfig) {
+            return undefined;
+        }
+        const defaults = {};
+        if (schema?.properties) {
+            for (const [key, propSchema] of Object.entries(schema.properties)) {
+                if (propSchema.default !== undefined) {
+                    defaults[key] = propSchema.default;
+                }
+            }
+        }
+        if (!userConfig && ( Object.keys(defaults)).length === 0) {
+            return undefined;
+        }
+        return {
+            ...defaults,
+            ...userConfig
+        };
     }
     computeTokenLength(modelId, message, token) {
         const model = this._modelCache.get(modelId);
@@ -612,6 +679,118 @@ let LanguageModelsService = class LanguageModelsService {
         }
         return provider.provideTokenCount(modelId, message, token);
     }
+    getModelConfiguration(modelId) {
+        const metadata = this._modelCache.get(modelId);
+        return this._resolveModelConfigurationWithDefaults(modelId, metadata);
+    }
+    async setModelConfiguration(modelId, values) {
+        const metadata = this._modelCache.get(modelId);
+        if (!metadata) {
+            return;
+        }
+        const allGroups = this._languageModelsConfigurationService.getLanguageModelsProviderGroups();
+        let group;
+        group = allGroups.find(
+            g => g.vendor === metadata.vendor && g.settings?.[metadata.id] !== undefined
+        );
+        if (!group) {
+            group = allGroups.find(g => g.vendor === metadata.vendor);
+        }
+        const existingConfig = this._modelConfigurations.get(modelId) ?? {};
+        const updatedConfig = {
+            ...existingConfig,
+            ...values
+        };
+        const schema = metadata.configurationSchema;
+        if (schema?.properties) {
+            for (const [key, value] of Object.entries(updatedConfig)) {
+                const propSchema = schema.properties[key];
+                if (propSchema?.default !== undefined && propSchema.default === value) {
+                    delete updatedConfig[key];
+                }
+            }
+        }
+        if (group) {
+            const existingSettings = group.settings ?? {};
+            let updatedSettings;
+            if (( Object.keys(updatedConfig)).length === 0) {
+                updatedSettings = {
+                    ...existingSettings
+                };
+                delete updatedSettings[metadata.id];
+            } else {
+                updatedSettings = {
+                    ...existingSettings,
+                    [metadata.id]: updatedConfig
+                };
+            }
+            const updatedGroup = {
+                ...group,
+                settings: ( Object.keys(updatedSettings)).length > 0 ? updatedSettings : undefined
+            };
+            if (!updatedGroup.settings && ( Object.keys(updatedGroup)).filter(k => k !== "name" && k !== "vendor" && k !== "range" && k !== "settings").length === 0) {
+                await this._languageModelsConfigurationService.removeLanguageModelsProviderGroup(group);
+            } else {
+                await this._languageModelsConfigurationService.updateLanguageModelsProviderGroup(group, updatedGroup);
+            }
+        } else if (( Object.keys(updatedConfig)).length > 0) {
+            const vendor = this.getVendors().find(v => v.vendor === metadata.vendor);
+            if (!vendor) {
+                return;
+            }
+            const newGroup = {
+                name: vendor.displayName,
+                vendor: metadata.vendor,
+                settings: {
+                    [metadata.id]: updatedConfig
+                }
+            };
+            await this._languageModelsConfigurationService.addLanguageModelsProviderGroup(newGroup);
+        }
+        if (( Object.keys(updatedConfig)).length > 0) {
+            this._modelConfigurations.set(modelId, updatedConfig);
+        } else {
+            this._modelConfigurations.delete(modelId);
+        }
+        this._onLanguageModelChange.fire(metadata.vendor);
+    }
+    getModelConfigurationActions(modelId) {
+        const metadata = this._modelCache.get(modelId);
+        const schema = metadata?.configurationSchema;
+        if (!schema?.properties) {
+            return [];
+        }
+        const actions = [];
+        const currentConfig = this._modelConfigurations.get(modelId) ?? {};
+        for (const [key, propSchema] of Object.entries(schema.properties)) {
+            if (!propSchema.enum || !Array.isArray(propSchema.enum)) {
+                continue;
+            }
+            const currentValue = currentConfig[key] ?? propSchema.default;
+            const label = (typeof propSchema.title === "string" ? propSchema.title : undefined) ?? key.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/^./, s => s.toUpperCase());
+            const defaultValue = propSchema.default;
+            const enumItemLabels = propSchema.enumItemLabels;
+            const enumDescriptions = propSchema.enumDescriptions;
+            const enumActions = ( propSchema.enum.map((value, index) => {
+                const itemLabel = enumItemLabels?.[index] ?? String(value);
+                const displayLabel = value === defaultValue ? ( localize(7225, "{0} (default)", itemLabel)) : itemLabel;
+                const tooltip = enumDescriptions?.[index] ?? "";
+                return {
+                    id: `configureModel.${key}.${value}`,
+                    label: displayLabel,
+                    class: undefined,
+                    enabled: true,
+                    tooltip,
+                    checked: currentValue === value,
+                    run: () => this.setModelConfiguration(modelId, {
+                        [key]: value
+                    })
+                };
+            }));
+            actions.push(( new SubmenuAction(`configureModel.${key}`, label, enumActions)));
+        }
+        return actions;
+    }
     async configureLanguageModelsProviderGroup(vendorId, providerGroupName) {
         const vendor = this.getVendors().find((
             {
@@ -653,6 +832,62 @@ let LanguageModelsService = class LanguageModelsService {
             throw error;
         }
     }
+    async configureModel(modelId) {
+        const metadata = this._modelCache.get(modelId);
+        if (!metadata || !metadata.configurationSchema) {
+            return;
+        }
+        const vendorGroups = this._modelsGroups.get(metadata.vendor);
+        let group;
+        if (vendorGroups) {
+            for (const vg of vendorGroups) {
+                if (vg.modelIdentifiers.includes(modelId) && vg.group) {
+                    group = vg.group;
+                    break;
+                }
+            }
+        }
+        if (!group) {
+            const vendor = this.getVendors().find(v => v.vendor === metadata.vendor);
+            if (!vendor) {
+                return;
+            }
+            const groupName = vendor.displayName;
+            const newGroup = {
+                name: groupName,
+                vendor: metadata.vendor,
+                settings: {
+                    [metadata.id]: {}
+                }
+            };
+            group = await this._languageModelsConfigurationService.addLanguageModelsProviderGroup(newGroup);
+            await this._resolveAllLanguageModels(metadata.vendor, true);
+        }
+        const snippet = this._getModelConfigurationSnippet(metadata.id, metadata.configurationSchema);
+        await this._languageModelsConfigurationService.configureLanguageModels({
+            group,
+            snippet
+        });
+    }
+    _getModelConfigurationSnippet(modelId, schema) {
+        const properties = [];
+        if (schema.properties) {
+            for (const [key, propSchema] of Object.entries(schema.properties)) {
+                if (propSchema.defaultSnippets?.[0]) {
+                    const snippet = propSchema.defaultSnippets[0];
+                    let bodyText = snippet.bodyText ?? JSON.stringify(snippet.body, null, "\t\t\t");
+                    bodyText = bodyText.replace(/"(\^[^"]*)"/g, (_, value) => value.substring(1));
+                    properties.push(`\t\t\t"${key}": ${bodyText}`);
+                } else if (propSchema.default !== undefined) {
+                    properties.push(`\t\t\t"${key}": ${JSON.stringify(propSchema.default)}`);
+                } else {
+                    properties.push(`\t\t\t"${key}": $\{${key}\}`);
+                }
+            }
+        }
+        const modelContent = properties.length > 0 ? `{\n${properties.join(",\n")}\n\t\t}` : "{\n\t\t\t$0\n\t\t}";
+        return `"settings": {\n\t\t"${modelId}": ${modelContent}\n\t}`;
+    }
     async addLanguageModelsProviderGroup(name, vendorId, configuration) {
         const vendor = this.getVendors().find((
             {
@@ -730,18 +965,18 @@ let LanguageModelsService = class LanguageModelsService {
         try {
             await ( new Promise(resolve => {
                 const inputBox = disposables.add(this._quickInputService.createInputBox());
-                inputBox.title = ( localize(7002, "Group Name"));
-                inputBox.placeholder = ( localize(7003, "Enter a name for the group"));
+                inputBox.title = ( localize(7226, "Group Name"));
+                inputBox.placeholder = ( localize(7227, "Enter a name for the group"));
                 inputBox.value = providerGroupName;
                 inputBox.ignoreFocusOut = true;
                 disposables.add(inputBox.onDidChangeValue(value => {
                     if (!value) {
-                        inputBox.validationMessage = ( localize(7004, "Please enter a name"));
+                        inputBox.validationMessage = ( localize(7228, "Please enter a name"));
                         inputBox.severity = Severity$1.Error;
                         return;
                     }
                     if (!existing && ( languageModelProviderGroups.some(g => g.name === value))) {
-                        inputBox.validationMessage = ( localize(7005, "A language models group with this name already exists"));
+                        inputBox.validationMessage = ( localize(7229, "A language models group with this name already exists"));
                         inputBox.severity = Severity$1.Error;
                         return;
                     }
@@ -822,7 +1057,7 @@ let LanguageModelsService = class LanguageModelsService {
                 quickPick.items = ( items.map(item => ({
                     label: item
                 })));
-                quickPick.placeholder = propertySchema.description ?? ( localize(7006, "Select value for {0}", property));
+                quickPick.placeholder = propertySchema.description ?? ( localize(7230, "Select value for {0}", property));
                 quickPick.canSelectMany = true;
                 quickPick.ignoreFocusOut = true;
                 disposables.add(quickPick.onDidAccept(() => {
@@ -844,7 +1079,7 @@ let LanguageModelsService = class LanguageModelsService {
             const value = await ( new Promise((resolve, reject) => {
                 const inputBox = disposables.add(this._quickInputService.createInputBox());
                 inputBox.title = `${groupName}: ${propertySchema.title ?? property}`;
-                inputBox.placeholder = ( localize(7007, "Enter value for {0}", property));
+                inputBox.placeholder = ( localize(7231, "Enter value for {0}", property));
                 inputBox.password = !!propertySchema.secret;
                 inputBox.ignoreFocusOut = true;
                 if (existing?.[property]) {
@@ -857,20 +1092,20 @@ let LanguageModelsService = class LanguageModelsService {
                 }
                 disposables.add(inputBox.onDidChangeValue(value => {
                     if (!value && required) {
-                        inputBox.validationMessage = ( localize(7008, "Value is required"));
+                        inputBox.validationMessage = ( localize(7232, "Value is required"));
                         inputBox.severity = Severity$1.Error;
                         return;
                     }
                     if (propertySchema.type === "number" || propertySchema.type === "integer") {
                         if (isNaN(Number(value))) {
-                            inputBox.validationMessage = ( localize(7009, "Please enter a number"));
+                            inputBox.validationMessage = ( localize(7233, "Please enter a number"));
                             inputBox.severity = Severity$1.Error;
                             return;
                         }
                     }
                     if (propertySchema.type === "boolean") {
                         if (value !== "true" && value !== "false") {
-                            inputBox.validationMessage = ( localize(7010, "Please enter true or false"));
+                            inputBox.validationMessage = ( localize(7234, "Please enter true or false"));
                             inputBox.severity = Severity$1.Error;
                             return;
                         }
@@ -880,7 +1115,7 @@ let LanguageModelsService = class LanguageModelsService {
                 }));
                 disposables.add(inputBox.onDidAccept(() => {
                     if (!inputBox.value && required) {
-                        inputBox.validationMessage = ( localize(7008, "Value is required"));
+                        inputBox.validationMessage = ( localize(7232, "Value is required"));
                         inputBox.severity = Severity$1.Error;
                         return;
                     }
@@ -929,13 +1164,20 @@ let LanguageModelsService = class LanguageModelsService {
         }
         return removed;
     }
+    _clearModelConfigurations(vendor) {
+        for (const [id] of this._modelConfigurations) {
+            if (this._modelCache.get(id)?.vendor === vendor || id.startsWith(`${vendor}/`)) {
+                this._modelConfigurations.delete(id);
+            }
+        }
+    }
     async _resolveConfiguration(group, schema) {
         if (!schema) {
             return {};
         }
         const result = {};
         for (const key in group) {
-            if (key === "vendor" || key === "name" || key === "range") {
+            if (key === "vendor" || key === "name" || key === "range" || key === "settings") {
                 continue;
             }
             let value = group[key];
@@ -1071,7 +1313,7 @@ let LanguageModelsService = class LanguageModelsService {
                 free[entry.id] = {
                     label: entry.label,
                     featured: entry.featured,
-                    exists: this._modelExistsInCache(entry.id)
+                    exists: ( this._modelCache.has(`copilot/${entry.id}`))
                 };
             }
         }
@@ -1085,7 +1327,7 @@ let LanguageModelsService = class LanguageModelsService {
                     label: entry.label,
                     featured: entry.featured,
                     minVSCodeVersion: entry.minVSCodeVersion,
-                    exists: this._modelExistsInCache(entry.id)
+                    exists: ( this._modelCache.has(`copilot/${entry.id}`))
                 };
             }
         }
@@ -1095,14 +1337,6 @@ let LanguageModelsService = class LanguageModelsService {
         };
         this._onDidChangeModelsControlManifest.fire(this._modelsControlManifest);
     }
-    _modelExistsInCache(metadataId) {
-        for (const model of ( this._modelCache.values())) {
-            if (model.id === metadataId) {
-                return true;
-            }
-        }
-        return false;
-    }
     _initChatControlData() {
         this._chatControlUrl = this._productService.chatParticipantRegistry;
         if (!this._chatControlUrl) {
@@ -1137,7 +1371,8 @@ let LanguageModelsService = class LanguageModelsService {
         try {
             context = await this._requestService.request({
                 type: "GET",
-                url: this._chatControlUrl
+                url: this._chatControlUrl,
+                callSite: "languageModels.fetchChatControlData"
             }, CancellationToken.None);
         } catch (err) {
             this._logService.warn("[LM] Failed to request chat control data", getErrorMessage(err));

package/vscode/src/vs/workbench/contrib/chat/common/languageModels.service.d.ts

@@ -1,10 +1,11 @@
+import { IAction } from "../../../../base/common/actions.js";
 import { CancellationToken } from "../../../../base/common/cancellation.js";
 import { IStringDictionary } from "../../../../base/common/collections.js";
 import { Event } from "../../../../base/common/event.js";
 import { IDisposable } from "../../../../base/common/lifecycle.js";
 import { IObservable } from "../../../../base/common/observable.js";
 import { ExtensionIdentifier } from "../../../../platform/extensions/common/extensions.js";
-import { ILanguageModelProviderDescriptor, ILanguageModelChatMetadata, ILanguageModelChatMetadataAndIdentifier, ILanguageModelsGroup, ILanguageModelChatSelector, ILanguageModelChatProvider, IUserFriendlyLanguageModel, IChatMessage, ILanguageModelChatResponse, IModelsControlManifest } from "./languageModels.js";
+import { ILanguageModelProviderDescriptor, ILanguageModelChatMetadata, ILanguageModelChatMetadataAndIdentifier, ILanguageModelsGroup, ILanguageModelChatSelector, ILanguageModelChatProvider, IUserFriendlyLanguageModel, IChatMessage, ILanguageModelChatRequestOptions, ILanguageModelChatResponse, IModelsControlManifest } from "./languageModels.js";
 import { ILanguageModelsProviderGroup } from "./languageModelsConfiguration.js";
 export declare const ILanguageModelsService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<ILanguageModelsService>;
 export interface ILanguageModelsService {
@@ -27,13 +28,33 @@ export interface ILanguageModelsService {
     selectLanguageModels(selector: ILanguageModelChatSelector): Promise<string[]>;
     registerLanguageModelProvider(vendor: string, provider: ILanguageModelChatProvider): IDisposable;
     deltaLanguageModelChatProviderDescriptors(added: IUserFriendlyLanguageModel[], removed: IUserFriendlyLanguageModel[]): void;
-    sendChatRequest(modelId: string, from: ExtensionIdentifier | undefined, messages: IChatMessage[], options: {
-        [name: string]: any;
-    }, token: CancellationToken): Promise<ILanguageModelChatResponse>;
+    sendChatRequest(modelId: string, from: ExtensionIdentifier | undefined, messages: IChatMessage[], options: ILanguageModelChatRequestOptions, token: CancellationToken): Promise<ILanguageModelChatResponse>;
     computeTokenLength(modelId: string, message: string | IChatMessage, token: CancellationToken): Promise<number>;
+    /**
+    * Returns the resolved per-model configuration for the given model identifier.
+    * Includes schema defaults with user overrides applied on top.
+    * Returns undefined if the model has no configuration schema and no user config.
+    */
+    getModelConfiguration(modelId: string): IStringDictionary<unknown> | undefined;
+    /**
+    * Updates the per-model configuration for the given model.
+    * Merges the provided values into the existing configuration.
+    */
+    setModelConfiguration(modelId: string, values: IStringDictionary<unknown>): Promise<void>;
+    /**
+    * Returns actions for configuring the given model based on its configuration schema.
+    * For enum properties, returns submenu actions with checkable values.
+    * Returns an empty array if the model has no configuration schema.
+    */
+    getModelConfigurationActions(modelId: string): IAction[];
     addLanguageModelsProviderGroup(name: string, vendorId: string, configuration: IStringDictionary<unknown> | undefined): Promise<void>;
     removeLanguageModelsProviderGroup(vendorId: string, providerGroupName: string): Promise<void>;
     configureLanguageModelsProviderGroup(vendorId: string, name?: string): Promise<void>;
+    /**
+    * Opens the language models configuration file and navigates to
+    * or creates the per-model configuration for the given model.
+    */
+    configureModel(modelId: string): Promise<void>;
     migrateLanguageModelsProviderGroup(languageModelsProviderGroup: ILanguageModelsProviderGroup): Promise<void>;
     /**
     * Returns the most recently used model identifiers, ordered by most-recent-first.

package/vscode/src/vs/workbench/contrib/chat/common/languageModelsConfiguration.d.ts

@@ -8,4 +8,5 @@ export interface ILanguageModelsProviderGroup extends IStringDictionary<unknown>
     readonly name: string;
     readonly vendor: string;
     readonly range?: IRange;
+    readonly settings?: IStringDictionary<IStringDictionary<unknown>>;
 }

package/vscode/src/vs/workbench/contrib/chat/common/model/chatModel.d.ts

@@ -279,12 +279,14 @@ declare class AbstractResponse implements IResponse {
     protected _responseParts: IChatProgressResponseContent[];
     /**
      * A stringified representation of response data which might be presented to a screenreader or used when copying a response.
+     * Computed lazily on demand to avoid expensive string rebuilding during streaming.
      */
-    protected _responseRepr: string;
+    private _responseRepr;
     /**
-     * Just the markdown content of the response, used for determining the rendering rate of markdown
+     * Just the markdown content of the response, used for determining the rendering rate of markdown.
+     * Computed lazily on demand to avoid expensive string rebuilding during streaming.
      */
-    protected _markdownContent: string;
+    private _markdownContent;
     get value(): IChatProgressResponseContent[];
     constructor(value: IChatProgressResponseContent[]);
     toString(): string;
@@ -292,7 +294,12 @@ declare class AbstractResponse implements IResponse {
      * _Just_ the content of markdown parts in the response
      */
     getMarkdown(): string;
-    protected _updateRepr(): void;
+    /**
+     * Invalidate cached representations so they are recomputed on next access.
+     */
+    protected _invalidateRepr(): void;
+    private computeMarkdownContent;
+    protected computeRepr(): string;
     private partsToRepr;
     private inlineRefToRepr;
     private getToolInvocationText;
@@ -311,7 +318,8 @@ export declare class Response extends AbstractResponse implements IDisposable {
     private _mergeOrPushTextEditGroup;
     private _mergeOrPushNotebookEditGroup;
     private _handleExternalToolInvocationUpdate;
-    protected _updateRepr(quiet?: boolean): void;
+    protected computeRepr(): string;
+    private _contentChanged;
 }
 export interface IChatResponseModelParameters {
     responseContent: IMarkdownString | ReadonlyArray<SerializedChatResponsePart>;
@@ -524,6 +532,7 @@ export interface ISerializableChatRequestData extends ISerializableChatResponseD
     confirmation?: string;
     editedFileEvents?: IChatAgentEditedFileEvent[];
     modelId?: string;
+    modeInfo?: IChatRequestModeInfo;
 }
 export interface ISerializableMarkdownInfo {
     readonly suggestionId: EditSuggestionId;