@codingame/monaco-vscode-api 21.6.0 → 22.0.1

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

@@ -100,7 +100,7 @@ class NullDefaultAccountService extends Disposable {
             this.getChatEntitlements(session.accessToken, chatEntitlementUrl),
             this.getTokenEntitlements(session.accessToken, tokenEntitlementUrl),
         ]);
-        const mcpRegistryProvider = this.productService.quality !== 'stable' && tokenEntitlements.mcp && this.configurationService.getValue('chat.mcp.enterprise.registry.enabled') === true ? await this.getMcpRegistryProvider(session.accessToken, mcpRegistryDataUrl) : undefined;
+        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('_'),
@@ -197,7 +197,7 @@ class NullDefaultAccountService extends Disposable {
             constructor() {
                 super({
                     id: DEFAULT_ACCOUNT_SIGN_IN_COMMAND,
-                    title: ( localize(12933, "Sign in to {0}", authProviderLabel)),
+                    title: ( localize(13055, "Sign in to {0}", authProviderLabel)),
                 });
             }
             run() {

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-9a5ab9e7-d838-5831-9eb4-e79ea3764dcb-common/vscode/vs/workbench/services/activity/common/activity";
+import { IActivity } from "@codingame/monaco-vscode-d941ac7b-412f-57e3-b1bf-f6b0eb253b21-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/authentication/common/authentication.d.ts

@@ -49,7 +49,7 @@ export interface IAuthenticationCreateSessionOptions {
      */
     [key: string]: any;
 }
-export interface IAuthenticationWWWAuthenticateRequest {
+export interface IAuthenticationWwwAuthenticateRequest {
     /**
      * The raw WWW-Authenticate header value that triggered this challenge.
      * This will be parsed by the authentication provider to extract the necessary
@@ -60,9 +60,9 @@ export interface IAuthenticationWWWAuthenticateRequest {
      * Optional scopes for the session. If not provided, the authentication provider
      * may use default scopes or extract them from the challenge.
      */
-    readonly scopes?: readonly string[];
+    readonly fallbackScopes?: readonly string[];
 }
-export declare function isAuthenticationWWWAuthenticateRequest(obj: unknown): obj is IAuthenticationWWWAuthenticateRequest;
+export declare function isAuthenticationWwwAuthenticateRequest(obj: unknown): obj is IAuthenticationWwwAuthenticateRequest;
 /**
  * Represents constraints for authentication, including challenges and optional scopes.
  * This is used when creating or retrieving sessions that must satisfy specific authentication
@@ -77,7 +77,7 @@ export interface IAuthenticationConstraint {
      * Optional scopes for the session. If not provided, the authentication provider
      * may extract scopes from the challenges or use default scopes.
      */
-    readonly scopes?: readonly string[];
+    readonly fallbackScopes?: readonly string[];
 }
 /**
  * Options for getting authentication sessions via the service.

package/vscode/src/vs/workbench/services/authentication/common/authentication.js

@@ -1,11 +1,11 @@
 
 
 const INTERNAL_AUTH_PROVIDER_PREFIX = '__';
-function isAuthenticationWWWAuthenticateRequest(obj) {
+function isAuthenticationWwwAuthenticateRequest(obj) {
     return typeof obj === 'object'
         && obj !== null
         && 'wwwAuthenticate' in obj
         && (typeof obj.wwwAuthenticate === 'string');
 }
 
-export { INTERNAL_AUTH_PROVIDER_PREFIX, isAuthenticationWWWAuthenticateRequest };
+export { INTERNAL_AUTH_PROVIDER_PREFIX, isAuthenticationWwwAuthenticateRequest };

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

@@ -2,7 +2,7 @@ import { Event } from "../../../../base/common/event.js";
 import { IDisposable } from "../../../../base/common/lifecycle.js";
 import { IAuthorizationServerMetadata, IAuthorizationProtectedResourceMetadata } from "../../../../base/common/oauth.js";
 import { URI } from "../../../../base/common/uri.js";
-import { AuthenticationProviderInformation, AuthenticationSessionsChangeEvent, IAuthenticationProvider, AuthenticationSessionAccount, IAuthenticationWWWAuthenticateRequest, IAuthenticationGetSessionsOptions, AuthenticationSession, IAuthenticationCreateSessionOptions, IAuthenticationProviderHostDelegate } from "./authentication.js";
+import { AuthenticationProviderInformation, AuthenticationSessionsChangeEvent, IAuthenticationProvider, AuthenticationSessionAccount, IAuthenticationWwwAuthenticateRequest, IAuthenticationGetSessionsOptions, AuthenticationSession, IAuthenticationCreateSessionOptions, IAuthenticationProviderHostDelegate } from "./authentication.js";
 export declare const IAuthenticationService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IAuthenticationService>;
 export interface IAuthenticationService {
     readonly _serviceBrand: undefined;
@@ -84,14 +84,14 @@ export interface IAuthenticationService {
     * @param options Additional options for getting sessions
     * @param activateImmediate If true, the provider should activate immediately if it is not already
     */
-    getSessions(id: string, scopeListOrRequest?: ReadonlyArray<string> | IAuthenticationWWWAuthenticateRequest, options?: IAuthenticationGetSessionsOptions, activateImmediate?: boolean): Promise<ReadonlyArray<AuthenticationSession>>;
+    getSessions(id: string, scopeListOrRequest?: ReadonlyArray<string> | IAuthenticationWwwAuthenticateRequest, options?: IAuthenticationGetSessionsOptions, activateImmediate?: boolean): Promise<ReadonlyArray<AuthenticationSession>>;
     /**
     * Creates an AuthenticationSession with the given provider and scopes
     * @param providerId The id of the provider
     * @param scopes The scopes to request
     * @param options Additional options for creating the session
     */
-    createSession(providerId: string, scopeListOrRequest: ReadonlyArray<string> | IAuthenticationWWWAuthenticateRequest, options?: IAuthenticationCreateSessionOptions): Promise<AuthenticationSession>;
+    createSession(providerId: string, scopeListOrRequest: ReadonlyArray<string> | IAuthenticationWwwAuthenticateRequest, options?: IAuthenticationCreateSessionOptions): Promise<AuthenticationSession>;
     /**
     * Removes the session with the given id from the provider with the given id
     * @param providerId The id of the provider
@@ -168,8 +168,8 @@ export interface IAuthenticationExtensionsService {
     * @param scopes
     */
     removeSessionPreference(providerId: string, extensionId: string, scopes: string[]): void;
-    selectSession(providerId: string, extensionId: string, extensionName: string, scopeListOrRequest: ReadonlyArray<string> | IAuthenticationWWWAuthenticateRequest, possibleSessions: readonly AuthenticationSession[]): Promise<AuthenticationSession>;
-    requestSessionAccess(providerId: string, extensionId: string, extensionName: string, scopeListOrRequest: ReadonlyArray<string> | IAuthenticationWWWAuthenticateRequest, possibleSessions: readonly AuthenticationSession[]): void;
-    requestNewSession(providerId: string, scopeListOrRequest: ReadonlyArray<string> | IAuthenticationWWWAuthenticateRequest, extensionId: string, extensionName: string): Promise<void>;
+    selectSession(providerId: string, extensionId: string, extensionName: string, scopeListOrRequest: ReadonlyArray<string> | IAuthenticationWwwAuthenticateRequest, possibleSessions: readonly AuthenticationSession[]): Promise<AuthenticationSession>;
+    requestSessionAccess(providerId: string, extensionId: string, extensionName: string, scopeListOrRequest: ReadonlyArray<string> | IAuthenticationWwwAuthenticateRequest, possibleSessions: readonly AuthenticationSession[]): void;
+    requestNewSession(providerId: string, scopeListOrRequest: ReadonlyArray<string> | IAuthenticationWwwAuthenticateRequest, extensionId: string, extensionName: string): Promise<void>;
     updateNewSessionRequests(providerId: string, addedSessions: readonly AuthenticationSession[]): void;
 }

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

@@ -0,0 +1,286 @@
+import { CancellationToken } from "../../../../base/common/cancellation.js";
+import { Event } from "../../../../base/common/event.js";
+import { Lazy } from "../../../../base/common/lazy.js";
+import { Disposable } from "../../../../base/common/lifecycle.js";
+import { IConfigurationService } from "../../../../platform/configuration/common/configuration.service.js";
+import { RawContextKey } from "../../../../platform/contextkey/common/contextkey.js";
+import { IContextKeyService } from "../../../../platform/contextkey/common/contextkey.service.js";
+import { IDialogService } from "../../../../platform/dialogs/common/dialogs.service.js";
+import { IInstantiationService } from "../../../../platform/instantiation/common/instantiation.js";
+import { ILogService } from "../../../../platform/log/common/log.service.js";
+import { IProductService } from "../../../../platform/product/common/productService.service.js";
+import { IRequestService } from "../../../../platform/request/common/request.service.js";
+import { IStorageService } from "../../../../platform/storage/common/storage.service.js";
+import { ITelemetryService } from "../../../../platform/telemetry/common/telemetry.service.js";
+import { AuthenticationSession } from "../../authentication/common/authentication.js";
+import { IAuthenticationExtensionsService } from "../../authentication/common/authentication.service.js";
+import { IAuthenticationService } from "../../authentication/common/authentication.service.js";
+import { IOpenerService } from "../../../../platform/opener/common/opener.service.js";
+import { IWorkbenchEnvironmentService } from "../../environment/common/environmentService.service.js";
+import { ILifecycleService } from "../../lifecycle/common/lifecycle.service.js";
+import { IObservable } from "../../../../base/common/observable.js";
+import { IChatEntitlementService } from "./chatEntitlementService.service.js";
+export declare namespace ChatEntitlementContextKeys {
+    const Setup: {
+        hidden: RawContextKey<boolean>;
+        installed: RawContextKey<boolean>;
+        disabled: RawContextKey<boolean>;
+        untrusted: RawContextKey<boolean>;
+        later: RawContextKey<boolean>;
+        registered: RawContextKey<boolean>;
+    };
+    const Entitlement: {
+        signedOut: RawContextKey<boolean>;
+        canSignUp: RawContextKey<boolean>;
+        planFree: RawContextKey<boolean>;
+        planPro: RawContextKey<boolean>;
+        planProPlus: RawContextKey<boolean>;
+        planBusiness: RawContextKey<boolean>;
+        planEnterprise: RawContextKey<boolean>;
+        organisations: RawContextKey<string[]>;
+        internal: RawContextKey<boolean>;
+        sku: RawContextKey<string>;
+    };
+    const chatQuotaExceeded: RawContextKey<boolean>;
+    const completionsQuotaExceeded: RawContextKey<boolean>;
+    const chatAnonymous: RawContextKey<boolean>;
+}
+export declare enum ChatEntitlement {
+    /** Signed out */
+    Unknown = 1,
+    /** Signed in but not yet resolved */
+    Unresolved = 2,
+    /** Signed in and entitled to Free */
+    Available = 3,
+    /** Signed in but not entitled to Free */
+    Unavailable = 4,
+    /** Signed-up to Free */
+    Free = 5,
+    /** Signed-up to Pro */
+    Pro = 6,
+    /** Signed-up to Pro Plus */
+    ProPlus = 7,
+    /** Signed-up to Business */
+    Business = 8,
+    /** Signed-up to Enterprise */
+    Enterprise = 9
+}
+export interface IChatSentiment {
+    /**
+     * User has Chat installed.
+     */
+    installed?: boolean;
+    /**
+     * User signals no intent in using Chat.
+     *
+     * Note: in contrast to `disabled`, this should not only disable
+     * Chat but also hide all of its UI.
+     */
+    hidden?: boolean;
+    /**
+     * User signals intent to disable Chat.
+     *
+     * Note: in contrast to `hidden`, this should not hide
+     * Chat but but disable its functionality.
+     */
+    disabled?: boolean;
+    /**
+     * Chat is disabled due to missing workspace trust.
+     *
+     * Note: even though this disables Chat, we want to treat it
+     * different from the `disabled` state that is by explicit
+     * user choice.
+     */
+    untrusted?: boolean;
+    /**
+     * User signals intent to use Chat later.
+     */
+    later?: boolean;
+    /**
+     * User has registered as Free or Pro user.
+     */
+    registered?: boolean;
+}
+/**
+ * Checks the chat entitlements to see if the user falls into the paid category
+ * @param chatEntitlement The chat entitlement to check
+ * @returns Whether or not they are a paid user
+ */
+export declare function isProUser(chatEntitlement: ChatEntitlement): boolean;
+interface IChatQuotasAccessor {
+    clearQuotas(): void;
+    acceptQuotas(quotas: IQuotas): void;
+}
+export declare class ChatEntitlementService extends Disposable implements IChatEntitlementService {
+    private readonly contextKeyService;
+    private readonly configurationService;
+    _serviceBrand: undefined;
+    readonly context: Lazy<ChatEntitlementContext> | undefined;
+    readonly requests: Lazy<ChatEntitlementRequests> | undefined;
+    constructor(instantiationService: IInstantiationService, productService: IProductService, environmentService: IWorkbenchEnvironmentService, contextKeyService: IContextKeyService, configurationService: IConfigurationService);
+    readonly onDidChangeEntitlement: Event<void>;
+    readonly entitlementObs: IObservable<ChatEntitlement>;
+    get entitlement(): ChatEntitlement;
+    get isInternal(): boolean;
+    get organisations(): string[] | undefined;
+    get sku(): string | undefined;
+    private readonly _onDidChangeQuotaExceeded;
+    readonly onDidChangeQuotaExceeded: Event<void>;
+    private readonly _onDidChangeQuotaRemaining;
+    readonly onDidChangeQuotaRemaining: Event<void>;
+    private _quotas;
+    get quotas(): IQuotas;
+    private readonly chatQuotaExceededContextKey;
+    private readonly completionsQuotaExceededContextKey;
+    private ExtensionQuotaContextKeys;
+    private registerListeners;
+    acceptQuotas(quotas: IQuotas): void;
+    private compareQuotas;
+    clearQuotas(): void;
+    private updateContextKeys;
+    readonly onDidChangeSentiment: Event<void>;
+    readonly sentimentObs: IObservable<IChatSentiment>;
+    get sentiment(): IChatSentiment;
+    private readonly anonymousContextKey;
+    private readonly _onDidChangeAnonymous;
+    readonly onDidChangeAnonymous: Event<void>;
+    readonly anonymousObs: IObservable<boolean>;
+    get anonymous(): boolean;
+    update(token: CancellationToken): Promise<void>;
+}
+interface IEntitlements {
+    readonly entitlement: ChatEntitlement;
+    readonly organisations?: string[];
+    readonly sku?: string;
+    readonly quotas?: IQuotas;
+}
+export interface IQuotaSnapshot {
+    readonly total: number;
+    readonly remaining: number;
+    readonly percentRemaining: number;
+    readonly overageEnabled: boolean;
+    readonly overageCount: number;
+    readonly unlimited: boolean;
+}
+export interface IQuotas {
+    readonly resetDate?: string;
+    readonly resetDateHasTime?: boolean;
+    readonly chat?: IQuotaSnapshot;
+    readonly completions?: IQuotaSnapshot;
+    readonly premiumChat?: IQuotaSnapshot;
+}
+export declare class ChatEntitlementRequests extends Disposable {
+    private readonly context;
+    private readonly chatQuotasAccessor;
+    private readonly telemetryService;
+    private readonly authenticationService;
+    private readonly logService;
+    private readonly requestService;
+    private readonly dialogService;
+    private readonly openerService;
+    private readonly configurationService;
+    private readonly authenticationExtensionsService;
+    private readonly lifecycleService;
+    static providerId(configurationService: IConfigurationService): string;
+    private state;
+    private pendingResolveCts;
+    private didResolveEntitlements;
+    constructor(context: ChatEntitlementContext, chatQuotasAccessor: IChatQuotasAccessor, telemetryService: ITelemetryService, authenticationService: IAuthenticationService, logService: ILogService, requestService: IRequestService, dialogService: IDialogService, openerService: IOpenerService, configurationService: IConfigurationService, authenticationExtensionsService: IAuthenticationExtensionsService, lifecycleService: ILifecycleService);
+    private registerListeners;
+    private resolve;
+    private findMatchingProviderSession;
+    private doGetSessions;
+    private includesScopes;
+    private resolveEntitlement;
+    private doResolveEntitlement;
+    private getEntitlementUrl;
+    private toQuotas;
+    private request;
+    private update;
+    forceResolveEntitlement(sessions: AuthenticationSession[] | undefined, token?: Readonly<CancellationToken>): Promise<IEntitlements | undefined>;
+    signUpFree(sessions: AuthenticationSession[]): Promise<true | false | {
+        errorCode: number;
+    }>;
+    private onUnknownSignUpError;
+    private onUnprocessableSignUpError;
+    signIn(options?: {
+        useSocialProvider?: string;
+        additionalScopes?: readonly string[];
+    }): Promise<{
+        session: AuthenticationSession;
+        entitlements: IEntitlements | undefined;
+    }>;
+    dispose(): void;
+}
+export interface IChatEntitlementContextState extends IChatSentiment {
+    /**
+     * Users last known or resolved entitlement.
+     */
+    entitlement: ChatEntitlement;
+    /**
+     * User's last known or resolved raw SKU type.
+     */
+    sku: string | undefined;
+    /**
+     * User's last known or resolved organisations.
+     */
+    organisations: string[] | undefined;
+    /**
+     * User is or was a registered Chat user.
+     */
+    registered?: boolean;
+}
+export declare class ChatEntitlementContext extends Disposable {
+    private readonly storageService;
+    private readonly logService;
+    private readonly configurationService;
+    private readonly telemetryService;
+    private static readonly CHAT_ENTITLEMENT_CONTEXT_STORAGE_KEY;
+    private static readonly CHAT_DISABLED_CONFIGURATION_KEY;
+    private readonly canSignUpContextKey;
+    private readonly signedOutContextKey;
+    private readonly freeContextKey;
+    private readonly proContextKey;
+    private readonly proPlusContextKey;
+    private readonly businessContextKey;
+    private readonly enterpriseContextKey;
+    private readonly organisationsContextKey;
+    private readonly isInternalContextKey;
+    private readonly skuContextKey;
+    private readonly hiddenContext;
+    private readonly laterContext;
+    private readonly installedContext;
+    private readonly disabledContext;
+    private readonly untrustedContext;
+    private readonly registeredContext;
+    private _state;
+    private suspendedState;
+    get state(): IChatEntitlementContextState;
+    private readonly _onDidChange;
+    readonly onDidChange: Event<void>;
+    private updateBarrier;
+    constructor(contextKeyService: IContextKeyService, storageService: IStorageService, logService: ILogService, configurationService: IConfigurationService, telemetryService: ITelemetryService);
+    private registerListeners;
+    private withConfiguration;
+    update(context: {
+        installed: boolean;
+        disabled: boolean;
+        untrusted: boolean;
+    }): Promise<void>;
+    update(context: {
+        hidden: false;
+    }): Promise<void>;
+    update(context: {
+        later: boolean;
+    }): Promise<void>;
+    update(context: {
+        entitlement: ChatEntitlement;
+        organisations: string[] | undefined;
+        sku: string | undefined;
+    }): Promise<void>;
+    private updateContext;
+    private updateContextSync;
+    suspend(): void;
+    resume(): void;
+}
+export {};