@codingame/monaco-vscode-chat-service-override 25.1.2 → 26.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/contextContrib/chatContextService.js

@@ -19,26 +19,51 @@ let ChatContextService = class ChatContextService extends Disposable {
         this._registeredPickers = this._register(( new DisposableMap()));
         this._lastResourceContext = ( new Map());
     }
+    setExecuteCommandCallback(callback) {
+        this._executeCommandCallback = callback;
+    }
+    async executeChatContextItemCommand(handle) {
+        if (!this._executeCommandCallback) {
+            return;
+        }
+        await this._executeCommandCallback(handle);
+    }
     setChatContextProvider(id, picker) {
-        const providerEntry = this._providers.get(id) ?? { picker: undefined };
+        const providerEntry = this._providers.get(id) ?? {};
         providerEntry.picker = picker;
         this._providers.set(id, providerEntry);
         this._registerWithPickService(id);
     }
     _registerWithPickService(id) {
         const providerEntry = this._providers.get(id);
-        if (!providerEntry || !providerEntry.picker || !providerEntry.chatContextProvider) {
+        if (!providerEntry || !providerEntry.picker || !providerEntry.explicitProvider) {
             return;
         }
-        const title = `${providerEntry.picker.title.replace(/\.+$/, '')}...`;
-        this._registeredPickers.set(id, this._contextPickService.registerChatContextItem(this._asPicker(title, providerEntry.picker.icon, id)));
+        const title = `${providerEntry.picker.title.replace(/\.+$/, "")}...`;
+        this._registeredPickers.set(
+            id,
+            this._contextPickService.registerChatContextItem(this._asPicker(title, providerEntry.picker.icon, id))
+        );
+    }
+    registerChatWorkspaceContextProvider(id, provider) {
+        const providerEntry = this._providers.get(id) ?? {};
+        providerEntry.workspaceProvider = provider;
+        this._providers.set(id, providerEntry);
     }
-    registerChatContextProvider(id, selector, provider) {
-        const providerEntry = this._providers.get(id) ?? { picker: undefined };
-        providerEntry.chatContextProvider = { selector, provider };
+    registerChatExplicitContextProvider(id, provider) {
+        const providerEntry = this._providers.get(id) ?? {};
+        providerEntry.explicitProvider = provider;
         this._providers.set(id, providerEntry);
         this._registerWithPickService(id);
     }
+    registerChatResourceContextProvider(id, selector, provider) {
+        const providerEntry = this._providers.get(id) ?? {};
+        providerEntry.resourceProvider = {
+            selector,
+            provider
+        };
+        this._providers.set(id, providerEntry);
+    }
     unregisterChatContextProvider(id) {
         this._providers.delete(id);
         this._registeredPickers.deleteAndDispose(id);
@@ -58,29 +83,40 @@ let ChatContextService = class ChatContextService extends Disposable {
                     name: item.label,
                     modelDescription: item.modelDescription,
                     id: item.label,
-                    kind: 'workspace'
+                    kind: "workspace"
                 });
             }
         }
         return items;
     }
