@codingame/monaco-vscode-api 22.1.8 → 23.0.0

package/vscode/src/vs/workbench/services/accounts/common/defaultAccount.js

@@ -9,6 +9,7 @@ import { registerAction2, Action2 } from '../../../../platform/actions/common/ac
 import { localize } from '../../../../nls.js';
 import '../../../../base/common/async.js';
 import { getErrorMessage } from '../../../../base/common/errors.js';
+import { isString } from '../../../../base/common/types.js';
 
 const DEFAULT_ACCOUNT_SIGN_IN_COMMAND = 'workbench.actions.accounts.signIn';
 var DefaultAccountStatus;
@@ -45,37 +46,47 @@ class NullDefaultAccountService extends Disposable {
         this.initialize();
     }
     async initialize() {
+        this.logService.debug('[DefaultAccount] Starting initialization');
         if (!this.productService.defaultAccount) {
+            this.logService.debug('[DefaultAccount] No default account configuration in product service, skipping initialization');
+            return;
+        }
+        const defaultAccountProviderId = this.getDefaultAccountProviderId();
+        this.logService.debug('[DefaultAccount] Default account provider ID:', defaultAccountProviderId);
+        if (!defaultAccountProviderId) {
             return;
         }
-        const { authenticationProvider, tokenEntitlementUrl, chatEntitlementUrl, mcpRegistryDataUrl } = this.productService.defaultAccount;
         await this.extensionService.whenInstalledExtensionsRegistered();
-        const declaredProvider = this.authenticationService.declaredProviders.find(provider => provider.id === authenticationProvider.id);
+        this.logService.debug('[DefaultAccount] Installed extensions registered.');
+        const declaredProvider = this.authenticationService.declaredProviders.find(provider => provider.id === defaultAccountProviderId);
         if (!declaredProvider) {
-            this.logService.info(`Default account authentication provider ${authenticationProvider} is not declared.`);
+            this.logService.info(`[DefaultAccount] Authentication provider is not declared.`, defaultAccountProviderId);
             return;
         }
-        this.registerSignInAction(authenticationProvider.id, declaredProvider.label, authenticationProvider.enterpriseProviderId, authenticationProvider.enterpriseProviderConfig, authenticationProvider.scopes);
-        this.setDefaultAccount(await this.getDefaultAccountFromAuthenticatedSessions(authenticationProvider.id, authenticationProvider.enterpriseProviderId, authenticationProvider.enterpriseProviderConfig, authenticationProvider.scopes, tokenEntitlementUrl, chatEntitlementUrl, mcpRegistryDataUrl));
+        this.registerSignInAction(defaultAccountProviderId, this.productService.defaultAccount.authenticationProvider.scopes);
+        this.setDefaultAccount(await this.getDefaultAccountFromAuthenticatedSessions(defaultAccountProviderId, this.productService.defaultAccount.authenticationProvider.scopes));
         this._register(this.authenticationService.onDidChangeSessions(async (e) => {
-            if (e.providerId !== authenticationProvider.id && e.providerId !== authenticationProvider.enterpriseProviderId) {
+            if (e.providerId !== this.getDefaultAccountProviderId()) {
                 return;
             }
             if (this.defaultAccount && e.event.removed?.some(session => session.id === this.defaultAccount?.sessionId)) {
                 this.setDefaultAccount(null);
                 return;
             }
-            this.setDefaultAccount(await this.getDefaultAccountFromAuthenticatedSessions(authenticationProvider.id, authenticationProvider.enterpriseProviderId, authenticationProvider.enterpriseProviderConfig, authenticationProvider.scopes, tokenEntitlementUrl, chatEntitlementUrl, mcpRegistryDataUrl));
+            this.setDefaultAccount(await this.getDefaultAccountFromAuthenticatedSessions(defaultAccountProviderId, this.productService.defaultAccount.authenticationProvider.scopes));
         }));
+        this.logService.debug('[DefaultAccount] Initialization complete');
     }
     setDefaultAccount(account) {
         this.defaultAccount = account;
         this.defaultAccountService.setDefaultAccount(this.defaultAccount);
         if (this.defaultAccount) {
             this.accountStatusContext.set(DefaultAccountStatus.Available);
+            this.logService.debug('[DefaultAccount] Account status set to Available');
         }
         else {
             this.accountStatusContext.set(DefaultAccountStatus.Unavailable);
+            this.logService.debug('[DefaultAccount] Account status set to Unavailable');
         }
     }
     extractFromToken(token) {
@@ -86,37 +97,49 @@ class NullDefaultAccountService extends Disposable {
             const [key, value] = field.split('=');
             result.set(key, value);
         }
-        this.logService.trace(`DefaultAccount#extractFromToken: ${JSON.stringify(Object.fromEntries(result))}`);
+        this.logService.debug(`[DefaultAccount] extractFromToken: ${JSON.stringify(Object.fromEntries(result))}`);
         return result;
     }
-    async getDefaultAccountFromAuthenticatedSessions(authProviderId, enterpriseAuthProviderId, enterpriseAuthProviderConfig, scopes, tokenEntitlementUrl, chatEntitlementUrl, mcpRegistryDataUrl) {
-        const id = this.configurationService.getValue(enterpriseAuthProviderConfig) === enterpriseAuthProviderId ? enterpriseAuthProviderId : authProviderId;
-        const sessions = await this.authenticationService.getSessions(id, undefined, undefined, true);
-        const session = sessions.find(s => this.scopesMatch(s.scopes, scopes));
-        if (!session) {
+    async getDefaultAccountFromAuthenticatedSessions(authProviderId, scopes) {
+        try {
+            this.logService.debug('[DefaultAccount] Getting Default Account from authenticated sessions for provider:', authProviderId);
+            const sessions = await this.authenticationService.getSessions(authProviderId, undefined, undefined, true);
+            const session = sessions.find(s => this.scopesMatch(s.scopes, scopes));
+            if (!session) {
+                this.logService.debug('[DefaultAccount] No matching session found for provider:', authProviderId);
+                return null;
+            }
+            const [chatEntitlements, tokenEntitlements] = await Promise.all([
+                this.getChatEntitlements(session.accessToken),
+                this.getTokenEntitlements(session.accessToken),
+            ]);
+            const mcpRegistryProvider = tokenEntitlements.mcp ? await this.getMcpRegistryProvider(session.accessToken) : undefined;
+            const account = {
+                sessionId: session.id,
+                enterprise: this.isEnterpriseAuthenticationProvider(authProviderId) || session.account.label.includes('_'),
+                ...chatEntitlements,
+                ...tokenEntitlements,
+                mcpRegistryUrl: mcpRegistryProvider?.url,
+                mcpAccess: mcpRegistryProvider?.registry_access,
+            };
+            this.logService.debug('[DefaultAccount] Successfully created default account for provider:', authProviderId);
+            return account;
+        }
+        catch (error) {
+            this.logService.error('[DefaultAccount] Failed to create default account for provider:', authProviderId, getErrorMessage(error));
             return null;
         }
-        const [chatEntitlements, tokenEntitlements] = await Promise.all([
-            this.getChatEntitlements(session.accessToken, chatEntitlementUrl),
-            this.getTokenEntitlements(session.accessToken, tokenEntitlementUrl),
-        ]);
-        const mcpRegistryProvider = this.productService.quality !== 'stable' && tokenEntitlements.mcp ? await this.getMcpRegistryProvider(session.accessToken, mcpRegistryDataUrl) : undefined;
-        return {
-            sessionId: session.id,
-            enterprise: id === enterpriseAuthProviderId || session.account.label.includes('_'),
-            ...chatEntitlements,
-            ...tokenEntitlements,
-            mcpRegistryUrl: mcpRegistryProvider?.url,
-            mcpAccess: mcpRegistryProvider?.registry_access,
-        };
     }
     scopesMatch(scopes, expectedScopes) {
         return scopes.length === expectedScopes.length && expectedScopes.every(scope => scopes.includes(scope));
     }
-    async getTokenEntitlements(accessToken, tokenEntitlementsUrl) {
+    async getTokenEntitlements(accessToken) {
+        const tokenEntitlementsUrl = this.getTokenEntitlementUrl();
         if (!tokenEntitlementsUrl) {
+            this.logService.debug('[DefaultAccount] No token entitlements URL found');
             return {};
         }
+        this.logService.debug('[DefaultAccount] Fetching token entitlements from:', tokenEntitlementsUrl);
         try {
             const chatContext = await this.requestService.request({
                 type: 'GET',
@@ -142,10 +165,13 @@ class NullDefaultAccountService extends Disposable {
         }
         return {};
     }
-    async getChatEntitlements(accessToken, chatEntitlementsUrl) {
+    async getChatEntitlements(accessToken) {
+        const chatEntitlementsUrl = this.getChatEntitlementUrl();
         if (!chatEntitlementsUrl) {
+            this.logService.debug('[DefaultAccount] No chat entitlements URL found');
             return {};
         }
+        this.logService.debug('[DefaultAccount] Fetching chat entitlements from:', chatEntitlementsUrl);
         try {
             const context = await this.requestService.request({
                 type: 'GET',
@@ -166,8 +192,10 @@ class NullDefaultAccountService extends Disposable {
         }
         return {};
     }
-    async getMcpRegistryProvider(accessToken, mcpRegistryDataUrl) {
+    async getMcpRegistryProvider(accessToken) {
+        const mcpRegistryDataUrl = this.getMcpRegistryDataUrl();
         if (!mcpRegistryDataUrl) {
+            this.logService.debug('[DefaultAccount] No MCP registry data URL found');
             return undefined;
         }
         try {
@@ -184,25 +212,100 @@ class NullDefaultAccountService extends Disposable {
                 this.logService.debug('Fetched MCP registry providers', data.mcp_registries);
                 return data.mcp_registries[0];
             }
-            this.logService.error('Failed to fetch MCP registry providers', 'No data returned');
+            this.logService.debug('Failed to fetch MCP registry providers', 'No data returned');
         }
         catch (error) {
             this.logService.error('Failed to fetch MCP registry providers', getErrorMessage(error));
         }
         return undefined;
     }
-    registerSignInAction(authProviderId, authProviderLabel, enterpriseAuthProviderId, enterpriseAuthProviderConfig, scopes) {
+    getChatEntitlementUrl() {
+        if (!this.productService.defaultAccount) {
+            return undefined;
+        }
+        if (this.isEnterpriseAuthenticationProvider(this.getDefaultAccountProviderId())) {
+            try {
+                const enterpriseUrl = this.getEnterpriseUrl();
+                if (!enterpriseUrl) {
+                    return undefined;
+                }
+                return `${enterpriseUrl.protocol}//api.${enterpriseUrl.hostname}${enterpriseUrl.port ? ':' + enterpriseUrl.port : ''}/copilot_internal/user`;
+            }
+            catch (error) {
+                this.logService.error(error);
+            }
+        }
+        return this.productService.defaultAccount?.chatEntitlementUrl;
+    }
+    getTokenEntitlementUrl() {
+        if (!this.productService.defaultAccount) {
+            return undefined;
+        }
+        if (this.isEnterpriseAuthenticationProvider(this.getDefaultAccountProviderId())) {
+            try {
+                const enterpriseUrl = this.getEnterpriseUrl();
+                if (!enterpriseUrl) {
+                    return undefined;
+                }
+                return `${enterpriseUrl.protocol}//api.${enterpriseUrl.hostname}${enterpriseUrl.port ? ':' + enterpriseUrl.port : ''}/copilot_internal/v2/token`;
+            }
+            catch (error) {
+                this.logService.error(error);
+            }
+        }
+        return this.productService.defaultAccount?.tokenEntitlementUrl;
+    }
+    getMcpRegistryDataUrl() {
+        if (!this.productService.defaultAccount) {
+            return undefined;
+        }
+        if (this.isEnterpriseAuthenticationProvider(this.getDefaultAccountProviderId())) {
+            try {
+                const enterpriseUrl = this.getEnterpriseUrl();
+                if (!enterpriseUrl) {
+                    return undefined;
+                }
+                return `${enterpriseUrl.protocol}//api.${enterpriseUrl.hostname}${enterpriseUrl.port ? ':' + enterpriseUrl.port : ''}/copilot/mcp_registry`;
+            }
+            catch (error) {
+                this.logService.error(error);
+            }
+        }
+        return this.productService.defaultAccount?.mcpRegistryDataUrl;
+    }
+    getDefaultAccountProviderId() {
+        if (this.productService.defaultAccount && this.configurationService.getValue(this.productService.defaultAccount.authenticationProvider.enterpriseProviderConfig) === this.productService.defaultAccount?.authenticationProvider.enterpriseProviderId) {
+            return this.productService.defaultAccount?.authenticationProvider.enterpriseProviderId;
+        }
+        return this.productService.defaultAccount?.authenticationProvider.id;
+    }
+    isEnterpriseAuthenticationProvider(providerId) {
+        if (!providerId) {
+            return false;
+        }
+        return providerId === this.productService.defaultAccount?.authenticationProvider.enterpriseProviderId;
+    }
+    getEnterpriseUrl() {
+        if (!this.productService.defaultAccount) {
+            return undefined;
+        }
+        const value = this.configurationService.getValue(this.productService.defaultAccount.authenticationProvider.enterpriseProviderUriSetting);
+        if (!isString(value)) {
+            return undefined;
+        }
+        return ( new URL(value));
+    }
+    registerSignInAction(authProviderId, scopes) {
         const that = this;
         this._register(registerAction2(class extends Action2 {
             constructor() {
                 super({
                     id: DEFAULT_ACCOUNT_SIGN_IN_COMMAND,
-                    title: ( localize(13056, "Sign in to {0}", authProviderLabel)),
+                    title: ( localize(13367, "Sign in")),
                 });
             }
             run() {
-                const id = that.configurationService.getValue(enterpriseAuthProviderConfig) === enterpriseAuthProviderId ? enterpriseAuthProviderId : authProviderId;
-                return that.authenticationService.createSession(id, scopes);
+                return that.authenticationService.createSession(authProviderId, scopes);
             }
         }));
     }

package/vscode/src/vs/workbench/services/activity/common/activity.service.d.ts

@@ -1,7 +1,7 @@
 import { Event } from "../../../../base/common/event.js";
 import { IDisposable } from "../../../../base/common/lifecycle.js";
 import { ViewContainer } from "../../../common/views.js";
-import { IActivity } from "@codingame/monaco-vscode-d941ac7b-412f-57e3-b1bf-f6b0eb253b21-common/vscode/vs/workbench/services/activity/common/activity";
+import { IActivity } from "@codingame/monaco-vscode-3b5a5cd1-d4ff-500a-b609-57e0cd4afa0a-common/vscode/vs/workbench/services/activity/common/activity";
 export declare const IActivityService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IActivityService>;
 export interface IActivityService {
     readonly _serviceBrand: undefined;

package/vscode/src/vs/workbench/services/assignment/common/assignmentService.d.ts

@@ -0,0 +1,36 @@
+import { IInstantiationService } from "../../../../platform/instantiation/common/instantiation.js";
+import { ITelemetryService } from "../../../../platform/telemetry/common/telemetry.service.js";
+import { IStorageService } from "../../../../platform/storage/common/storage.service.js";
+import { IConfigurationService } from "../../../../platform/configuration/common/configuration.service.js";
+import { IProductService } from "../../../../platform/product/common/productService.service.js";
+import { IAssignmentService } from "../../../../platform/assignment/common/assignment.js";
+import { IWorkbenchEnvironmentService } from "../../environment/common/environmentService.service.js";
+import { Disposable } from "../../../../base/common/lifecycle.js";
+import { Event } from "../../../../base/common/event.js";
+export interface IAssignmentFilter {
+    exclude(assignment: string): boolean;
+    onDidChange: Event<void>;
+}
+export declare class WorkbenchAssignmentService extends Disposable implements IAssignmentService {
+    private readonly telemetryService;
+    private readonly configurationService;
+    private readonly productService;
+    private readonly instantiationService;
+    readonly _serviceBrand: undefined;
+    private readonly tasClient;
+    private readonly tasSetupDisposables;
+    private networkInitialized;
+    private readonly overrideInitDelay;
+    private readonly telemetry;
+    private readonly keyValueStorage;
+    private readonly experimentsEnabled;
+    private readonly _onDidRefetchAssignments;
+    readonly onDidRefetchAssignments: Event<void>;
+    constructor(telemetryService: ITelemetryService, storageService: IStorageService, configurationService: IConfigurationService, productService: IProductService, environmentService: IWorkbenchEnvironmentService, instantiationService: IInstantiationService);
+    getTreatment<T extends string | number | boolean>(name: string): Promise<T | undefined>;
+    private doGetTreatment;
+    private setupTASClient;
+    private refetchAssignments;
+    getCurrentExperiments(): Promise<string[] | undefined>;
+    addTelemetryAssignmentFilter(filter: IAssignmentFilter): void;
+}

package/vscode/src/vs/workbench/services/assignment/common/assignmentService.service.d.ts

@@ -1,5 +1,7 @@
 import { IAssignmentService } from "../../../../platform/assignment/common/assignment.js";
+import { IAssignmentFilter } from "./assignmentService.js";
 export declare const IWorkbenchAssignmentService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IWorkbenchAssignmentService>;
 export interface IWorkbenchAssignmentService extends IAssignmentService {
     getCurrentExperiments(): Promise<string[] | undefined>;
+    addTelemetryAssignmentFilter(filter: IAssignmentFilter): void;
 }

package/vscode/src/vs/workbench/services/authentication/browser/authenticationMcpService.service.d.ts

@@ -9,7 +9,7 @@ export interface IAuthenticationMcpService {
     * * A session preference is changed (because it's deprecated)
     * * A session preference is removed (because it's deprecated)
     */
-    onDidChangeAccountPreference: Event<{
+    readonly onDidChangeAccountPreference: Event<{
         mcpServerIds: string[];
         providerId: string;
     }>;

package/vscode/src/vs/workbench/services/authentication/common/authentication.service.d.ts

@@ -123,7 +123,7 @@ export interface IAuthenticationExtensionsService {
     * * A session preference is changed (because it's deprecated)
     * * A session preference is removed (because it's deprecated)
     */
-    onDidChangeAccountPreference: Event<{
+    readonly onDidChangeAccountPreference: Event<{
         extensionIds: string[];
         providerId: string;
     }>;

package/vscode/src/vs/workbench/services/chat/common/chatContext.d.ts

@@ -0,0 +1,19 @@
+import { CancellationToken } from "../../../../base/common/cancellation.js";
+import { ThemeIcon } from "../../../../base/common/themables.js";
+import { URI } from "../../../../base/common/uri.js";
+export interface IChatContextItem {
+    icon: ThemeIcon;
+    label: string;
+    modelDescription?: string;
+    handle: number;
+    value?: string;
+}
+export interface IChatContextSupport {
+    supportsResource: boolean;
+    supportsResolve: boolean;
+}
+export interface IChatContextProvider {
+    provideChatContext(options: {}, token: CancellationToken): Promise<IChatContextItem[]>;
+    provideChatContextForResource?(resource: URI, options: {}, token: CancellationToken): Promise<IChatContextItem | undefined>;
+    resolveChatContext?(context: IChatContextItem, token: CancellationToken): Promise<IChatContextItem>;
+}

package/vscode/src/vs/workbench/services/chat/common/chatEntitlementService.d.ts

@@ -114,10 +114,11 @@ interface IChatQuotasAccessor {
 export declare class ChatEntitlementService extends Disposable implements IChatEntitlementService {
     private readonly contextKeyService;
     private readonly configurationService;
+    private readonly telemetryService;
     _serviceBrand: undefined;
     readonly context: Lazy<ChatEntitlementContext> | undefined;
     readonly requests: Lazy<ChatEntitlementRequests> | undefined;
-    constructor(instantiationService: IInstantiationService, productService: IProductService, environmentService: IWorkbenchEnvironmentService, contextKeyService: IContextKeyService, configurationService: IConfigurationService);
+    constructor(instantiationService: IInstantiationService, productService: IProductService, environmentService: IWorkbenchEnvironmentService, contextKeyService: IContextKeyService, configurationService: IConfigurationService, telemetryService: ITelemetryService);
     readonly onDidChangeEntitlement: Event<void>;
     readonly entitlementObs: IObservable<ChatEntitlement>;
     get entitlement(): ChatEntitlement;

package/vscode/src/vs/workbench/services/chat/common/chatEntitlementService.js

@@ -103,11 +103,21 @@ function isAnonymous(configurationService, entitlement, sentiment) {
     }
     return true;
 }
+function logChatEntitlements(state, configurationService, telemetryService) {
+    telemetryService.publicLog2('chatEntitlements', {
+        chatHidden: Boolean(state.hidden),
+        chatDisabled: Boolean(state.disabled),
+        chatEntitlement: state.entitlement,
+        chatRegistered: Boolean(state.registered),
+        chatAnonymous: isAnonymous(configurationService, state.entitlement, state)
+    });
+}
 let ChatEntitlementService = class ChatEntitlementService extends Disposable {
-    constructor(instantiationService, productService, environmentService, contextKeyService, configurationService) {
+    constructor(instantiationService, productService, environmentService, contextKeyService, configurationService, telemetryService) {
         super();
         this.contextKeyService = contextKeyService;
         this.configurationService = configurationService;
+        this.telemetryService = telemetryService;
         this._onDidChangeQuotaExceeded = this._register(( new Emitter()));
         this.onDidChangeQuotaExceeded = this._onDidChangeQuotaExceeded.event;
         this._onDidChangeQuotaRemaining = this._register(( new Emitter()));
@@ -123,6 +133,7 @@ let ChatEntitlementService = class ChatEntitlementService extends Disposable {
         this.chatQuotaExceededContextKey = ChatEntitlementContextKeys.chatQuotaExceeded.bindTo(this.contextKeyService);
         this.completionsQuotaExceededContextKey = ChatEntitlementContextKeys.completionsQuotaExceeded.bindTo(this.contextKeyService);
         this.anonymousContextKey = ChatEntitlementContextKeys.chatAnonymous.bindTo(this.contextKeyService);
+        this.anonymousContextKey.set(this.anonymous);
         this.onDidChangeEntitlement = ( Event.map(
             Event.filter(this.contextKeyService.onDidChangeContext, e => e.affectsSome(( new Set([
                 ChatEntitlementContextKeys.Entitlement.planPro.key,
@@ -227,6 +238,9 @@ let ChatEntitlementService = class ChatEntitlementService extends Disposable {
             if (newAnonymousUsage !== anonymousUsage) {
                 anonymousUsage = newAnonymousUsage;
                 this.anonymousContextKey.set(newAnonymousUsage);
+                if (this.context?.hasValue) {
+                    logChatEntitlements(this.context.value.state, this.configurationService, this.telemetryService);
+                }
                 this._onDidChangeAnonymous.fire();
             }
         };
@@ -289,7 +303,8 @@ ChatEntitlementService = ( __decorate([
     ( __param(1, IProductService)),
     ( __param(2, IWorkbenchEnvironmentService)),
     ( __param(3, IContextKeyService)),
-    ( __param(4, IConfigurationService))
+    ( __param(4, IConfigurationService)),
+    ( __param(5, ITelemetryService))
 ], ChatEntitlementService));
 let ChatEntitlementRequests = ChatEntitlementRequests_1 = class ChatEntitlementRequests extends Disposable {
     static providerId(configurationService) {
@@ -610,7 +625,7 @@ let ChatEntitlementRequests = ChatEntitlementRequests_1 = class ChatEntitlementR
         };
         const response = await this.request(defaultChat.entitlementSignupLimitedUrl, 'POST', body, sessions, CancellationToken.None);
         if (!response) {
-            const retry = await this.onUnknownSignUpError(( localize(13213, "No response received.")), '[chat entitlement] sign-up: no response');
+            const retry = await this.onUnknownSignUpError(( localize(13527, "No response received.")), '[chat entitlement] sign-up: no response');
             return retry ? this.signUpFree(sessions) : { errorCode: 1 };
         }
         if (response.res.statusCode && response.res.statusCode !== 200) {
@@ -628,7 +643,7 @@ let ChatEntitlementRequests = ChatEntitlementRequests_1 = class ChatEntitlementR
                 catch (error) {
                 }
             }
-            const retry = await this.onUnknownSignUpError(( localize(13214, "Unexpected status code {0}.", response.res.statusCode)), `[chat entitlement] sign-up: unexpected status code ${response.res.statusCode}`);
+            const retry = await this.onUnknownSignUpError(( localize(13528, "Unexpected status code {0}.", response.res.statusCode)), `[chat entitlement] sign-up: unexpected status code ${response.res.statusCode}`);
             return retry ? this.signUpFree(sessions) : { errorCode: response.res.statusCode };
         }
         let responseText = null;
@@ -638,7 +653,7 @@ let ChatEntitlementRequests = ChatEntitlementRequests_1 = class ChatEntitlementR
         catch (error) {
         }
         if (!responseText) {
-            const retry = await this.onUnknownSignUpError(( localize(13215, "Response has no contents.")), '[chat entitlement] sign-up: response has no content');
+            const retry = await this.onUnknownSignUpError(( localize(13529, "Response has no contents.")), '[chat entitlement] sign-up: response has no content');
             return retry ? this.signUpFree(sessions) : { errorCode: 2 };
         }
         let parsedResult = undefined;
@@ -647,7 +662,7 @@ let ChatEntitlementRequests = ChatEntitlementRequests_1 = class ChatEntitlementR
             this.logService.trace(`[chat entitlement] sign-up: response is ${responseText}`);
         }
         catch (err) {
-            const retry = await this.onUnknownSignUpError(( localize(13216, "Invalid response contents.")), `[chat entitlement] sign-up: error parsing response (${err})`);
+            const retry = await this.onUnknownSignUpError(( localize(13530, "Invalid response contents.")), `[chat entitlement] sign-up: error parsing response (${err})`);
             return retry ? this.signUpFree(sessions) : { errorCode: 3 };
         }
         this.update({ entitlement: ChatEntitlement.Free });
@@ -659,11 +674,11 @@ let ChatEntitlementRequests = ChatEntitlementRequests_1 = class ChatEntitlementR
             const { confirmed } = await this.dialogService.confirm({
                 type: Severity$1.Error,
                 message: ( localize(
-                    13217,
+                    13531,
                     "An error occurred while signing up for the GitHub Copilot Free plan. Would you like to try again?"
                 )),
                 detail,
-                primaryButton: ( localize(13218, "Retry"))
+                primaryButton: ( localize(13532, "Retry"))
             });
             return confirmed;
         }
@@ -675,17 +690,17 @@ let ChatEntitlementRequests = ChatEntitlementRequests_1 = class ChatEntitlementR
             this.dialogService.prompt({
                 type: Severity$1.Error,
                 message: ( localize(
-                    13219,
+                    13533,
                     "An error occurred while signing up for the GitHub Copilot Free plan."
                 )),
                 detail: logDetails,
                 buttons: [
                     {
-                        label: ( localize(13220, "OK")),
+                        label: ( localize(13534, "OK")),
                         run: () => { }
                     },
                     {
-                        label: ( localize(13221, "Learn More")),
+                        label: ( localize(13535, "Learn More")),
                         run: () => this.openerService.open(( URI.parse(defaultChat.upgradePlanUrl)))
                     }
                 ]
@@ -694,7 +709,14 @@ let ChatEntitlementRequests = ChatEntitlementRequests_1 = class ChatEntitlementR
     }
     async signIn(options) {
         const providerId = ChatEntitlementRequests_1.providerId(this.configurationService);
-        const scopes = options?.additionalScopes ? distinct([...defaultChat.providerScopes[0], ...options.additionalScopes]) : defaultChat.providerScopes[0];
+        let defaultProviderScopes;
+        if (this.configurationService.getValue('chat.signInWithAlternateScopes') === true) {
+            defaultProviderScopes = defaultChat.providerScopes.at(-1) ?? [];
+        }
+        else {
+            defaultProviderScopes = defaultChat.providerScopes.at(0) ?? [];
+        }
+        const scopes = options?.additionalScopes ? distinct([...defaultProviderScopes, ...options.additionalScopes]) : defaultProviderScopes;
         const session = await this.authenticationService.createSession(providerId, scopes, {
             extraAuthorizeParameters: { get_started_with: 'copilot-vscode' },
             provider: options?.useSocialProvider
@@ -831,13 +853,7 @@ let ChatEntitlementContext = class ChatEntitlementContext extends Disposable {
         this.untrustedContext.set(!!state.untrusted);
         this.registeredContext.set(!!state.registered);
         this.logService.trace(`[chat entitlement context] updateContext(): ${JSON.stringify(state)}`);
-        this.telemetryService.publicLog2('chatEntitlements', {
-            chatHidden: Boolean(state.hidden),
-            chatDisabled: Boolean(state.disabled),
-            chatEntitlement: state.entitlement,
-            chatRegistered: Boolean(state.registered),
-            chatAnonymous: isAnonymous(this.configurationService, state.entitlement, state)
-        });
+        logChatEntitlements(state, this.configurationService, this.telemetryService);
         this._onDidChange.fire();
     }
     suspend() {