mirror of
https://github.com/microsoft/vscode.git
synced 2026-06-03 06:04:37 +01:00
Ulugbek Abdullaev
e63188cacb
* proxy /models: fix: correct scheme * proxy /models: introduce a new ProxyModelsService nes: model picker: prioritize local config and adopt
308 lines
12 KiB
TypeScript
308 lines
12 KiB
TypeScript
/*---------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
*--------------------------------------------------------------------------------------------*/
|
|
|
|
import { isDeepStrictEqual } from 'util';
|
|
import type * as vscode from 'vscode';
|
|
import { filterMap } from '../../../util/common/arrays';
|
|
import * as errors from '../../../util/common/errors';
|
|
import { createTracer } from '../../../util/common/tracing';
|
|
import { pushMany } from '../../../util/vs/base/common/arrays';
|
|
import { softAssert } from '../../../util/vs/base/common/assert';
|
|
import { Emitter } from '../../../util/vs/base/common/event';
|
|
import { Disposable } from '../../../util/vs/base/common/lifecycle';
|
|
import { autorun, observableFromEvent } from '../../../util/vs/base/common/observable';
|
|
import { CopilotToken } from '../../authentication/common/copilotToken';
|
|
import { ICopilotTokenStore } from '../../authentication/common/copilotTokenStore';
|
|
import { ConfigKey, ExperimentBasedConfig, IConfigurationService } from '../../configuration/common/configurationService';
|
|
import { ILogService } from '../../log/common/logService';
|
|
import { IProxyModelsService } from '../../proxyModels/common/proxyModelsService';
|
|
import { IExperimentationService } from '../../telemetry/common/nullExperimentationService';
|
|
import { ITelemetryService } from '../../telemetry/common/telemetry';
|
|
import { WireTypes } from '../common/dataTypes/inlineEditsModelsTypes';
|
|
import { isPromptingStrategy, ModelConfiguration, PromptingStrategy } from '../common/dataTypes/xtabPromptOptions';
|
|
import { IInlineEditsModelService } from '../common/inlineEditsModelService';
|
|
|
|
type Model = {
|
|
modelName: string;
|
|
promptingStrategy: PromptingStrategy | undefined;
|
|
includeTagsInCurrentFile: boolean;
|
|
}
|
|
|
|
export class InlineEditsModelService extends Disposable implements IInlineEditsModelService {
|
|
|
|
_serviceBrand: undefined;
|
|
|
|
private static readonly COPILOT_NES_XTAB_MODEL: Model = {
|
|
modelName: 'copilot-nes-xtab',
|
|
promptingStrategy: undefined,
|
|
includeTagsInCurrentFile: true,
|
|
};
|
|
|
|
private static readonly COPILOT_NES_OCT: Model = {
|
|
modelName: 'copilot-nes-oct',
|
|
promptingStrategy: PromptingStrategy.Xtab275,
|
|
includeTagsInCurrentFile: false,
|
|
};
|
|
|
|
private _copilotTokenObs = observableFromEvent(this, this._tokenStore.onDidStoreUpdate, () => this._tokenStore.copilotToken);
|
|
|
|
// TODO@ulugbekna: use a derived observable such that it fires only when nesModels change
|
|
private _fetchedModelsObs = observableFromEvent(this, this._proxyModelsService.onModelListUpdated, () => this._proxyModelsService.nesModels);
|
|
|
|
private _preferredModelNameObs = this._configService.getExperimentBasedConfigObservable(ConfigKey.Advanced.InlineEditsPreferredModel, this._expService);
|
|
private _localModelConfigObs = this._configService.getConfigObservable(ConfigKey.TeamInternal.InlineEditsXtabProviderModelConfiguration);
|
|
private _expBasedModelConfigObs = this._configService.getExperimentBasedConfigObservable(ConfigKey.TeamInternal.InlineEditsXtabProviderModelConfigurationString, this._expService);
|
|
private _defaultModelConfigObs = this._configService.getExperimentBasedConfigObservable(ConfigKey.TeamInternal.InlineEditsXtabProviderDefaultModelConfigurationString, this._expService);
|
|
|
|
private _modelInfo: { readonly modelList: readonly Model[]; readonly currentModelId: string };
|
|
|
|
private readonly _onModelListUpdated = this._register(new Emitter<void>());
|
|
public readonly onModelListUpdated = this._onModelListUpdated.event;
|
|
|
|
private _tracer = createTracer(['NES', 'ModelsService'], (msg) => this._logService.trace(msg));
|
|
|
|
constructor(
|
|
@ICopilotTokenStore private readonly _tokenStore: ICopilotTokenStore,
|
|
@IProxyModelsService private readonly _proxyModelsService: IProxyModelsService,
|
|
@IConfigurationService private readonly _configService: IConfigurationService,
|
|
@IExperimentationService private readonly _expService: IExperimentationService,
|
|
@ITelemetryService private readonly _telemetryService: ITelemetryService,
|
|
@ILogService private readonly _logService: ILogService,
|
|
) {
|
|
super();
|
|
|
|
const tracer = this._tracer.sub('constructor');
|
|
|
|
const defaultModel = this.determineDefaultModel(this._copilotTokenObs.get(), this._defaultModelConfigObs.get());
|
|
|
|
this._modelInfo = { modelList: [defaultModel], currentModelId: defaultModel.modelName };
|
|
|
|
tracer.trace('initial modelInfo', this._modelInfo);
|
|
|
|
this._register(autorun((reader) => {
|
|
this.refreshModelsInfo({
|
|
copilotToken: this._copilotTokenObs.read(reader),
|
|
fetchedNesModels: this._fetchedModelsObs.read(reader),
|
|
preferredModelName: this._preferredModelNameObs.read(reader),
|
|
localModelConfig: this._localModelConfigObs.read(reader),
|
|
modelConfigString: this._expBasedModelConfigObs.read(reader),
|
|
defaultModelConfigString: this._defaultModelConfigObs.read(reader),
|
|
});
|
|
}));
|
|
|
|
tracer.trace('updated model info', this._modelInfo);
|
|
}
|
|
|
|
get modelInfo(): vscode.InlineCompletionModelInfo | undefined {
|
|
const tracer = this._tracer.sub('modelInfo.getter');
|
|
|
|
tracer.trace('model info', this._modelInfo);
|
|
|
|
const models: vscode.InlineCompletionModel[] = this._modelInfo.modelList.map(m => ({
|
|
id: m.modelName,
|
|
name: m.modelName,
|
|
}));
|
|
|
|
return {
|
|
models,
|
|
currentModelId: this._modelInfo.currentModelId,
|
|
};
|
|
}
|
|
|
|
|
|
async setCurrentModelId(modelId: string): Promise<void> {
|
|
if (this._modelInfo.currentModelId === modelId) {
|
|
return;
|
|
}
|
|
if (!this._modelInfo.modelList.some(m => m.modelName === modelId)) {
|
|
this._logService.warn(`Trying to set unknown model id: ${modelId}`);
|
|
return;
|
|
}
|
|
this._modelInfo = { ...this._modelInfo, currentModelId: modelId };
|
|
await this._configService.setConfig(ConfigKey.Advanced.InlineEditsPreferredModel, modelId);
|
|
this._onModelListUpdated.fire();
|
|
}
|
|
|
|
async refreshModelsInfo(
|
|
{
|
|
copilotToken,
|
|
fetchedNesModels,
|
|
preferredModelName,
|
|
localModelConfig,
|
|
modelConfigString,
|
|
defaultModelConfigString,
|
|
}: {
|
|
copilotToken: CopilotToken | undefined;
|
|
fetchedNesModels: WireTypes.Model.t[] | undefined;
|
|
preferredModelName: string;
|
|
localModelConfig: ModelConfiguration | undefined;
|
|
modelConfigString: string | undefined;
|
|
defaultModelConfigString: string | undefined;
|
|
},
|
|
): Promise<void> {
|
|
|
|
const tracer = this._tracer.sub('refreshModelsInfo');
|
|
|
|
tracer.trace('Fetching latest models...');
|
|
|
|
const models: Model[] = [];
|
|
|
|
// priority of adding models to the list:
|
|
// 0. model from user local setting
|
|
// 1. model from modelConfigurationString setting (set through ExP)
|
|
// 2. fetched models from /models endpoint (if useSlashModels is true)
|
|
|
|
if (localModelConfig) {
|
|
if (models.some(m => m.modelName === localModelConfig.modelName)) {
|
|
tracer.trace('Local model configuration already exists in the model list, skipping.');
|
|
} else {
|
|
tracer.trace(`Adding local model configuration: ${localModelConfig.modelName}`);
|
|
models.push({ ...localModelConfig });
|
|
}
|
|
}
|
|
|
|
if (modelConfigString) {
|
|
tracer.trace('Parsing modelConfigurationString...');
|
|
const parsedConfig = this.parseModelConfigStringSetting(ConfigKey.TeamInternal.InlineEditsXtabProviderModelConfigurationString);
|
|
if (parsedConfig && !models.some(m => m.modelName === parsedConfig.modelName)) {
|
|
tracer.trace(`Adding model from modelConfigurationString: ${parsedConfig.modelName}`);
|
|
models.push({ ...parsedConfig });
|
|
} else {
|
|
tracer.trace('No valid model found in modelConfigurationString.');
|
|
}
|
|
}
|
|
|
|
const useSlashModels = this._configService.getExperimentBasedConfig(ConfigKey.TeamInternal.InlineEditsUseSlashModels, this._expService);
|
|
if (useSlashModels && fetchedNesModels && fetchedNesModels.length > 0) {
|
|
tracer.trace('Processing fetched models...');
|
|
if (fetchedNesModels === undefined) {
|
|
tracer.trace('No fetched models available.');
|
|
} else {
|
|
tracer.trace(`Fetched ${fetchedNesModels.length} models.`);
|
|
const filteredFetchedModels = filterMap(fetchedNesModels, (m) => {
|
|
if (!isPromptingStrategy(m.capabilities.promptStrategy)) {
|
|
return undefined;
|
|
}
|
|
return {
|
|
modelName: m.name,
|
|
promptingStrategy: m.capabilities.promptStrategy,
|
|
includeTagsInCurrentFile: false, // FIXME@ulugbekna: determine this based on model capabilities and config
|
|
} satisfies Model;
|
|
});
|
|
tracer.trace(`Adding ${filteredFetchedModels.length} fetched models after filtering.`);
|
|
pushMany(models, filteredFetchedModels);
|
|
}
|
|
} else {
|
|
// push default model if /models doesn't give us any models
|
|
tracer.trace(`adding built-in default model: useSlashModels ${useSlashModels}, fetchedNesModels ${fetchedNesModels}`);
|
|
|
|
const defaultModel = this.determineDefaultModel(copilotToken, defaultModelConfigString);
|
|
if (defaultModel) {
|
|
if (models.some(m => m.modelName === defaultModel.modelName)) {
|
|
tracer.trace('Default model configuration already exists in the model list, skipping.');
|
|
} else {
|
|
tracer.trace(`Adding default model configuration: ${defaultModel.modelName}`);
|
|
models.push(defaultModel);
|
|
}
|
|
}
|
|
}
|
|
|
|
const hasModelListChanged = !isDeepStrictEqual(this._modelInfo.modelList, models);
|
|
|
|
if (!hasModelListChanged) {
|
|
tracer.trace('Model list unchanged, not updating.');
|
|
} else {
|
|
this._modelInfo = {
|
|
modelList: models,
|
|
currentModelId: this._pickModel({ preferredModelName, models }),
|
|
};
|
|
tracer.trace('Model list updated, firing event.');
|
|
this._onModelListUpdated.fire();
|
|
}
|
|
}
|
|
|
|
public selectedModelConfiguration(): ModelConfiguration {
|
|
const tracer = this._tracer.sub('selectedModelConfiguration');
|
|
const model = this._modelInfo.modelList.find(m => m.modelName === this._modelInfo.currentModelId);
|
|
if (model) {
|
|
tracer.trace(`Selected model found: ${model.modelName}`);
|
|
return {
|
|
modelName: model.modelName,
|
|
promptingStrategy: model.promptingStrategy,
|
|
includeTagsInCurrentFile: model.includeTagsInCurrentFile,
|
|
};
|
|
}
|
|
tracer.trace('No selected model found, using default model.');
|
|
return this.determineDefaultModel(undefined, undefined);
|
|
}
|
|
|
|
private determineDefaultModel(copilotToken: CopilotToken | undefined, defaultModelConfigString: string | undefined): Model {
|
|
// if a default model config string is specified, use that
|
|
if (defaultModelConfigString) {
|
|
const parsedConfig = this.parseModelConfigStringSetting(ConfigKey.TeamInternal.InlineEditsXtabProviderDefaultModelConfigurationString);
|
|
if (parsedConfig) {
|
|
return { ...parsedConfig };
|
|
}
|
|
}
|
|
|
|
// otherwise, use built-in defaults
|
|
if (copilotToken?.isFcv1()) {
|
|
return InlineEditsModelService.COPILOT_NES_XTAB_MODEL;
|
|
} else {
|
|
return InlineEditsModelService.COPILOT_NES_OCT;
|
|
}
|
|
}
|
|
|
|
private _pickModel({
|
|
preferredModelName,
|
|
models
|
|
}: {
|
|
preferredModelName: string;
|
|
models: Model[];
|
|
}): string {
|
|
const userHasPreferredModel = preferredModelName !== 'none';
|
|
|
|
// FIXME@ulugbekna: respect exp-set model name
|
|
|
|
if (userHasPreferredModel && models.some(m => m.modelName === preferredModelName)) {
|
|
return preferredModelName;
|
|
}
|
|
|
|
softAssert(models.length > 0, 'InlineEdits model list should have at least one model');
|
|
|
|
if (models.length > 0) {
|
|
return models[0].modelName;
|
|
}
|
|
|
|
return this.determineDefaultModel(undefined, undefined).modelName;
|
|
}
|
|
|
|
private parseModelConfigStringSetting(configKey: ExperimentBasedConfig<string | undefined>): ModelConfiguration | undefined {
|
|
const configString = this._configService.getExperimentBasedConfig(configKey, this._expService);
|
|
if (configString === undefined) {
|
|
return undefined;
|
|
}
|
|
|
|
let parsedConfig: ModelConfiguration | undefined;
|
|
try {
|
|
parsedConfig = JSON.parse(configString);
|
|
// FIXME@ulugbekna: validate parsedConfig structure
|
|
} catch (e: unknown) {
|
|
/* __GDPR__
|
|
"incorrectNesModelConfig" : {
|
|
"owner": "ulugbekna",
|
|
"comment": "Capture if model configuration string is invalid JSON.",
|
|
"configName": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "Name of the configuration that failed to parse." },
|
|
"errorMessage": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "Error message from JSON.parse." },
|
|
"configValue": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "The invalid JSON string." }
|
|
}
|
|
*/
|
|
this._telemetryService.sendMSFTTelemetryEvent('incorrectNesModelConfig', { configName: configKey.id, errorMessage: errors.toString(errors.fromUnknown(e)), configValue: configString });
|
|
}
|
|
|
|
return parsedConfig;
|
|
}
|
|
}
|