-    async contextForResource(uri) {
-        return this._contextForResource(uri, false);
+    async contextForResource(uri, language) {
+        return this._contextForResource(uri, false, language);
     }
-    async _contextForResource(uri, withValue) {
+    async _contextForResource(uri, withValue, language) {
         const scoredProviders = [];
         for (const providerEntry of ( this._providers.values())) {
-            if (!providerEntry.chatContextProvider?.provider.provideChatContextForResource || (providerEntry.chatContextProvider.selector === undefined)) {
+            if (!providerEntry.resourceProvider) {
                 continue;
             }
-            const matchScore = score(providerEntry.chatContextProvider.selector, uri, '', true, undefined, undefined);
-            scoredProviders.push({ score: matchScore, provider: providerEntry.chatContextProvider.provider });
+            const matchScore = score(
+                providerEntry.resourceProvider.selector,
+                uri,
+                language ?? "",
+                true,
+                undefined,
+                undefined
+            );
+            scoredProviders.push({
+                score: matchScore,
+                provider: providerEntry.resourceProvider.provider
+            });
         }
         scoredProviders.sort((a, b) => b.score - a.score);
         if (scoredProviders.length === 0 || scoredProviders[0].score <= 0) {
             return;
         }
-        const context = (await scoredProviders[0].provider.provideChatContextForResource(uri, withValue, CancellationToken.None));
+        const provider = scoredProviders[0].provider;
+        const context = (await provider.provideChatContext(uri, withValue, CancellationToken.None));
         if (!context) {
             return;
         }
@@ -89,28 +125,35 @@ let ChatContextService = class ChatContextService extends Disposable {
             name: context.label,
             icon: context.icon,
             uri: uri,
-            modelDescription: context.modelDescription
+            modelDescription: context.modelDescription,
+            tooltip: context.tooltip,
+            commandId: context.command?.id,
+            handle: context.handle
         };
         this._lastResourceContext.clear();
-        this._lastResourceContext.set(contextValue, { originalItem: context, provider: scoredProviders[0].provider });
+        this._lastResourceContext.set(contextValue, {
+            originalItem: context,
+            provider
+        });
         return contextValue;
     }
-    async resolveChatContext(context) {
+    async resolveChatContext(context, language) {
         if (context.value !== undefined) {
             return context;
         }
         const item = this._lastResourceContext.get(context);
         if (!item) {
-            const resolved = await this._contextForResource(context.uri, true);
+            const resolved = await this._contextForResource(context.uri, true, language);
             context.value = resolved?.value;
             context.modelDescription = resolved?.modelDescription;
+            context.tooltip = resolved?.tooltip;
             return context;
-        }
-        else if (item.provider.resolveChatContext) {
+        } else {
             const resolved = await item.provider.resolveChatContext(item.originalItem, CancellationToken.None);
             if (resolved) {
                 context.value = resolved.value;
                 context.modelDescription = resolved.modelDescription;
+                context.tooltip = resolved.tooltip;
                 return context;
             }
         }
@@ -120,17 +163,17 @@ let ChatContextService = class ChatContextService extends Disposable {
         const asPicker = () => {
             let providerEntry = this._providers.get(id);
             if (!providerEntry) {
-                throw ( new Error('No chat context provider registered'));
+                throw ( new Error("No chat context provider registered"));
             }
             const picks = async () => {
-                if (providerEntry && !providerEntry.chatContextProvider) {
+                if (providerEntry && !providerEntry.explicitProvider) {
                     await this._extensionService.activateByEvent(`onChatContextProvider:${id}`);
                     providerEntry = this._providers.get(id);
-                    if (!providerEntry?.chatContextProvider) {
+                    if (!providerEntry?.explicitProvider) {
                         return [];
                     }
                 }
-                const results = await providerEntry?.chatContextProvider.provider.provideChatContext({}, CancellationToken.None);
+                const results = await providerEntry?.explicitProvider.provideChatContext(CancellationToken.None);
                 return results || [];
             };
             return {
@@ -140,11 +183,11 @@ let ChatContextService = class ChatContextService extends Disposable {
                         iconClass: ThemeIcon.asClassName(item.icon),
                         asAttachment: async () => {
                             let contextValue = item;
-                            if ((contextValue.value === undefined) && providerEntry?.chatContextProvider?.provider.resolveChatContext) {
-                                contextValue = await providerEntry.chatContextProvider.provider.resolveChatContext(item, CancellationToken.None);
+                            if ((contextValue.value === undefined) && providerEntry?.explicitProvider) {
+                                contextValue = await providerEntry.explicitProvider.resolveChatContext(item, CancellationToken.None);
                             }
                             return {
-                                kind: 'generic',
+                                kind: "generic",
                                 id: contextValue.label,
                                 name: contextValue.label,
                                 icon: contextValue.icon,
@@ -158,16 +201,13 @@ let ChatContextService = class ChatContextService extends Disposable {
         };
         const picker = {
             asPicker,
-            type: 'pickerPick',
+            type: "pickerPick",
             label: title,
             icon
         };
         return picker;
     }
 };
-ChatContextService = ( __decorate([
-    ( __param(0, IChatContextPickService)),
-    ( __param(1, IExtensionService))
-], ChatContextService));
+ChatContextService = ( __decorate([( __param(0, IChatContextPickService)), ( __param(1, IExtensionService))], ChatContextService));
 
 export { ChatContextService };

package/vscode/src/vs/workbench/contrib/chat/browser/languageModelsConfigurationService.d.ts

@@ -0,0 +1,47 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { Mutable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/types";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { IUriIdentityService } from "@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
+import { IEditorGroupsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service";
+import { ITextEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/textfile/common/textEditorService.service";
+import { IUserDataProfileService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service";
+import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
+import { ITextModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service";
+import { ITextFileService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/textfile/common/textfiles.service";
+import { ConfigureLanguageModelsOptions, ILanguageModelsProviderGroup } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelsConfiguration";
+import { ILanguageModelsConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelsConfiguration.service";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { ILanguageModelsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service";
+type LanguageModelsProviderGroups = Mutable<ILanguageModelsProviderGroup>[];
+export declare class LanguageModelsConfigurationService extends Disposable implements ILanguageModelsConfigurationService {
+    private readonly fileService;
+    private readonly textFileService;
+    private readonly textModelService;
+    private readonly editorGroupsService;
+    private readonly textEditorService;
+    _serviceBrand: undefined;
+    private readonly modelsConfigurationFile;
+    get configurationFile(): URI;
+    private readonly _onDidChangeLanguageModelGroups;
+    readonly onDidChangeLanguageModelGroups: Event<readonly ILanguageModelsProviderGroup[]>;
+    private languageModelsProviderGroups;
+    constructor(fileService: IFileService, textFileService: ITextFileService, textModelService: ITextModelService, editorGroupsService: IEditorGroupsService, textEditorService: ITextEditorService, userDataProfileService: IUserDataProfileService, uriIdentityService: IUriIdentityService);
+    private setLanguageModelsConfiguration;
+    private updateLanguageModelsConfiguration;
+    getLanguageModelsProviderGroups(): readonly ILanguageModelsProviderGroup[];
+    addLanguageModelsProviderGroup(toAdd: ILanguageModelsProviderGroup): Promise<ILanguageModelsProviderGroup>;
+    updateLanguageModelsProviderGroup(from: ILanguageModelsProviderGroup, to: ILanguageModelsProviderGroup): Promise<ILanguageModelsProviderGroup>;
+    removeLanguageModelsProviderGroup(toRemove: ILanguageModelsProviderGroup): Promise<void>;
+    configureLanguageModels(options?: ConfigureLanguageModelsOptions): Promise<void>;
+    private withLanguageModelsProviderGroups;
+}
+export declare function parseLanguageModelsProviderGroups(model: ITextModel): LanguageModelsProviderGroups;
+export declare class ChatLanguageModelsDataContribution extends Disposable implements IWorkbenchContribution {
+    private readonly languageModelsService;
+    static readonly ID = "workbench.contrib.chatLanguageModelsData";
+    constructor(languageModelsService: ILanguageModelsService, languageModelsConfigurationService: ILanguageModelsConfigurationService);
+    private updateSchema;
+}
+export {};

package/vscode/src/vs/workbench/contrib/chat/browser/languageModelsConfigurationService.js

@@ -0,0 +1,333 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
+import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
+import { ITextEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/textfile/common/textEditorService.service';
+import { IUserDataProfileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/userDataProfile/common/userDataProfile.service';
+import { equals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
+import { visit } from '@codingame/monaco-vscode-api/vscode/vs/base/common/json';
+import { ITextModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service';
+import { ITextFileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/textfile/common/textfiles.service';
+import { getCodeEditor } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser';
+import { SnippetController2 } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/snippet/browser/snippetController2';
+import { ILanguageModelsConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelsConfiguration.service';
+import { Extensions } from '@codingame/monaco-vscode-api/vscode/vs/platform/jsonschemas/common/jsonContributionRegistry';
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+import { ILanguageModelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service';
+
+let LanguageModelsConfigurationService = class LanguageModelsConfigurationService extends Disposable {
+    get configurationFile() {
+        return this.modelsConfigurationFile;
+    }
+    constructor(
+        fileService,
+        textFileService,
+        textModelService,
+        editorGroupsService,
+        textEditorService,
+        userDataProfileService,
+        uriIdentityService
+    ) {
+        super();
+        this.fileService = fileService;
+        this.textFileService = textFileService;
+        this.textModelService = textModelService;
+        this.editorGroupsService = editorGroupsService;
+        this.textEditorService = textEditorService;
+        this._onDidChangeLanguageModelGroups = ( new Emitter());
+        this.onDidChangeLanguageModelGroups = this._onDidChangeLanguageModelGroups.event;
+        this.languageModelsProviderGroups = [];
+        this.modelsConfigurationFile = uriIdentityService.extUri.joinPath(userDataProfileService.currentProfile.location, "chatLanguageModels.json");
+        this.updateLanguageModelsConfiguration();
+        this._register(fileService.watch(this.modelsConfigurationFile));
+        this._register(fileService.onDidFilesChange(e => {
+            if (e.contains(this.modelsConfigurationFile)) {
+                this.updateLanguageModelsConfiguration();
+            }
+        }));
+    }
+    setLanguageModelsConfiguration(languageModelsConfiguration) {
+        const changedGroups = [];
+        const oldGroupMap = ( new Map(( this.languageModelsProviderGroups.map(g => [`${g.vendor}:${g.name}`, g]))));
+        const newGroupMap = ( new Map(( languageModelsConfiguration.map(g => [`${g.vendor}:${g.name}`, g]))));
+        for (const [key, newGroup] of newGroupMap) {
+            const oldGroup = oldGroupMap.get(key);
+            if (!oldGroup || !equals(oldGroup, newGroup)) {
+                changedGroups.push(newGroup);
+            }
+        }
+        for (const [key, oldGroup] of oldGroupMap) {
+            if (!( newGroupMap.has(key))) {
+                changedGroups.push(oldGroup);
+            }
+        }
+        this.languageModelsProviderGroups = languageModelsConfiguration;
+        if (changedGroups.length > 0) {
+            this._onDidChangeLanguageModelGroups.fire(changedGroups);
+        }
+    }
+    async updateLanguageModelsConfiguration() {
+        const languageModelsProviderGroups = await this.withLanguageModelsProviderGroups();
+        this.setLanguageModelsConfiguration(languageModelsProviderGroups);
+    }
+    getLanguageModelsProviderGroups() {
+        return this.languageModelsProviderGroups;
+    }
+    async addLanguageModelsProviderGroup(toAdd) {
+        await this.withLanguageModelsProviderGroups(async languageModelsProviderGroups => {
+            if (( languageModelsProviderGroups.some((
+                {
+                    name,
+                    vendor
+                }
+            ) => name === toAdd.name && vendor === toAdd.vendor))) {
+                throw ( new Error(
+                    `Language model group with name ${toAdd.name} already exists for vendor ${toAdd.vendor}`
+                ));
+            }
+            languageModelsProviderGroups.push(toAdd);
+            return languageModelsProviderGroups;
+        });
+        await this.updateLanguageModelsConfiguration();
+        const result = this.getLanguageModelsProviderGroups().find(group => group.name === toAdd.name && group.vendor === toAdd.vendor);
+        if (!result) {
+            throw ( new Error(
+                `Language model group with name ${toAdd.name} not found for vendor ${toAdd.vendor}`
+            ));
+        }
+        return result;
+    }
+    async updateLanguageModelsProviderGroup(from, to) {
+        await this.withLanguageModelsProviderGroups(async languageModelsProviderGroups => {
+            const result = [];
+            for (const group of languageModelsProviderGroups) {
+                if (group.name === from.name && group.vendor === from.vendor) {
+                    result.push(to);
+                } else {
+                    result.push(group);
+                }
+            }
+            return result;
+        });
+        await this.updateLanguageModelsConfiguration();
+        const result = this.getLanguageModelsProviderGroups().find(group => group.name === to.name && group.vendor === to.vendor);
+        if (!result) {
+            throw ( new Error(
+                `Language model group with name ${to.name} not found for vendor ${to.vendor}`
+            ));
+        }
+        return result;
+    }
+    async removeLanguageModelsProviderGroup(toRemove) {
+        await this.withLanguageModelsProviderGroups(async languageModelsProviderGroups => {
+            const result = [];
+            for (const group of languageModelsProviderGroups) {
+                if (group.name === toRemove.name && group.vendor === toRemove.vendor) {
+                    continue;
+                }
+                result.push(group);
+            }
+            return result;
+        });
+        await this.updateLanguageModelsConfiguration();
+    }
+    async configureLanguageModels(options) {
+        const editor = await this.editorGroupsService.activeGroup.openEditor(this.textEditorService.createTextEditor({
+            resource: this.modelsConfigurationFile
+        }));
+        if (!editor || !options?.group) {
+            return;
+        }
+        const codeEditor = getCodeEditor(editor.getControl());
+        if (!codeEditor) {
+            return;
+        }
+        if (!options.group.range) {
+            return;
+        }
+        if (options.snippet) {
+            const model = codeEditor.getModel();
+            if (!model) {
+                return;
+            }
+            const lastPropertyLine = options.group.range.endLineNumber - 1;
+            const lastPropertyLineLength = model.getLineLength(lastPropertyLine);
+            const insertPosition = {
+                lineNumber: lastPropertyLine,
+                column: lastPropertyLineLength + 1
+            };
+            codeEditor.setPosition(insertPosition);
+            codeEditor.revealPositionNearTop(insertPosition);
+            codeEditor.focus();
+            SnippetController2.get(codeEditor)?.insert(",\n" + options.snippet);
+        } else {
+            const position = {
+                lineNumber: options.group.range.startLineNumber,
+                column: options.group.range.startColumn
+            };
+            codeEditor.setPosition(position);
+            codeEditor.revealPositionNearTop(position);
+            codeEditor.focus();
+        }
+    }
+    async withLanguageModelsProviderGroups(update) {
+        const exists = await this.fileService.exists(this.modelsConfigurationFile);
+        if (!exists) {
+            await this.fileService.writeFile(
+                this.modelsConfigurationFile,
+                VSBuffer.fromString(JSON.stringify([], undefined, "\t"))
+            );
+        }
+        const ref = await this.textModelService.createModelReference(this.modelsConfigurationFile);
+        const model = ref.object.textEditorModel;
+        try {
+            const languageModelsProviderGroups = parseLanguageModelsProviderGroups(model);
+            if (!update) {
+                return languageModelsProviderGroups;
+            }
+            const updatedLanguageModelsProviderGroups = await update(languageModelsProviderGroups);
+            for (const group of updatedLanguageModelsProviderGroups) {
+                delete group.range;
+            }
+            model.setValue(JSON.stringify(updatedLanguageModelsProviderGroups, undefined, "\t"));
+            await this.textFileService.save(this.modelsConfigurationFile);
+            return updatedLanguageModelsProviderGroups;
+        } finally {
+            ref.dispose();
+        }
+    }
+};
+LanguageModelsConfigurationService = ( __decorate([( __param(0, IFileService)), ( __param(1, ITextFileService)), ( __param(2, ITextModelService)), ( __param(3, IEditorGroupsService)), ( __param(4, ITextEditorService)), ( __param(5, IUserDataProfileService)), ( __param(6, IUriIdentityService))], LanguageModelsConfigurationService));
+function parseLanguageModelsProviderGroups(model) {
+    const configuration = [];
+    let currentProperty = null;
+    let currentParent = configuration;
+    const previousParents = [];
+    function onValue(value, offset, length) {
+        if (Array.isArray(currentParent)) {
+            currentParent.push(value);
+        } else if (currentProperty !== null) {
+            currentParent[currentProperty] = value;
+        }
+    }
+    const visitor = {
+        onObjectBegin: (offset, length) => {
+            const object = {};
+            if (previousParents.length === 1 && Array.isArray(currentParent)) {
+                const start = model.getPositionAt(offset);
+                const end = model.getPositionAt(offset + length);
+                object.range = {
+                    startLineNumber: start.lineNumber,
+                    startColumn: start.column,
+                    endLineNumber: end.lineNumber,
+                    endColumn: end.column
+                };
+            }
+            onValue(object);
+            previousParents.push(currentParent);
+            currentParent = object;
+            currentProperty = null;
+        },
+        onObjectProperty: (name, offset, length) => {
+            currentProperty = name;
+        },
+        onObjectEnd: (offset, length) => {
+            const parent = currentParent;
+            if (parent.range) {
+                const end = model.getPositionAt(offset + length);
+                parent.range = {
+                    startLineNumber: parent.range.startLineNumber,
+                    startColumn: parent.range.startColumn,
+                    endLineNumber: end.lineNumber,
+                    endColumn: end.column
+                };
+            }
+            if (parent._parentConfigurationRange) {
+                const end = model.getPositionAt(offset + length);
+                parent._parentConfigurationRange.endLineNumber = end.lineNumber;
+                parent._parentConfigurationRange.endColumn = end.column;
+                delete parent._parentConfigurationRange;
+            }
+            currentParent = previousParents.pop();
+        },
+        onArrayBegin: (offset, length) => {
+            if (currentParent === configuration && previousParents.length === 0) {
+                previousParents.push(currentParent);
+                currentProperty = null;
+                return;
+            }
+            const array = [];
+            onValue(array);
+            previousParents.push(currentParent);
+            currentParent = array;
+            currentProperty = null;
+        },
+        onArrayEnd: (offset, length) => {
+            const parent = currentParent;
+            if (parent._parentConfigurationRange) {
+                const end = model.getPositionAt(offset + length);
+                parent._parentConfigurationRange.endLineNumber = end.lineNumber;
+                parent._parentConfigurationRange.endColumn = end.column;
+                delete parent._parentConfigurationRange;
+            }
+            currentParent = previousParents.pop();
+        },
+        onLiteralValue: (value, offset, length) => {
+            onValue(value);
+        }
+    };
+    visit(model.getValue(), visitor);
+    return configuration;
+}
+const languageModelsSchemaId = "vscode://schemas/language-models";
+let ChatLanguageModelsDataContribution = class ChatLanguageModelsDataContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.chatLanguageModelsData";
+    }
+    constructor(languageModelsService, languageModelsConfigurationService) {
+        super();
+        this.languageModelsService = languageModelsService;
+        const registry = ( Registry.as(Extensions.JSONContribution));
+        this._register(registry.registerSchemaAssociation(languageModelsSchemaId, ( languageModelsConfigurationService.configurationFile.toString())));
+        this.updateSchema(registry);
+        this._register(
+            this.languageModelsService.onDidChangeLanguageModels(() => this.updateSchema(registry))
+        );
+    }
+    updateSchema(registry) {
+        const vendors = this.languageModelsService.getVendors();
+        const schema = {
+            type: "array",
+            items: {
+                properties: {
+                    vendor: {
+                        type: "string",
+                        enum: ( vendors.map(v => v.vendor))
+                    },
+                    name: {
+                        type: "string"
+                    }
+                },
+                allOf: ( vendors.map(vendor => ({
+                    if: {
+                        properties: {
+                            vendor: {
+                                const: vendor.vendor
+                            }
+                        }
+                    },
+                    then: vendor.configuration
+                }))),
+                required: ["vendor", "name"]
+            }
+        };
+        registry.registerSchema(languageModelsSchemaId, schema);
+    }
+};
+ChatLanguageModelsDataContribution = ( __decorate([( __param(0, ILanguageModelsService)), ( __param(1, ILanguageModelsConfigurationService))], ChatLanguageModelsDataContribution));
+
+export { ChatLanguageModelsDataContribution, LanguageModelsConfigurationService, parseLanguageModelsProviderGroups };