@codingame/monaco-vscode-chat-service-override 32.0.2 → 33.0.5

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

@@ -0,0 +1,91 @@
+
+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 { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { IChatContextService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/contextContrib/chatContextService.service';
+import { isProposedApiEnabled } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions';
+import { ExtensionsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensionsRegistry';
+
+const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
+    extensionPoint: "chatContext",
+    jsonSchema: {
+        description: ( localize(6786, "Contributes chat context integrations to the chat widget.")),
+        type: "array",
+        items: {
+            type: "object",
+            properties: {
+                id: {
+                    description: ( localize(6787, "A unique identifier for this item.")),
+                    type: "string"
+                },
+                icon: {
+                    description: ( localize(6788, "The icon associated with this chat context item.")),
+                    type: "string"
+                },
+                displayName: {
+                    description: ( localize(
+                        6789,
+                        "A user-friendly name for this item which is used for display in menus."
+                    )),
+                    type: "string"
+                }
+            },
+            required: ["id", "icon", "displayName"]
+        }
+    },
+    activationEventsGenerator: function*(contributions) {
+        for (const contrib of contributions) {
+            yield `onChatContextProvider:${contrib.id}`;
+        }
+    }
+});
+let ChatContextContribution = class ChatContextContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.chatContextContribution";
+    }
+    constructor(_chatContextService) {
+        super();
+        this._chatContextService = _chatContextService;
+        extensionPoint.setHandler(extensions => {
+            for (const ext of extensions) {
+                if (!isProposedApiEnabled(ext.description)) {
+                    continue;
+                }
+                if (!Array.isArray(ext.value)) {
+                    continue;
+                }
+                for (const contribution of ext.value) {
+                    const icon = contribution.icon ? ThemeIcon.fromString(contribution.icon) : undefined;
+                    if (!icon && contribution.icon) {
+                        ext.collector.error(( localize(
+                            6790,
+                            "Invalid icon format for chat context contribution '{0}'. Icon must be in the format '{1}' or '{2}', e.g. '{3}'.",
+                            contribution.id,
+                            "$(iconId)",
+                            "$(iconId~spin)",
+                            "$(copilot)"
+                        )));
+                        continue;
+                    }
+                    if (!icon) {
+                        continue;
+                    }
+                    this._chatContextService.setChatContextProvider(`${ext.description.id}-${contribution.id}`, {
+                        title: contribution.displayName,
+                        icon
+                    });
+                }
+            }
+        });
+    }
+};
+ChatContextContribution = ( __decorate([( __param(0, IChatContextService))], ChatContextContribution));
+registerWorkbenchContribution2(
+    ChatContextContribution.ID,
+    ChatContextContribution,
+    WorkbenchPhase.AfterRestored
+);
+
+export { ChatContextContribution };

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

