@codingame/monaco-vscode-api 26.2.2 → 27.0.0

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

@@ -1,21 +1,25 @@
 
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { SequencerByKey } from '../../../../base/common/async.js';
+import { SequencerByKey, timeout } from '../../../../base/common/async.js';
 import { CancellationToken } from '../../../../base/common/cancellation.js';
 import { getErrorMessage, isCancellationError, CancellationError } from '../../../../base/common/errors.js';
 import { Emitter } from '../../../../base/common/event.js';
 import { hash } from '../../../../base/common/hash.js';
 import { Iterable } from '../../../../base/common/iterator.js';
 import { DisposableStore, toDisposable } from '../../../../base/common/lifecycle.js';
+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 { isString } from '../../../../base/common/types.js';
+import { isString, isObject } from '../../../../base/common/types.js';
 import { generateUuid } from '../../../../base/common/uuid.js';
 import { localize } from '../../../../nls.js';
 import { ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
 import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.service.js';
 import { ILogService } from '../../../../platform/log/common/log.service.js';
+import { IProductService } from '../../../../platform/product/common/productService.service.js';
+import { asJson } from '../../../../platform/request/common/request.js';
+import { IRequestService } from '../../../../platform/request/common/request.service.js';
 import { QuickInputHideReason } from '../../../../platform/quickinput/common/quickInput.js';
 import { IQuickInputService } from '../../../../platform/quickinput/common/quickInput.service.js';
 import { ISecretStorageService } from '../../../../platform/secrets/common/secrets.service.js';
@@ -25,6 +29,7 @@ import { IExtensionService } from '../../../services/extensions/common/extension
 import { ExtensionsRegistry } from '../../../services/extensions/common/extensionsRegistry.js';
 import { ChatContextKeys } from './actions/chatContextKeys.js';
 import { ILanguageModelsConfigurationService } from './languageModelsConfiguration.service.js';
+import { observableValue } from '../../../../base/common/observableInternal/observables/observableValue.js';
 
 var LanguageModelsService_1;
 var ChatMessageRole;
@@ -71,6 +76,34 @@ var ILanguageModelChatMetadata;
     }
     ILanguageModelChatMetadata.matchesQualifiedName = matchesQualifiedName;
 })(ILanguageModelChatMetadata || (ILanguageModelChatMetadata = {}));
