@codingame/monaco-vscode-chat-service-override 36.2.7 → 37.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/expNotification/chatExpNotificationConfig.js

@@ -0,0 +1,232 @@
+
+import { stableStringify } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
+import { parseExpPayloadEnvelope, isObject, readText, MAX_ID_LENGTH, ID_PATTERN, readSelectorList, normalizeSelector, expandModelMatchCandidates, modelSelectorAliases } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/common/expPayload';
+import { ChatInputNotificationSeverity, ChatInputNotificationActionKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/chatInputNotificationService';
+
+const CHAT_EXP_NOTIFICATION_VERSION = 1;
+const MAX_NOTIFICATIONS = 8;
+const MAX_ACTIONS = 3;
+const MAX_CONFIG_KEYS = 8;
+const MATCH_KEYS = ["sessionTypes", "selectedModels", "excludeSelectedModels"];
+const MAX_TITLE_LENGTH = 120;
+const MAX_DESCRIPTION_LENGTH = 500;
+const MAX_LABEL_LENGTH = 40;
+const SEVERITIES = ( new Map([
+    ["info", ChatInputNotificationSeverity.Info],
+    ["warning", ChatInputNotificationSeverity.Warning],
+    ["error", ChatInputNotificationSeverity.Error]
+]));
+function parseChatExpNotifications(raw) {
+    const parsed = parseExpPayloadEnvelope(raw, CHAT_EXP_NOTIFICATION_VERSION);
+    if (typeof parsed === "string") {
+        return {
+            error: parsed
+        };
+    }
+    if (!Array.isArray(parsed.notifications)) {
+        return {
+            error: "notifications must be an array"
+        };
+    }
+    if (parsed.notifications.length > MAX_NOTIFICATIONS) {
+        return {
+            error: `notifications exceeds ${MAX_NOTIFICATIONS} entries`
+        };
+    }
+    const notifications = [];
+    const seen = ( new Set());
+    for (let i = 0; i < parsed.notifications.length; i++) {
+        const notification = readNotification(parsed.notifications[i], `notifications[${i}]`);
+        if (typeof notification === "string") {
+            return {
+                error: notification
+            };
+        }
+        if (( seen.has(notification.id))) {
+            return {
+                error: `notifications[${i}].id "${notification.id}" is duplicated`
+            };
+        }
+        seen.add(notification.id);
+        notifications.push(notification);
+    }
+    return {
+        notifications
+    };
+}
+function readNotification(raw, path) {
+    if (!isObject(raw)) {
+        return `${path} must be an object`;
+    }
+    const id = readText(raw.id, MAX_ID_LENGTH, ID_PATTERN);
+    if (!id) {
+        return `${path}.id is missing or malformed`;
+    }
+    const message = readText(raw.title, MAX_TITLE_LENGTH);
+    if (!message) {
+        return `${path}.title is missing or too long`;
+    }
+    const description = raw.description === undefined ? undefined : readText(raw.description, MAX_DESCRIPTION_LENGTH);
+    if (raw.description !== undefined && !description) {
+        return `${path}.description is empty or too long`;
+    }
+    const severity = raw.severity === undefined ? ChatInputNotificationSeverity.Info : SEVERITIES.get(raw.severity);
+    if (severity === undefined) {
+        return `${path}.severity must be "info", "warning" or "error"`;
+    }
+    const match = readMatch(raw.match, `${path}.match`);
+    if (typeof match === "string") {
+        return match;
+    }
+    const actions = readActions(raw.actions, `${path}.actions`);
+    if (typeof actions === "string") {
+        return actions;
+    }
+    const dismissible = readBoolean(raw.dismissible, true);
+    const autoDismissOnMessage = readBoolean(raw.autoDismissOnMessage, false);
+    if (dismissible === undefined || autoDismissOnMessage === undefined) {
+        return `${path}.dismissible and ${path}.autoDismissOnMessage must be booleans`;
+    }
+    if (!dismissible && !autoDismissOnMessage && !actions.length) {
+        return `${path} must be dismissible, auto-dismiss on message, or offer an action`;
+    }
+    return {
+        id,
+        telemetryId: id,
+        severity,
+        message,
+        description,
+        match,
+        actions,
+        dismissible,
+        autoDismissOnMessage,
+        signature: stableStringify(raw)
+    };
+}
+function readBoolean(raw, fallback) {
+    return raw === undefined ? fallback : typeof raw === "boolean" ? raw : undefined;
+}
+function readMatch(raw, path) {
+    if (raw !== undefined && !isObject(raw)) {
+        return `${path} must be an object`;
+    }
+    const source = isObject(raw) ? raw : {};
+    const unknown = ( Object.keys(source)).find(key => !MATCH_KEYS.includes(key));
+    if (unknown) {
+        return `${path} has unknown key ${JSON.stringify(unknown)}`;
+    }
+    const sessionTypes = readSelectorList(source.sessionTypes, `${path}.sessionTypes`);
+    if (typeof sessionTypes === "string") {
+        return sessionTypes;
+    }
+    const selectedModels = readSelectorList(source.selectedModels, `${path}.selectedModels`);
+    if (typeof selectedModels === "string") {
+        return selectedModels;
+    }
+    const excludeSelectedModels = readSelectorList(source.excludeSelectedModels, `${path}.excludeSelectedModels`);
+    if (typeof excludeSelectedModels === "string") {
+        return excludeSelectedModels;
+    }
+    if (!sessionTypes.length && !selectedModels.length && !excludeSelectedModels.length) {
+        return `${path} must narrow at least one dimension`;
+    }
+    return {
+        sessionTypes,
+        selectedModels,
+        excludeSelectedModels
+    };
+}
+function readActions(raw, path) {
+    if (raw === undefined) {
+        return [];
+    }
+    if (!Array.isArray(raw)) {
+        return `${path} must be an array`;
+    }
+    if (raw.length > MAX_ACTIONS) {
+        return `${path} exceeds ${MAX_ACTIONS} entries`;
+    }
+    const actions = [];
+    const seen = ( new Set());
+    for (let i = 0; i < raw.length; i++) {
+        const action = readAction(raw[i], `${path}[${i}]`);
+        if (typeof action === "string") {
+            return action;
+        }
+        if (( seen.has(action.telemetryActionId))) {
+            return `${path}[${i}].id "${action.telemetryActionId}" is duplicated`;
+        }
+        seen.add(action.telemetryActionId);
+        actions.push(action);
+    }
+    return actions;
+}
+function readAction(raw, path) {
+    if (!isObject(raw)) {
+        return `${path} must be an object`;
+    }
+    const telemetryActionId = readText(raw.id, MAX_ID_LENGTH, ID_PATTERN);
+    if (!telemetryActionId) {
+        return `${path}.id is missing or malformed`;
+    }
+    const label = readText(raw.label, MAX_LABEL_LENGTH);
+    if (!label) {
+        return `${path}.label is missing or too long`;
+    }
+    const base = {
+        label,
+        telemetryActionId
+    };
+    switch (raw.kind) {
+    case ChatInputNotificationActionKind.OpenModelPicker:
+        return {
+            ...base,
+            kind: ChatInputNotificationActionKind.OpenModelPicker
+        };
+    case ChatInputNotificationActionKind.Command:
+        {
+            if (typeof raw.commandId !== "string" || !raw.commandId.trim()) {
+                return `${path}.commandId is missing`;
+            }
+            if (raw.args !== undefined && !Array.isArray(raw.args)) {
+                return `${path}.args must be an array`;
+            }
+            return {
+                ...base,
+                kind: ChatInputNotificationActionKind.Command,
+                commandId: raw.commandId.trim(),
+                commandArgs: raw.args ?? []
+            };
+        }
+    case ChatInputNotificationActionKind.SwitchToModel:
+        {
+            if (typeof raw.model !== "string" || !raw.model.trim()) {
+                return `${path}.model is missing`;
+            }
+            if (raw.config !== undefined && (!isObject(raw.config) || ( Object.keys(raw.config)).length > MAX_CONFIG_KEYS)) {
+                return `${path}.config must be an object of at most ${MAX_CONFIG_KEYS} keys`;
+            }
+            const target = normalizeSelector(raw.model);
+            return {
+                ...base,
+                kind: ChatInputNotificationActionKind.SwitchToModel,
+                matchesModel: model => ( expandModelMatchCandidates(model.identifier, modelSelectorAliases(model.metadata)).has(target)),
+                config: raw.config,
+                requireUniqueModel: true
+            };
+        }
+    }
+    return `${path}.kind must be "${ChatInputNotificationActionKind.Command}", "${ChatInputNotificationActionKind.OpenModelPicker}" or "${ChatInputNotificationActionKind.SwitchToModel}"`;
+}
+function matchesChatExpNotification(match, context) {
+    const {
+        sessionTypes,
+        selectedModels,
+        excludeSelectedModels
+    } = match;
+    const sessionCandidates = ( [context.sessionType, context.harness].map(value => value && normalizeSelector(value)));
+    const modelCandidates = expandModelMatchCandidates(context.selectedModelId, context.selectedModelAliases);
+    return (!sessionTypes.length || ( sessionTypes.some(selector => sessionCandidates.includes(selector)))) && (!selectedModels.length || ( selectedModels.some(selector => ( modelCandidates.has(selector))))) && !( excludeSelectedModels.some(selector => ( modelCandidates.has(selector))));
+}
+
+export { CHAT_EXP_NOTIFICATION_VERSION, matchesChatExpNotification, parseChatExpNotifications };

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

@@ -0,0 +1,36 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { IWorkbenchAssignmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/assignment/common/assignmentService.service";
+import { IChatEntitlementService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service";
+import { IChatSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service";
+import { IChatInputNotificationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/chatInputNotificationService.service";
+export declare const CHAT_EXP_NOTIFICATION_TREATMENT = "chatNotifications";
+/**
+ * Renders chat input notifications described by an experiment treatment.
+ *
+ * The treatment carries the words, the targeting and the buttons, so a notification can be
+ * authored or retired without shipping code. Removing the assignment is the kill switch.
+ */
+export declare class ChatExpNotificationContribution extends Disposable implements IWorkbenchContribution {
+    private readonly _assignmentService;
+    private readonly _notificationService;
+    private readonly _chatSessionsService;
+    private readonly _configurationService;
+    private readonly _entitlementService;
+    private readonly _storageService;
+    private readonly _logService;
+    static readonly ID = "workbench.contrib.chatExpNotification";
+    /** Registered payload ids, each mapped to the entry text that produced it. */
+    private readonly _registered;
+    private _notifications;
+    /** Increments on every refresh so a slow in-flight resolution cannot overwrite a newer one. */
+    private _generation;
+    constructor(_assignmentService: IWorkbenchAssignmentService, _notificationService: IChatInputNotificationService, _chatSessionsService: IChatSessionsService, _configurationService: IConfigurationService, _entitlementService: IChatEntitlementService, _storageService: IStorageService, _logService: ILogService);
+    private _resolve;
+    private _update;
+    private _matches;
+    private _handleDismissed;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/expNotification/chatExpNotificationContribution.js

@@ -0,0 +1,127 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ChatAIDisabledSettingId } from '@codingame/monaco-vscode-api/vscode/vs/platform/chat/common/chatSettings';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { StorageScope } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { IWorkbenchAssignmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/assignment/common/assignmentService.service';
+import { IChatEntitlementService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service';
+import { IChatSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service';
+import { modelSelectorAliases } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/common/expPayload';
+import { readDismissedNotificationIds, addDismissedNotificationId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/chatInputNotificationService';
+import { IChatInputNotificationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/chatInputNotificationService.service';
+import { parseChatExpNotifications, matchesChatExpNotification } from './chatExpNotificationConfig.js';
+
+const CHAT_EXP_NOTIFICATION_TREATMENT = "chatNotifications";
+const DISMISSED_STORAGE_KEY = "chat.dismissedExpNotificationIds";
+const ID_PREFIX = "chat.expNotification.";
+let ChatExpNotificationContribution = class ChatExpNotificationContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.chatExpNotification";
+    }
+    constructor(
+        _assignmentService,
+        _notificationService,
+        _chatSessionsService,
+        _configurationService,
+        _entitlementService,
+        _storageService,
+        _logService
+    ) {
+        super();
+        this._assignmentService = _assignmentService;
+        this._notificationService = _notificationService;
+        this._chatSessionsService = _chatSessionsService;
+        this._configurationService = _configurationService;
+        this._entitlementService = _entitlementService;
+        this._storageService = _storageService;
+        this._logService = _logService;
+        this._registered = ( new Map());
+        this._notifications = [];
+        this._generation = 0;
+        void this._resolve();
+        this._register(
+            this._assignmentService.onDidRefetchAssignments(() => void this._resolve())
+        );
+        this._register(this._notificationService.onDidDismiss(id => this._handleDismissed(id)));
+        this._register(
+            this._storageService.onDidChangeValue(StorageScope.APPLICATION, DISMISSED_STORAGE_KEY, this._store)(() => this._update())
+        );
+        this._register(
+            this._entitlementService.onDidChangeSentiment(() => this._notificationService.refresh())
+        );
+        this._register(this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(ChatAIDisabledSettingId)) {
+                this._notificationService.refresh();
+            }
+        }));
+    }
+    async _resolve() {
+        const generation = ++this._generation;
+        let payload;
+        try {
+            payload = await this._assignmentService.getTreatment(CHAT_EXP_NOTIFICATION_TREATMENT);
+        } catch (err) {
+            this._logService.trace(`[chatExpNotification] failed to resolve treatment: ${err}`);
+            return;
+        }
+        if (generation !== this._generation) {
+            return;
+        }
+        const result = payload === undefined ? undefined : parseChatExpNotifications(payload);
+        if (result?.error) {
+            this._logService.warn(`[chatExpNotification] ignoring invalid payload: ${result.error}`);
+        }
+        this._notifications = result?.notifications ?? [];
+        this._update();
+    }
+    _update() {
+        const dismissed = readDismissedNotificationIds(this._storageService, DISMISSED_STORAGE_KEY);
+        const active = this._notifications.filter(notification => !( dismissed.has(notification.id)));
+        for (const id of [...( this._registered.keys())]) {
+            if (!( active.some(notification => notification.id === id))) {
+                this._notificationService.deleteNotification(ID_PREFIX + id);
+                this._registered.delete(id);
+            }
+        }
+        for (const {
+            match,
+            signature,
+            ...notification
+        } of active) {
+            if (this._registered.get(notification.id) === signature) {
+                continue;
+            }
+            this._registered.set(notification.id, signature);
+            this._notificationService.setNotification({
+                ...notification,
+                id: ID_PREFIX + notification.id,
+                when: context => this._matches(match, context)
+            });
+        }
+    }
+    _matches(match, context) {
+        if (this._configurationService.getValue(ChatAIDisabledSettingId) === true || this._entitlementService.sentiment.hidden) {
+            return false;
+        }
+        const model = context.modelState.currentModel;
+        return matchesChatExpNotification(match, {
+            sessionType: context.sessionType,
+            harness: context.sessionType ? this._chatSessionsService.getChatSessionContribution(context.sessionType)?.agentHostProviderId : undefined,
+            selectedModelId: model?.identifier,
+            selectedModelAliases: model && modelSelectorAliases(model.metadata)
+        });
+    }
+    _handleDismissed(id) {
+        if (!id.startsWith(ID_PREFIX)) {
+            return;
+        }
+        addDismissedNotificationId(this._storageService, DISMISSED_STORAGE_KEY, id.slice(ID_PREFIX.length));
+        this._update();
+    }
+};
+ChatExpNotificationContribution = ( __decorate([( __param(0, IWorkbenchAssignmentService)), ( __param(1, IChatInputNotificationService)), ( __param(2, IChatSessionsService)), ( __param(3, IConfigurationService)), ( __param(4, IChatEntitlementService)), ( __param(5, IStorageService)), ( __param(6, ILogService))], ChatExpNotificationContribution));
+
+export { CHAT_EXP_NOTIFICATION_TREATMENT, ChatExpNotificationContribution };

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

@@ -33,7 +33,7 @@ ExploreAgentDefaultModel = ( __decorate([( __param(0, ILanguageModelsService)),
 registerWorkbenchContribution2(
     ExploreAgentDefaultModel.ID,
     ExploreAgentDefaultModel,
-    WorkbenchPhase.BlockRestore
+    WorkbenchPhase.AfterRestored
 );
 
 export { ExploreAgentDefaultModel };

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

@@ -0,0 +1,18 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
+import { IChatModelFeedbackSurveyService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/feedbackSurvey/chatModelFeedbackSurveyService.service";
+/**
+ * Watches the model picker of every chat widget and reports switches to the survey service.
+ *
+ * It sits outside the picker so model selection knows nothing about surveys, and outside the
+ * service so the service stays free of widget lifecycle and easy to test.
+ */
+export declare class ChatModelFeedbackSurveyPromptContribution extends Disposable implements IWorkbenchContribution {
+    private readonly chatWidgetService;
+    private readonly surveyService;
+    static readonly ID = "chat.modelFeedbackSurveyPrompt";
+    private readonly widgetListeners;
+    constructor(chatWidgetService: IChatWidgetService, surveyService: IChatModelFeedbackSurveyService);
+    private trackWidget;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/feedbackSurvey/chatModelFeedbackSurveyPromptContribution.js

@@ -0,0 +1,55 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable, DisposableMap, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { IChatModelFeedbackSurveyService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/feedbackSurvey/chatModelFeedbackSurveyService.service';
+import { observableSignalFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignalFromEvent';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+let ChatModelFeedbackSurveyPromptContribution = class ChatModelFeedbackSurveyPromptContribution extends Disposable {
+    static {
+        this.ID = "chat.modelFeedbackSurveyPrompt";
+    }
+    constructor(chatWidgetService, surveyService) {
+        super();
+        this.chatWidgetService = chatWidgetService;
+        this.surveyService = surveyService;
+        this.widgetListeners = this._register(( new DisposableMap()));
+        for (const widget of this.chatWidgetService.getAllWidgets()) {
+            this.trackWidget(widget);
+        }
+        this._register(this.chatWidgetService.onDidAddWidget(widget => this.trackWidget(widget)));
+        this._register(
+            this.chatWidgetService.onDidRemoveWidget(widget => this.widgetListeners.deleteAndDispose(widget))
+        );
+    }
+    trackWidget(widget) {
+        const listeners = ( new DisposableStore());
+        const viewModelChanged = observableSignalFromEvent("chatFeedbackSurveyViewModel", widget.onDidChangeViewModel);
+        let previous;
+        listeners.add(autorun(reader => {
+            viewModelChanged.read(reader);
+            const modelId = widget.input.selectedLanguageModel.read(reader)?.identifier;
+            const sessionResource = widget.viewModel?.sessionResource;
+            const session = sessionResource?.toString();
+            const last = previous;
+            previous = modelId && session ? {
+                modelId,
+                session
+            } : undefined;
+            if (last && last.session !== session) {
+                previous = undefined;
+                return;
+            }
+            if (!last || !modelId || !sessionResource || last.modelId === modelId) {
+                return;
+            }
+            this.surveyService.notifyModelSwitchedAway(sessionResource, last.modelId, modelId);
+        }));
+        this.widgetListeners.set(widget, listeners);
+    }
+};
+ChatModelFeedbackSurveyPromptContribution = ( __decorate([( __param(0, IChatWidgetService)), ( __param(1, IChatModelFeedbackSurveyService))], ChatModelFeedbackSurveyPromptContribution));
+
+export { ChatModelFeedbackSurveyPromptContribution };

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

@@ -9,9 +9,10 @@ import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform
 import { ChatEntitlementContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService';
 import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
 import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
-import { ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
 import { COPILOT_VENDOR_ID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels';
 import { ILanguageModelsConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelsConfiguration.service';
+import { ChatAIDisabledSettingId } from '@codingame/monaco-vscode-api/vscode/vs/platform/chat/common/chatSettings';
 
 var HasByokModelsContribution_1;
 let HasByokModelsContribution = class HasByokModelsContribution extends Disposable {
@@ -61,14 +62,14 @@ let HasByokModelsContribution = class HasByokModelsContribution extends Disposab
         });
         this._register(Event.any(Event.filter(
             this._configurationService.onDidChangeConfiguration,
-            e => e.affectsConfiguration(ChatConfiguration.AIDisabled)
+            e => e.affectsConfiguration(ChatAIDisabledSettingId)
         ), Event.filter(
             this._contextKeyService.onDidChangeContext,
             e => e.affectsSome(HasByokModelsContribution_1.TRACKED_KEYS)
         ), this._languageModelsConfigurationService.onDidChangeLanguageModelGroups)(() => this._update()));
     }
     _isFeatureEnabled() {
-        return !this._configurationService.getValue(ChatConfiguration.AIDisabled) && !!this._contextKeyService.getContextKeyValue(ChatEntitlementContextKeys.clientByokEnabled.key);
+        return !this._configurationService.getValue(ChatAIDisabledSettingId) && !!this._contextKeyService.getContextKeyValue(ChatEntitlementContextKeys.clientByokEnabled.key);
     }
     _restore() {
         if (!this._isFeatureEnabled()) {

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

@@ -380,7 +380,7 @@ let ChatLanguageModelsDataContribution = class ChatLanguageModelsDataContributio
                     },
                     settings: {
                         type: "object",
-                        description: ( localize(7422, "Per-model settings"))
+                        description: ( localize(8668, "Per-model settings"))
                     }
                 },
                 allOf: [...( vendors.map(vendor => ({