@@ -0,0 +1,52 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IRemoteAgentHostConnectionInfo } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService";
+export declare const COPILOT_CLI_LOCAL_AH_SCHEME = "agent-host-copilotcli";
+export declare const COPILOT_CLI_EH_SCHEME = "copilotcli";
+/**
+ * Builds the local `events.jsonl` URI under `~/.copilot/session-state/<rawId>/`.
+ *
+ * Used for both the local Agent Host Copilot CLI provider and the
+ * extension-host Copilot CLI provider, which share the same on-disk layout
+ * and the same chat session URI shape (`copilotcli:/<rawId>`).
+ */
+export declare function buildLocalEventsUri(userHome: URI, rawSessionId: string): URI;
+/**
+ * Builds a `vscode-agent-host://` URI for the `events.jsonl` file inside
+ * the host's user home directory, using the connection's reported
+ * `defaultDirectory` (set from `os.homedir()` on the host during the
+ * AHP handshake).
+ *
+ * The path is joined at the URI-path level using forward slashes, which
+ * works for both POSIX hosts (`/home/me`) and Windows hosts whose
+ * `URI.file(os.homedir()).path` is also forward-slash-rooted (e.g.
+ * `/c:/Users/me`). Returns `undefined` if the host did not report a
+ * usable `defaultDirectory`.
+ */
+export declare function buildRemoteEventsUri(connection: IRemoteAgentHostConnectionInfo, rawSessionId: string): URI | undefined;
+/**
+ * Parses the connection authority out of a remote AH chat session scheme
+ * of the form `remote-<authority>-copilotcli`. Returns `undefined` for
+ * any other scheme, including the local `copilotcli` scheme.
+ */
+export declare function parseRemoteAuthorityFromScheme(scheme: string): string | undefined;
+export type ResolveEventsUriResult = {
+    readonly kind: "ok";
+    readonly resource: URI;
+} | {
+    readonly kind: "no-session";
+} | {
+    readonly kind: "unsupported-scheme";
+    readonly scheme: string;
+} | {
+    readonly kind: "remote-not-connected";
+    readonly authority: string;
+} | {
+    readonly kind: "remote-no-home";
+    readonly authority: string;
+};
+/**
+ * Pure resolver for tests. Translates a chat session resource into the
+ * `events.jsonl` URI for the corresponding Copilot CLI session, or
+ * returns a structured error.
+ */
+export declare function resolveEventsUri(sessionResource: URI | undefined, userHome: URI, getConnectionByAuthority: (authority: string) => IRemoteAgentHostConnectionInfo | undefined): ResolveEventsUriResult;

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