+async function getTextResponseFromStream(response) {
+    let responseText = "";
+    const streaming = (async () => {
+        if (!response?.stream) {
+            return;
+        }
+        for await (const part of response.stream) {
+            if (Array.isArray(part)) {
+                for (const item of part) {
+                    if (item.type === "text") {
+                        responseText += item.value;
+                    }
+                }
+            } else if (part.type === "text") {
+                responseText += part.value;
+            }
+        }
+    })();
+    try {
+        await Promise.all([response.result, streaming]);
+        return responseText;
+    } catch (err) {
+        if (responseText) {
+            return responseText;
+        }
+        throw err;
+    }
+}
 function isILanguageModelChatSelector(value) {
     if (typeof value !== "object" || value === null) {
         return false;
@@ -84,15 +117,15 @@ const languageModelChatProviderType = {
     properties: {
         vendor: {
             type: "string",
-            description: ( localize(6324, "A globally unique vendor of language model chat provider."))
+            description: ( localize(6875, "A globally unique vendor of language model chat provider."))
         },
         displayName: {
             type: "string",
-            description: ( localize(6325, "The display name of the language model chat provider."))
+            description: ( localize(6876, "The display name of the language model chat provider."))
         },
         configuration: {
             type: "object",
-            description: ( localize(6326, "Configuration options for the language model chat provider.")),
+            description: ( localize(6877, "Configuration options for the language model chat provider.")),
             anyOf: [{
                 $ref: "http://json-schema.org/draft-07/schema#"
             }, {
@@ -104,7 +137,7 @@ const languageModelChatProviderType = {
                             properties: {
                                 secret: {
                                     type: "boolean",
-                                    description: ( localize(6327, "Whether the property is a secret."))
+                                    description: ( localize(6878, "Whether the property is a secret."))
                                 }
                             }
                         }
@@ -114,7 +147,7 @@ const languageModelChatProviderType = {
                         properties: {
                             secret: {
                                 type: "boolean",
-                                description: ( localize(6327, "Whether the property is a secret."))
+                                description: ( localize(6878, "Whether the property is a secret."))
                             }
                         }
                     }
@@ -124,19 +157,19 @@ const languageModelChatProviderType = {
         managementCommand: {
             type: "string",
             description: ( localize(
-                6328,
+                6879,
                 "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(
-                6329,
+                6880,
                 "The managementCommand property is deprecated and will be removed in a future release. Use the new configuration property instead."
             ))
         },
         when: {
             type: "string",
             description: ( localize(
-                6330,
+                6881,
                 "Condition which must be true to show this language model chat provider in the Manage Models list."
             ))
         }
@@ -145,7 +178,7 @@ const languageModelChatProviderType = {
 const languageModelChatProviderExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: "languageModelChatProviders",
     jsonSchema: {
-        description: ( localize(6331, "Contribute language model chat providers of a specific vendor.")),
+        description: ( localize(6882, "Contribute language model chat providers of a specific vendor.")),
         oneOf: [languageModelChatProviderType, {
             type: "array",
             items: languageModelChatProviderType
@@ -158,6 +191,9 @@ const languageModelChatProviderExtensionPoint = ExtensionsRegistry.registerExten
     }
 });
 const CHAT_MODEL_PICKER_PREFERENCES_STORAGE_KEY = "chatModelPickerPreferences";
+const CHAT_MODEL_RECENTLY_USED_STORAGE_KEY = "chatModelRecentlyUsed";
+const CHAT_PARTICIPANT_NAME_REGISTRY_STORAGE_KEY = "chat.participantNameRegistry";
+const CHAT_MODELS_CONTROL_STORAGE_KEY = "chat.modelsControl";
 let LanguageModelsService = class LanguageModelsService {
     static {
         LanguageModelsService_1 = this;
@@ -175,7 +211,9 @@ let LanguageModelsService = class LanguageModelsService {
         _contextKeyService,
         _languageModelsConfigurationService,
         _quickInputService,
-        _secretStorageService
+        _secretStorageService,
+        _productService,
+        _requestService
     ) {
         this._extensionService = _extensionService;
         this._logService = _logService;
@@ -184,6 +222,8 @@ let LanguageModelsService = class LanguageModelsService {
         this._languageModelsConfigurationService = _languageModelsConfigurationService;
         this._quickInputService = _quickInputService;
         this._secretStorageService = _secretStorageService;
+        this._productService = _productService;
+        this._requestService = _requestService;
         this._store = ( new DisposableStore());
         this._providers = ( new Map());
         this._vendors = ( new Map());
@@ -195,16 +235,29 @@ let LanguageModelsService = class LanguageModelsService {
         this._modelPickerUserPreferences = {};
         this._onLanguageModelChange = this._store.add(( new Emitter()));
         this.onDidChangeLanguageModels = this._onLanguageModelChange.event;
+        this._recentlyUsedModelIds = [];
+        this._onDidChangeModelsControlManifest = this._store.add(( new Emitter()));
+        this.onDidChangeModelsControlManifest = this._onDidChangeModelsControlManifest.event;
+        this._modelsControlManifest = {
+            free: {},
+            paid: {}
+        };
+        this._chatControlDisposed = false;
+        this._restrictedChatParticipants = observableValue(this, Object.create(null));
+        this.restrictedChatParticipants = this._restrictedChatParticipants;
         this._hasUserSelectableModels = ChatContextKeys.languageModelsAreUserSelectable.bindTo(_contextKeyService);
         this._modelPickerUserPreferences = this._readModelPickerPreferences();
+        this._recentlyUsedModelIds = this._readRecentlyUsedModels();
+        this._initChatControlData();
         this._store.add(this._storageService.onDidChangeValue(
             StorageScope.PROFILE,
             CHAT_MODEL_PICKER_PREFERENCES_STORAGE_KEY,
             this._store
         )(() => this._onDidChangeModelPickerPreferences()));
-        this._store.add(this.onDidChangeLanguageModels(
-            () => this._hasUserSelectableModels.set(this._modelCache.size > 0 && ( Array.from(( this._modelCache.values())).some(model => model.isUserSelectable)))
-        ));
+        this._store.add(this.onDidChangeLanguageModels(() => {
+            this._hasUserSelectableModels.set(this._modelCache.size > 0 && ( Array.from(( this._modelCache.values())).some(model => model.isUserSelectable)));
+            this._refreshModelsControlManifest();
+        }));
         this._store.add(
             this._languageModelsConfigurationService.onDidChangeLanguageModelGroups(changedGroups => this._onDidChangeLanguageModelGroups(changedGroups))
         );
@@ -221,18 +274,18 @@ let LanguageModelsService = class LanguageModelsService {
                 for (const item of Iterable.wrap(extension.value)) {
                     if (( this._vendors.has(item.vendor))) {
                         extension.collector.error(( localize(
-                            6332,
+                            6883,
                             "The vendor '{0}' is already registered and cannot be registered twice",
                             item.vendor
                         )));
                         continue;
                     }
                     if (isFalsyOrWhitespace(item.vendor)) {
-                        extension.collector.error(( localize(6333, "The vendor field cannot be empty.")));
+                        extension.collector.error(( localize(6884, "The vendor field cannot be empty.")));
                         continue;
                     }
                     if (item.vendor.trim() !== item.vendor) {
-                        extension.collector.error(( localize(6334, "The vendor field cannot start or end with whitespace.")));
+                        extension.collector.error(( localize(6885, "The vendor field cannot start or end with whitespace.")));
                         continue;
                     }
                     addedVendors.push(item);
@@ -392,9 +445,12 @@ let LanguageModelsService = class LanguageModelsService {
         return model;
     }
     lookupLanguageModelByQualifiedName(referenceName) {
-        for (const model of ( this._modelCache.values())) {
+        for (const [identifier, model] of this._modelCache.entries()) {
             if (ILanguageModelChatMetadata.matchesQualifiedName(referenceName, model)) {
-                return model;
+                return {
+                    metadata: model,
+                    identifier
+                };
             }
         }
         return undefined;
@@ -674,18 +730,18 @@ let LanguageModelsService = class LanguageModelsService {
         try {
             await ( new Promise(resolve => {
                 const inputBox = disposables.add(this._quickInputService.createInputBox());
-                inputBox.title = ( localize(6335, "Group Name"));
-                inputBox.placeholder = ( localize(6336, "Enter a name for the group"));
+                inputBox.title = ( localize(6886, "Group Name"));
+                inputBox.placeholder = ( localize(6887, "Enter a name for the group"));
                 inputBox.value = providerGroupName;
                 inputBox.ignoreFocusOut = true;
                 disposables.add(inputBox.onDidChangeValue(value => {
                     if (!value) {
-                        inputBox.validationMessage = ( localize(6337, "Please enter a name"));
+                        inputBox.validationMessage = ( localize(6888, "Please enter a name"));
                         inputBox.severity = Severity$1.Error;
                         return;
                     }
                     if (!existing && ( languageModelProviderGroups.some(g => g.name === value))) {
-                        inputBox.validationMessage = ( localize(6338, "A language models group with this name already exists"));
+                        inputBox.validationMessage = ( localize(6889, "A language models group with this name already exists"));
                         inputBox.severity = Severity$1.Error;
                         return;
                     }
@@ -766,7 +822,7 @@ let LanguageModelsService = class LanguageModelsService {
                 quickPick.items = ( items.map(item => ({
                     label: item
                 })));
-                quickPick.placeholder = propertySchema.description ?? ( localize(6339, "Select value for {0}", property));
+                quickPick.placeholder = propertySchema.description ?? ( localize(6890, "Select value for {0}", property));
                 quickPick.canSelectMany = true;
                 quickPick.ignoreFocusOut = true;
                 disposables.add(quickPick.onDidAccept(() => {
@@ -788,7 +844,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(6340, "Enter value for {0}", property));
+                inputBox.placeholder = ( localize(6891, "Enter value for {0}", property));
                 inputBox.password = !!propertySchema.secret;
                 inputBox.ignoreFocusOut = true;
                 if (existing?.[property]) {
@@ -801,20 +857,20 @@ let LanguageModelsService = class LanguageModelsService {
                 }
                 disposables.add(inputBox.onDidChangeValue(value => {
                     if (!value && required) {
-                        inputBox.validationMessage = ( localize(6341, "Value is required"));
+                        inputBox.validationMessage = ( localize(6892, "Value is required"));
                         inputBox.severity = Severity$1.Error;
                         return;
                     }
                     if (propertySchema.type === "number" || propertySchema.type === "integer") {
                         if (isNaN(Number(value))) {
-                            inputBox.validationMessage = ( localize(6342, "Please enter a number"));
+                            inputBox.validationMessage = ( localize(6893, "Please enter a number"));
                             inputBox.severity = Severity$1.Error;
                             return;
                         }
                     }
                     if (propertySchema.type === "boolean") {
                         if (value !== "true" && value !== "false") {
-                            inputBox.validationMessage = ( localize(6343, "Please enter true or false"));
+                            inputBox.validationMessage = ( localize(6894, "Please enter true or false"));
                             inputBox.severity = Severity$1.Error;
                             return;
                         }
@@ -824,7 +880,7 @@ let LanguageModelsService = class LanguageModelsService {
                 }));
                 disposables.add(inputBox.onDidAccept(() => {
                     if (!inputBox.value && required) {
-                        inputBox.validationMessage = ( localize(6341, "Value is required"));
+                        inputBox.validationMessage = ( localize(6892, "Value is required"));
                         inputBox.severity = Severity$1.Error;
                         return;
                     }
@@ -963,11 +1019,176 @@ let LanguageModelsService = class LanguageModelsService {
         this._saveModelPickerPreferences();
         await this.addLanguageModelsProviderGroup(name, vendor, configuration);
     }
+    _readRecentlyUsedModels() {
+        return this._storageService.getObject(CHAT_MODEL_RECENTLY_USED_STORAGE_KEY, StorageScope.PROFILE, []);
+    }
+    _saveRecentlyUsedModels() {
+        this._storageService.store(
+            CHAT_MODEL_RECENTLY_USED_STORAGE_KEY,
+            this._recentlyUsedModelIds,
+            StorageScope.PROFILE,
+            StorageTarget.USER
+        );
+    }
+    getRecentlyUsedModelIds() {
+        return this._recentlyUsedModelIds.filter(id => ( this._modelCache.has(id)) && id !== "copilot/auto").slice(0, 4);
+    }
+    addToRecentlyUsedList(modelIdentifier) {
+        if (modelIdentifier === "copilot/auto") {
+            return;
+        }
+        const index = this._recentlyUsedModelIds.indexOf(modelIdentifier);
+        if (index !== -1) {
+            this._recentlyUsedModelIds.splice(index, 1);
+        }
+        this._recentlyUsedModelIds.unshift(modelIdentifier);
+        if (this._recentlyUsedModelIds.length > 20) {
+            this._recentlyUsedModelIds.length = 20;
+        }
+        this._saveRecentlyUsedModels();
+    }
+    clearRecentlyUsedList() {
+        this._recentlyUsedModelIds = [];
+        this._saveRecentlyUsedModels();
+    }
+    getModelsControlManifest() {
+        return this._modelsControlManifest;
+    }
+    _setModelsControlManifest(response) {
+        this._modelsControlRawResponse = response;
+        this._refreshModelsControlManifest();
+    }
+    _refreshModelsControlManifest() {
+        const response = this._modelsControlRawResponse;
+        const free = {};
+        const paid = {};
+        if (response?.free) {
+            const freeEntries = Array.isArray(response.free) ? response.free : ( Object.values(response.free));
+            for (const entry of freeEntries) {
+                if (!entry || !isObject(entry)) {
+                    continue;
+                }
+                free[entry.id] = {
+                    label: entry.label,
+                    featured: entry.featured,
+                    exists: this._modelExistsInCache(entry.id)
+                };
+            }
+        }
+        if (response?.paid) {
+            const paidEntries = Array.isArray(response.paid) ? response.paid : ( Object.values(response.paid));
+            for (const entry of paidEntries) {
+                if (!entry || !isObject(entry)) {
+                    continue;
+                }
+                paid[entry.id] = {
+                    label: entry.label,
+                    featured: entry.featured,
+                    minVSCodeVersion: entry.minVSCodeVersion,
+                    exists: this._modelExistsInCache(entry.id)
+                };
+            }
+        }
+        this._modelsControlManifest = {
+            free,
+            paid
+        };
+        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) {
+            return;
+        }
+        const raw = this._storageService.get(CHAT_PARTICIPANT_NAME_REGISTRY_STORAGE_KEY, StorageScope.APPLICATION);
+        try {
+            this._restrictedChatParticipants.set(JSON.parse(raw ?? "{}"), undefined);
+        } catch (err) {
+            this._storageService.remove(CHAT_PARTICIPANT_NAME_REGISTRY_STORAGE_KEY, StorageScope.APPLICATION);
+        }
+        const rawModels = this._storageService.get(CHAT_MODELS_CONTROL_STORAGE_KEY, StorageScope.APPLICATION);
+        try {
+            const models = JSON.parse(rawModels ?? "{}");
+            if (isObject(models)) {
+                this._setModelsControlManifest(models);
+            }
+        } catch (err) {
+            this._storageService.remove(CHAT_MODELS_CONTROL_STORAGE_KEY, StorageScope.APPLICATION);
+        }
+        this._refreshChatControlData();
+    }
+    _refreshChatControlData() {
+        if (this._chatControlDisposed) {
+            return;
+        }
+        this._fetchChatControlData().catch(err => this._logService.warn("Failed to fetch chat control data", err)).then(() => timeout(5 * 60 * 1000)).then(() => this._refreshChatControlData());
+    }
+    async _fetchChatControlData() {
+        this._logService.trace("[LM] Fetching chat control data from", this._chatControlUrl);
+        let context;
+        try {
+            context = await this._requestService.request({
+                type: "GET",
+                url: this._chatControlUrl
+            }, CancellationToken.None);
+        } catch (err) {
+            this._logService.warn("[LM] Failed to request chat control data", getErrorMessage(err));
+            return;
+        }
+        if (context.res.statusCode !== 200) {
+            this._logService.warn(
+                `[LM] Chat control data request failed with status ${context.res.statusCode}`
+            );
+            return;
+        }
+        let result;
+        try {
+            result = await asJson(context);
+        } catch (err) {
+            this._logService.warn("[LM] Failed to parse chat control response", getErrorMessage(err));
+            return;
+        }
+        this._logService.trace("[LM] Received chat control response", result ? ( Object.keys(result)) : "null");
+        if (!result || result.version !== 1) {
+            this._logService.warn("[LM] Unexpected chat control response version", result?.version);
+            return;
+        }
+        const registry = result.restrictedChatParticipants;
+        this._restrictedChatParticipants.set(registry, undefined);
+        this._storageService.store(
+            CHAT_PARTICIPANT_NAME_REGISTRY_STORAGE_KEY,
+            JSON.stringify(registry),
+            StorageScope.APPLICATION,
+            StorageTarget.MACHINE
+        );
+        if (result.models) {
+            this._logService.trace("[LM] Updating models control manifest", {
+                freeCount: ( Object.keys(result.models.free ?? {})).length,
+                paidCount: ( Object.keys(result.models.paid ?? {})).length
+            });
+            this._setModelsControlManifest(result.models);
+            this._storageService.store(
+                CHAT_MODELS_CONTROL_STORAGE_KEY,
+                JSON.stringify(result.models),
+                StorageScope.APPLICATION,
+                StorageTarget.MACHINE
+            );
+        }
+    }
     dispose() {
+        this._chatControlDisposed = true;
         this._store.dispose();
         this._providers.clear();
     }
 };
-LanguageModelsService = LanguageModelsService_1 = ( __decorate([( __param(0, IExtensionService)), ( __param(1, ILogService)), ( __param(2, IStorageService)), ( __param(3, IContextKeyService)), ( __param(4, ILanguageModelsConfigurationService)), ( __param(5, IQuickInputService)), ( __param(6, ISecretStorageService))], LanguageModelsService));
+LanguageModelsService = LanguageModelsService_1 = ( __decorate([( __param(0, IExtensionService)), ( __param(1, ILogService)), ( __param(2, IStorageService)), ( __param(3, IContextKeyService)), ( __param(4, ILanguageModelsConfigurationService)), ( __param(5, IQuickInputService)), ( __param(6, ISecretStorageService)), ( __param(7, IProductService)), ( __param(8, IRequestService))], LanguageModelsService));
 
-export { ChatImageMimeType, ChatMessageRole, ILanguageModelChatMetadata, ImageDetailLevel, LanguageModelPartAudience, LanguageModelsService, isILanguageModelChatSelector, languageModelChatProviderExtensionPoint };
+export { ChatImageMimeType, ChatMessageRole, ILanguageModelChatMetadata, ImageDetailLevel, LanguageModelPartAudience, LanguageModelsService, getTextResponseFromStream, isILanguageModelChatSelector, languageModelChatProviderExtensionPoint };

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

@@ -2,8 +2,9 @@ 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, ILanguageModelsGroup, ILanguageModelChatSelector, ILanguageModelChatProvider, IUserFriendlyLanguageModel, IChatMessage, ILanguageModelChatResponse } from "./languageModels.js";
+import { ILanguageModelProviderDescriptor, ILanguageModelChatMetadata, ILanguageModelChatMetadataAndIdentifier, ILanguageModelsGroup, ILanguageModelChatSelector, ILanguageModelChatProvider, IUserFriendlyLanguageModel, IChatMessage, 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 {
@@ -17,7 +18,7 @@ export interface ILanguageModelsService {
     /**
     * Find a model by its qualified name. The qualified name is what is used in prompt and agent files and is in the format "Model Name (Vendor)".
     */
-    lookupLanguageModelByQualifiedName(qualifiedName: string): ILanguageModelChatMetadata | undefined;
+    lookupLanguageModelByQualifiedName(qualifiedName: string): ILanguageModelChatMetadataAndIdentifier | undefined;
     getLanguageModelGroups(vendor: string): ILanguageModelsGroup[];
     /**
     * Given a selector, returns a list of model identifiers
@@ -34,4 +35,33 @@ export interface ILanguageModelsService {
     removeLanguageModelsProviderGroup(vendorId: string, providerGroupName: string): Promise<void>;
     configureLanguageModelsProviderGroup(vendorId: string, name?: string): Promise<void>;
     migrateLanguageModelsProviderGroup(languageModelsProviderGroup: ILanguageModelsProviderGroup): Promise<void>;
+    /**
+    * Returns the most recently used model identifiers, ordered by most-recent-first.
+    * @param maxCount Maximum number of entries to return (default 7).
+    */
+    getRecentlyUsedModelIds(): string[];
+    /**
+    * Records that a model was used, updating the recently used list.
+    */
+    addToRecentlyUsedList(modelIdentifier: string): void;
+    /**
+    * Clears the recently used model list.
+    */
+    clearRecentlyUsedList(): void;
+    /**
+    * Returns the models from the control manifest,
+    * separated into free and paid tiers.
+    */
+    getModelsControlManifest(): IModelsControlManifest;
+    /**
+    * Fires when models control manifest changes.
+    */
+    readonly onDidChangeModelsControlManifest: Event<IModelsControlManifest>;
+    /**
+    * Observable map of restricted chat participant names to allowed extension publisher/IDs.
+    * Fetched from the chat control manifest.
+    */
+    readonly restrictedChatParticipants: IObservable<{
+        [name: string]: string[];
+    }>;
 }

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

@@ -10,7 +10,7 @@ import { EditSuggestionId } from "../../../../../editor/common/textModelEditSour
 import { ILogService } from "../../../../../platform/log/common/log.service.js";
 import { ICellEditOperation } from "../../../notebook/common/notebookCommon.js";
 import { ChatRequestToolReferenceEntry, IChatRequestVariableEntry } from "../attachments/chatVariableEntries.js";
-import { ChatAgentVoteDirection, ChatAgentVoteDownReason, ChatRequestQueueKind, IChatAgentMarkdownContentWithVulnerability, IChatClearToPreviousToolInvocation, IChatCodeCitation, IChatCommandButton, IChatConfirmation, IChatContentInlineReference, IChatContentReference, IChatDisabledClaudeHooksPart, IChatEditingSessionAction, IChatElicitationRequest, IChatElicitationRequestSerialized, IChatExtensionsContent, IChatFollowup, IChatHookPart, IChatLocationData, IChatMarkdownContent, IChatMcpServersStarting, IChatMcpServersStartingSerialized, IChatMultiDiffData, IChatMultiDiffDataSerialized, IChatNotebookEdit, IChatProgress, IChatProgressMessage, IChatPullRequestContent, IChatQuestionCarousel, IChatResponseCodeblockUriPart, IChatResponseProgressFileTreeData, IChatSendRequestOptions, IChatSessionContext, IChatSessionTiming, IChatTask, IChatTaskSerialized, IChatTextEdit, IChatThinkingPart, IChatToolInvocation, IChatToolInvocationSerialized, IChatTreeData, IChatUndoStop, IChatUsedContext, IChatWarningMessage, IChatWorkspaceEdit, ResponseModelState } from "../chatService/chatService.js";
+import { ChatAgentVoteDirection, ChatAgentVoteDownReason, ChatRequestQueueKind, IChatAgentMarkdownContentWithVulnerability, IChatClearToPreviousToolInvocation, IChatCodeCitation, IChatCommandButton, IChatConfirmation, IChatContentInlineReference, IChatContentReference, IChatDisabledClaudeHooksPart, IChatEditingSessionAction, IChatElicitationRequest, IChatElicitationRequestSerialized, IChatExternalToolInvocationUpdate, IChatExtensionsContent, IChatFollowup, IChatHookPart, IChatLocationData, IChatMarkdownContent, IChatMcpServersStarting, IChatMcpServersStartingSerialized, IChatMultiDiffData, IChatMultiDiffDataSerialized, IChatNotebookEdit, IChatProgress, IChatProgressMessage, IChatPullRequestContent, IChatQuestionCarousel, IChatResponseCodeblockUriPart, IChatResponseProgressFileTreeData, IChatSendRequestOptions, IChatSessionContext, IChatSessionTiming, IChatTask, IChatTaskSerialized, IChatTextEdit, IChatThinkingPart, IChatToolInvocation, IChatToolInvocationSerialized, IChatTreeData, IChatUndoStop, IChatUsage, IChatUsedContext, IChatWarningMessage, IChatWorkspaceEdit, ResponseModelState } from "../chatService/chatService.js";
 import { IChatService } from "../chatService/chatService.service.js";
 import { ChatAgentLocation, ChatModeKind } from "../constants.js";
 import { IChatEditingSession } from "../editing/chatEditingService.js";
@@ -183,13 +183,15 @@ export interface IChatResponseModel {
     readonly voteDownReason: ChatAgentVoteDownReason | undefined;
     readonly followups?: IChatFollowup[] | undefined;
     readonly result?: IChatAgentResult;
+    readonly usage?: IChatUsage;
     readonly codeBlockInfos: ICodeBlockInfo[] | undefined;
     initializeCodeBlockInfos(codeBlockInfo: ICodeBlockInfo[]): void;
     addUndoStop(undoStop: IChatUndoStop): void;
     setVote(vote: ChatAgentVoteDirection): void;
     setVoteDownReason(reason: ChatAgentVoteDownReason | undefined): void;
+    setUsage(usage: IChatUsage): void;
     setEditApplied(edit: IChatTextEditGroup, editCount: number): boolean;
-    updateContent(progress: IChatProgressResponseContent | IChatTextEdit | IChatNotebookEdit | IChatTask, quiet?: boolean): void;
+    updateContent(progress: IChatProgressResponseContent | IChatTextEdit | IChatNotebookEdit | IChatTask | IChatExternalToolInvocationUpdate, quiet?: boolean): void;
     /**
      * Adopts any partially-undo {@link response} as the {@link entireResponse}.
      * Only valid when {@link isComplete}. This is needed because otherwise an
@@ -300,10 +302,11 @@ export declare class Response extends AbstractResponse implements IDisposable {
     dispose(): void;
     clear(): void;
     clearToPreviousToolInvocation(message?: string): void;
-    updateContent(progress: IChatProgressResponseContent | IChatTextEdit | IChatNotebookEdit | IChatTask, quiet?: boolean): void;
+    updateContent(progress: IChatProgressResponseContent | IChatTextEdit | IChatNotebookEdit | IChatTask | IChatExternalToolInvocationUpdate, quiet?: boolean): void;
     addCitation(citation: IChatCodeCitation): void;
     private _mergeOrPushTextEditGroup;
     private _mergeOrPushNotebookEditGroup;
+    private _handleExternalToolInvocationUpdate;
     protected _updateRepr(quiet?: boolean): void;
 }
 export interface IChatResponseModelParameters {
@@ -348,6 +351,7 @@ export declare class ChatResponseModel extends Disposable implements IChatRespon
     private _vote?;
     private _voteDownReason?;
     private _result?;
+    private _usage?;
     private _shouldBeRemovedOnSend;
     readonly isCompleteAddedRequest: boolean;
     private readonly _shouldBeBlocked;
@@ -372,6 +376,7 @@ export declare class ChatResponseModel extends Disposable implements IChatRespon
     private _finalizedResponse?;
     get entireResponse(): IResponse;
     get result(): IChatAgentResult | undefined;
+    get usage(): IChatUsage | undefined;
     get username(): string;
     private _followups?;
     get agent(): IChatAgentData | undefined;
@@ -403,7 +408,7 @@ export declare class ChatResponseModel extends Disposable implements IChatRespon
     /**
      * Apply a progress update to the actual response content.
      */
-    updateContent(responsePart: IChatProgressResponseContent | IChatTextEdit | IChatNotebookEdit, quiet?: boolean): void;
+    updateContent(responsePart: IChatProgressResponseContent | IChatTextEdit | IChatNotebookEdit | IChatExternalToolInvocationUpdate, quiet?: boolean): void;
     /**
      * Adds an undo stop at the current position in the stream.
      */
@@ -415,6 +420,7 @@ export declare class ChatResponseModel extends Disposable implements IChatRespon
     applyCodeCitation(progress: IChatCodeCitation): void;
     setAgent(agent: IChatAgentData, slashCommand?: IChatAgentCommand): void;
     setResult(result: IChatAgentResult): void;
+    setUsage(usage: IChatUsage): void;
     complete(): void;
     cancel(): void;
     setFollowups(followups: IChatFollowup[] | undefined): void;
@@ -471,6 +477,7 @@ export interface IChatModel extends IDisposable {
     toExport(): IExportableChatData;
     toJSON(): ISerializableChatData;
     readonly contributedChatSession: IChatSessionContext | undefined;
+    setContributedChatSession(session: IChatSessionContext | undefined): void;
     readonly repoData: IExportableRepoData | undefined;
     setRepoData(data: IExportableRepoData | undefined): void;
     readonly onDidChangePendingRequests: Event<void>;
@@ -863,7 +870,6 @@ export declare class ChatModel extends Disposable implements IChatModel {
         canUseTools: boolean;
         inputState?: ISerializableChatModelInputState;
         resource?: URI;
-        sessionId?: string;
         disableBackgroundKeepAlive?: boolean;
     }, logService: ILogService, chatAgentService: IChatAgentService, chatEditingService: IChatEditingService, chatService: IChatService);
     startEditingSession(isGlobalEditingSession?: boolean, transferFromSession?: IChatEditingSession): void;