@@ -0,0 +1,82 @@
+
+import { joinPath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { agentHostAuthority, toAgentHostUri } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
+
+const COPILOT_CLI_PROVIDER = "copilotcli";
+const COPILOT_CLI_LOCAL_AH_SCHEME = `agent-host-${COPILOT_CLI_PROVIDER}`;
+const COPILOT_CLI_EH_SCHEME = COPILOT_CLI_PROVIDER;
+const REMOTE_PROVIDER_PREFIX = "remote-";
+const REMOTE_PROVIDER_SUFFIX = `-${COPILOT_CLI_PROVIDER}`;
+function buildLocalEventsUri(userHome, rawSessionId) {
+    return joinPath(userHome, ".copilot", "session-state", rawSessionId, "events.jsonl");
+}
+function buildRemoteEventsUri(connection, rawSessionId) {
+    const homePath = connection.defaultDirectory;
+    if (!homePath) {
+        return undefined;
+    }
+    const trimmed = homePath.endsWith("/") ? homePath.slice(0, -1) : homePath;
+    const remoteFileUri = ( URI.from({
+        scheme: "file",
+        path: `${trimmed}/.copilot/session-state/${rawSessionId}/events.jsonl`
+    }));
+    const authority = agentHostAuthority(connection.address);
+    return toAgentHostUri(remoteFileUri, authority);
+}
+function parseRemoteAuthorityFromScheme(scheme) {
+    if (!scheme.startsWith(REMOTE_PROVIDER_PREFIX) || !scheme.endsWith(REMOTE_PROVIDER_SUFFIX)) {
+        return undefined;
+    }
+    const authority = scheme.slice(
+        REMOTE_PROVIDER_PREFIX.length,
+        scheme.length - REMOTE_PROVIDER_SUFFIX.length
+    );
+    return authority || undefined;
+}
+function resolveEventsUri(sessionResource, userHome, getConnectionByAuthority) {
+    if (!sessionResource) {
+        return {
+            kind: "no-session"
+        };
+    }
+    const rawId = sessionResource.path.startsWith("/") ? sessionResource.path.substring(1) : sessionResource.path;
+    if (!rawId) {
+        return {
+            kind: "no-session"
+        };
+    }
+    if (sessionResource.scheme === COPILOT_CLI_LOCAL_AH_SCHEME || sessionResource.scheme === COPILOT_CLI_EH_SCHEME) {
+        return {
+            kind: "ok",
+            resource: buildLocalEventsUri(userHome, rawId)
+        };
+    }
+    const remoteAuthority = parseRemoteAuthorityFromScheme(sessionResource.scheme);
+    if (remoteAuthority) {
+        const connection = getConnectionByAuthority(remoteAuthority);
+        if (!connection) {
+            return {
+                kind: "remote-not-connected",
+                authority: remoteAuthority
+            };
+        }
+        const resource = buildRemoteEventsUri(connection, rawId);
+        if (!resource) {
+            return {
+                kind: "remote-no-home",
+                authority: remoteAuthority
+            };
+        }
+        return {
+            kind: "ok",
+            resource
+        };
+    }
+    return {
+        kind: "unsupported-scheme",
+        scheme: sessionResource.scheme
+    };
+}
+
+export { COPILOT_CLI_EH_SCHEME, COPILOT_CLI_LOCAL_AH_SCHEME, buildLocalEventsUri, buildRemoteEventsUri, parseRemoteAuthorityFromScheme, resolveEventsUri };

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

@@ -16,12 +16,32 @@ export interface DefaultModelContributionOptions {
     readonly logPrefix: string;
     /** Additional filter beyond `isUserSelectable`. Return `true` to include the model. */
     readonly filter?: (metadata: ILanguageModelChatMetadata) => boolean;
+    /**
+     * How model identifiers are encoded in the stored setting value.
+     * - `'qualifiedName'` (default): `${name} (${vendor})` — matches
+     *   {@link ILanguageModelChatMetadata.asQualifiedName}. Kept for backward
+     *   compatibility with existing settings (plan/explore agent).
+     * - `'vendorAndId'`: `${vendor}/${id}` — stable composite of API-stable
+     *   fields, directly usable with `vscode.lm.selectChatModels`.
+     */
+    readonly storageFormat?: "qualifiedName" | "vendorAndId";
+    /**
+     * Optional override for the label of the default ("empty") enum entry.
+     * When omitted, defaults to `"Auto (Vendor Default)"`.
+     */
+    readonly defaultEntryLabel?: string;
+    /**
+     * Optional override for the description of the default ("empty") enum
+     * entry. See {@link defaultEntryLabel}.
+     */
+    readonly defaultEntryDescription?: string;
 }
 /**
  * Creates the initial static arrays used by configuration registration code.
  * The returned arrays are mutated in-place by {@link DefaultModelContribution}.
+ *
  */
-export declare function createDefaultModelArrays(): DefaultModelArrays;
+export declare function createDefaultModelArrays(defaultEntryLabel?: string, defaultEntryDescription?: string): DefaultModelArrays;
 /**
  * Shared base class for workbench contributions that populate a dynamic enum
  * of language models for a settings picker.

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

@@ -7,14 +7,13 @@ import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log
 import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
 import { ILanguageModelChatMetadata } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels';
 import { ILanguageModelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service';
-import { DEFAULT_MODEL_PICKER_CATEGORY } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/widget/input/modelPickerWidget';
 
 const configurationRegistry = ( Registry.as(Extensions.Configuration));
-function createDefaultModelArrays() {
+function createDefaultModelArrays(defaultEntryLabel, defaultEntryDescription) {
     return {
         modelIds: [""],
-        modelLabels: [( localize(6722, "Auto (Vendor Default)"))],
-        modelDescriptions: [( localize(6723, "Use the vendor's default model"))]
+        modelLabels: [defaultEntryLabel ?? ( localize(6791, "Auto (Vendor Default)"))],
+        modelDescriptions: [defaultEntryDescription ?? ( localize(6792, "Use the vendor's default model"))]
     };
 }
 let DefaultModelContribution = class DefaultModelContribution extends Disposable {
@@ -39,15 +38,18 @@ let DefaultModelContribution = class DefaultModelContribution extends Disposable
             configKey,
             configSectionId,
             logPrefix,
-            filter
+            filter,
+            storageFormat,
+            defaultEntryLabel,
+            defaultEntryDescription
         } = this._options;
         try {
             modelIds.length = 0;
             modelLabels.length = 0;
             modelDescriptions.length = 0;
             modelIds.push("");
-            modelLabels.push(( localize(6722, "Auto (Vendor Default)")));
-            modelDescriptions.push(( localize(6723, "Use the vendor's default model")));
+            modelLabels.push(defaultEntryLabel ?? ( localize(6791, "Auto (Vendor Default)")));
+            modelDescriptions.push(defaultEntryDescription ?? ( localize(6792, "Use the vendor's default model")));
             const models = [];
             const allModelIds = this._languageModelsService.getLanguageModelIds();
             for (const modelId of allModelIds) {
@@ -65,8 +67,16 @@ let DefaultModelContribution = class DefaultModelContribution extends Disposable
                     this._logService.error(`${logPrefix} Error looking up model ${modelId}:`, e);
                 }
             }
+            const vendors = this._languageModelsService.getVendors();
+            const visibleVendors = ( new Set(( vendors.map(vendor => vendor.vendor))));
             const supportedModels = models.filter(model => {
-                if (!model.metadata?.isUserSelectable) {
+                if (!( visibleVendors.has(model.metadata.vendor))) {
+                    return false;
+                }
+                if (model.metadata?.isUserSelectable === false) {
+                    return false;
+                }
+                if (model.metadata?.targetChatSessionType !== undefined) {
                     return false;
                 }
                 if (filter && !filter(model.metadata)) {
@@ -74,19 +84,46 @@ let DefaultModelContribution = class DefaultModelContribution extends Disposable
                 }
                 return true;
             });
-            supportedModels.sort((a, b) => {
-                const aCategory = a.metadata.modelPickerCategory ?? DEFAULT_MODEL_PICKER_CATEGORY;
-                const bCategory = b.metadata.modelPickerCategory ?? DEFAULT_MODEL_PICKER_CATEGORY;
-                if (aCategory.order !== bCategory.order) {
-                    return aCategory.order - bCategory.order;
+            supportedModels.sort((a, b) => a.metadata.name.localeCompare(b.metadata.name));
+            const vendorDisplayNames = ( new Map());
+            for (const vendor of vendors) {
+                vendorDisplayNames.set(vendor.vendor, vendor.displayName);
+            }
+            const ambiguousVendorIds = ( new Set());
+            if (storageFormat === "vendorAndId") {
+                const counts = ( new Map());
+                for (const model of models) {
+                    const key = `${model.metadata.vendor}/${model.metadata.id}`;
+                    counts.set(key, (counts.get(key) ?? 0) + 1);
                 }
-                return a.metadata.name.localeCompare(b.metadata.name);
-            });
+                for (const [key, count] of counts) {
+                    if (count > 1) {
+                        ambiguousVendorIds.add(key);
+                    }
+                }
+            }
             for (const model of supportedModels) {
                 try {
-                    const qualifiedName = ILanguageModelChatMetadata.asQualifiedName(model.metadata);
-                    modelIds.push(qualifiedName);
-                    modelLabels.push(model.metadata.name);
+                    const storedId = storageFormat === "vendorAndId" ? `${model.metadata.vendor}/${model.metadata.id}` : ILanguageModelChatMetadata.asQualifiedName(model.metadata);
+                    if (( ambiguousVendorIds.has(storedId))) {
+                        this._logService.trace(
+                            `${logPrefix} Skipping model '${model.metadata.name}' (${storedId}): key collides with another registered model.`
+                        );
+                        continue;
+                    }
+                    const vendorDisplayName = vendorDisplayNames.get(model.metadata.vendor);
+                    if (!vendorDisplayName) {
+                        this._logService.trace(
+                            `${logPrefix} No vendor descriptor for '${model.metadata.vendor}' (model '${model.metadata.id}'); falling back to vendor id in label.`
+                        );
+                    }
+                    modelIds.push(storedId);
+                    modelLabels.push(( localize(
+                        6793,
+                        "{0} ({1})",
+                        model.metadata.name,
+                        vendorDisplayName ?? model.metadata.vendor
+                    )));
                     modelDescriptions.push(model.metadata.tooltip ?? model.metadata.detail ?? "");
                 } catch (e) {
                     this._logService.error(`${logPrefix} Error adding model ${model.metadata.name}:`, e);

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

@@ -5,16 +5,16 @@ import { WorkbenchState } from '@codingame/monaco-vscode-api/vscode/vs/platform/
 import { ContributionEnablementState, isContributionDisabled } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/enablement';
 
 function createEnablementActions(key, enablementModel, idPrefix) {
-    return [( new Action(`${idPrefix}.enable`, ( localize(6724, "Enable")), undefined, true, () => {
+    return [( new Action(`${idPrefix}.enable`, ( localize(6794, "Enable")), undefined, true, () => {
         enablementModel.setEnabled(key, ContributionEnablementState.EnabledProfile);
         return Promise.resolve();
-    })), ( new Action(`${idPrefix}.enableForWorkspace`, ( localize(6725, "Enable (Workspace)")), undefined, true, () => {
+    })), ( new Action(`${idPrefix}.enableForWorkspace`, ( localize(6795, "Enable (Workspace)")), undefined, true, () => {
         enablementModel.setEnabled(key, ContributionEnablementState.EnabledWorkspace);
         return Promise.resolve();
-    })), ( new Action(`${idPrefix}.disable`, ( localize(6726, "Disable")), undefined, true, () => {
+    })), ( new Action(`${idPrefix}.disable`, ( localize(6796, "Disable")), undefined, true, () => {
         enablementModel.setEnabled(key, ContributionEnablementState.DisabledProfile);
         return Promise.resolve();
-    })), ( new Action(`${idPrefix}.disableForWorkspace`, ( localize(6727, "Disable (Workspace)")), undefined, true, () => {
+    })), ( new Action(`${idPrefix}.disableForWorkspace`, ( localize(6797, "Disable (Workspace)")), undefined, true, () => {
         enablementModel.setEnabled(key, ContributionEnablementState.DisabledWorkspace);
         return Promise.resolve();
     }))];

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

@@ -46,8 +46,8 @@ let EnablementStatusWidget = class EnablementStatusWidget extends Disposable {
 };
 EnablementStatusWidget = ( __decorate([( __param(3, IMarkdownRendererService))], EnablementStatusWidget));
 const pluginEnablementLabels = {
-    disabledProfile: ( localize(6728, "This plugin is disabled.")),
-    disabledWorkspace: ( localize(6729, "This plugin is disabled for this workspace."))
+    disabledProfile: ( localize(6798, "This plugin is disabled.")),
+    disabledWorkspace: ( localize(6799, "This plugin is disabled for this workspace."))
 };
 
 export { EnablementStatusWidget, pluginEnablementLabels };

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

@@ -0,0 +1,51 @@
+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 { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.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 { IExtensionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service";
+import { ILanguageModelsConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelsConfiguration.service";
+/**
+ * Owns the `github.copilot.hasByokModels` context key. The key is true iff:
+ *  - `github.copilot.clientByokEnabled` is true (set by `ChatEntitlementService` + Copilot extension),
+ *  - `chat.offlineByok` is enabled and `chat.aiDisabled` is off, and
+ *  - the `LanguageModelsService` has at least one resolved, user-selectable non-Copilot model
+ *    (signalled by the `chatNonCopilotModelsAreUserSelectable` context key).
+ *
+ * Verifying the last condition is expensive: it requires activating each BYOK-contributing
+ * extension and round-tripping into its provider. To avoid paying that cost just to gate UI,
+ * this contribution never triggers such activations itself. The strategy is:
+ *
+ *  1. On startup, optimistically restore the last persisted answer from
+ *     `chat.hasByokModels.lastKnown` so UI surfaces gated by this key are correct on warm
+ *     reload before anything else runs.
+ *  2. Whenever the `chatNonCopilotModelsAreUserSelectable` signal flips on — which happens
+ *     naturally when something else resolves a BYOK vendor (notably `ChatInputPart`, which
+ *     activates the previously selected model's vendor when restoring its persisted selection) —
+ *     record `true` and persist it.
+ *  3. Once extensions are fully scanned, if there are no configured non-Copilot vendors in the
+ *     language-models configuration, override a stale optimistic `true` with `false`. Same on
+ *     runtime removal of all groups, and when the feature flag flips off.
+ *
+ * The trade-off is the first-time experience: a brand-new user must pick a BYOK model once
+ * before this contribution observes the signal and persists the answer. From then on, the
+ * answer survives reloads without any activation cost — users without BYOK pay nothing.
+ *
+ * Eager so the key is bound at workbench startup before any sign-in UI surfaces render.
+ */
+export declare class HasByokModelsContribution extends Disposable implements IWorkbenchContribution {
+    private readonly _languageModelsConfigurationService;
+    private readonly _contextKeyService;
+    private readonly _configurationService;
+    private readonly _storageService;
+    static readonly ID = "workbench.contrib.hasByokModels";
+    private static readonly STORAGE_KEY_LAST_KNOWN;
+    private static readonly TRACKED_KEYS;
+    private readonly _hasByokModels;
+    private _extensionsRegistered;
+    constructor(_languageModelsConfigurationService: ILanguageModelsConfigurationService, _contextKeyService: IContextKeyService, _configurationService: IConfigurationService, _storageService: IStorageService, extensionService: IExtensionService);
+    private _isFeatureEnabled;
+    private _restore;
+    private _setResult;
+    private _update;
+}

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

@@ -0,0 +1,106 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+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 { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { StorageScope, StorageTarget } 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 { 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 { 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';
+
+var HasByokModelsContribution_1;
+let HasByokModelsContribution = class HasByokModelsContribution extends Disposable {
+    static {
+        HasByokModelsContribution_1 = this;
+    }
+    static {
+        this.ID = "workbench.contrib.hasByokModels";
+    }
+    static {
+        this.STORAGE_KEY_LAST_KNOWN = "chat.hasByokModels.lastKnown";
+    }
+    static {
+        this.TRACKED_KEYS = ( new Set([
+            ChatEntitlementContextKeys.clientByokEnabled.key,
+            ChatContextKeys.nonCopilotLanguageModelsAreUserSelectable.key
+        ]));
+    }
+    constructor(
+        _languageModelsConfigurationService,
+        _contextKeyService,
+        _configurationService,
+        _storageService,
+        extensionService
+    ) {
+        super();
+        this._languageModelsConfigurationService = _languageModelsConfigurationService;
+        this._contextKeyService = _contextKeyService;
+        this._configurationService = _configurationService;
+        this._storageService = _storageService;
+        this._extensionsRegistered = false;
+        this._hasByokModels = ChatEntitlementContextKeys.hasByokModels.bindTo(this._contextKeyService);
+        this._restore();
+        this._update();
+        extensionService.whenInstalledExtensionsRegistered().then(() => {
+            if (!this._store.isDisposed) {
+                this._extensionsRegistered = true;
+                this._update();
+            }
+        });
+        this._register(Event.any(Event.filter(
+            this._configurationService.onDidChangeConfiguration,
+            e => e.affectsConfiguration(ChatConfiguration.OfflineByok) || e.affectsConfiguration(ChatConfiguration.AIDisabled)
+        ), 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._configurationService.getValue(ChatConfiguration.OfflineByok) && !!this._contextKeyService.getContextKeyValue(ChatEntitlementContextKeys.clientByokEnabled.key);
+    }
+    _restore() {
+        if (!this._isFeatureEnabled()) {
+            this._hasByokModels.set(false);
+            return;
+        }
+        this._hasByokModels.set(this._storageService.getBoolean(
+            HasByokModelsContribution_1.STORAGE_KEY_LAST_KNOWN,
+            StorageScope.APPLICATION,
+            false
+        ));
+    }
+    _setResult(value) {
+        this._hasByokModels.set(value);
+        this._storageService.store(
+            HasByokModelsContribution_1.STORAGE_KEY_LAST_KNOWN,
+            value,
+            StorageScope.APPLICATION,
+            StorageTarget.MACHINE
+        );
+    }
+    _update() {
+        if (!this._isFeatureEnabled()) {
+            this._setResult(false);
+            return;
+        }
+        if (this._contextKeyService.getContextKeyValue(ChatContextKeys.nonCopilotLanguageModelsAreUserSelectable.key)) {
+            this._setResult(true);
+            return;
+        }
+        if (!this._extensionsRegistered) {
+            return;
+        }
+        const hasByokVendor = ( this._languageModelsConfigurationService.getLanguageModelsProviderGroups().some(g => g.vendor !== COPILOT_VENDOR_ID));
+        if (!hasByokVendor) {
+            this._setResult(false);
+        }
+    }
+};
+HasByokModelsContribution = HasByokModelsContribution_1 = ( __decorate([( __param(0, ILanguageModelsConfigurationService)), ( __param(1, IContextKeyService)), ( __param(2, IConfigurationService)), ( __param(3, IStorageService)), ( __param(4, IExtensionService))], HasByokModelsContribution));
+
+export { HasByokModelsContribution };

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

@@ -44,7 +44,9 @@ let LanguageModelsConfigurationService = class LanguageModelsConfigurationServic
         this.languageModelsProviderGroups = [];
         this.modelsConfigurationFile = uriIdentityService.extUri.joinPath(userDataProfileService.currentProfile.location, "chatLanguageModels.json");
         this.updateLanguageModelsConfiguration();
-        this._register(fileService.watch(this.modelsConfigurationFile));
+        this._register(
+            fileService.watch(uriIdentityService.extUri.dirname(this.modelsConfigurationFile))
+        );
         this._register(fileService.onDidFilesChange(e => {
             if (e.contains(this.modelsConfigurationFile)) {
                 this.updateLanguageModelsConfiguration();
@@ -340,7 +342,7 @@ let ChatLanguageModelsDataContribution = class ChatLanguageModelsDataContributio
                     },
                     settings: {
                         type: "object",
-                        description: ( localize(6730, "Per-model settings"))
+                        description: ( localize(6800, "Per-model settings"))
                     }
                 },
                 allOf: [...( vendors.map(vendor => ({

package/vscode/src/vs/workbench/contrib/chat/browser/planReviewFeedback/planReviewFeedbackEditorActions.js

@@ -34,7 +34,7 @@ class NavigatePlanReviewFeedbackAction extends Action2 {
     constructor(_next) {
         super({
             id: _next ? navigateNextPlanReviewFeedbackActionId : navigatePreviousPlanReviewFeedbackActionId,
-            title: _next ? ( localize2(6731, "Go to Next Feedback Comment")) : ( localize2(6732, "Go to Previous Feedback Comment")),
+            title: _next ? ( localize2(6801, "Go to Next Feedback Comment")) : ( localize2(6802, "Go to Previous Feedback Comment")),
             icon: _next ? Codicon.arrowDown : Codicon.arrowUp,
             category: CHAT_CATEGORY,
             f1: true,
@@ -73,8 +73,8 @@ class ClearAllPlanReviewFeedbackAction extends Action2 {
     constructor() {
         super({
             id: clearAllPlanReviewFeedbackActionId,
-            title: ( localize2(6733, "Clear")),
-            tooltip: ( localize2(6734, "Clear All Feedback")),
+            title: ( localize2(6803, "Clear")),
+            tooltip: ( localize2(6804, "Clear All Feedback")),
             icon: Codicon.clearAll,
             category: CHAT_CATEGORY,
             f1: true,
@@ -111,7 +111,7 @@ function registerPlanReviewFeedbackEditorActions() {
     MenuRegistry.appendMenuItem(PlanReviewFeedbackMenuId, {
         command: {
             id: navigationBearingFakeActionId,
-            title: ( localize(6735, "Navigation Status")),
+            title: ( localize(6805, "Navigation Status")),
             precondition: ( ContextKeyExpr.false())
         },
         group: "navigate",