@codingame/monaco-vscode-api 30.0.1 → 31.0.0

package/vscode/src/vs/workbench/contrib/webviewPanel/browser/webviewEditor.js

@@ -23,7 +23,7 @@ import { IWorkbenchLayoutService } from '../../../services/layout/browser/layout
 var WebviewEditor_1;
 const CONTEXT_ACTIVE_WEBVIEW_PANEL_ID = ( new RawContextKey("activeWebviewPanelId", "", {
     type: "string",
-    description: ( localize(15217, "The viewType of the currently active webview panel."))
+    description: ( localize(15353, "The viewType of the currently active webview panel."))
 }));
 let WebviewEditor = class WebviewEditor extends EditorPane {
     static {
@@ -153,6 +153,10 @@ let WebviewEditor = class WebviewEditor extends EditorPane {
             this._element.setAttribute("aria-flowto", input.webview.container.id);
             setParentFlowTo(input.webview.container, this._element);
         }
+        const modalEditorContainer = this._editorGroupsService.activeModalEditorPart?.modalElement;
+        const isModal = isHTMLElement(modalEditorContainer) && this._element && modalEditorContainer.contains(this._element);
+        this._clippingContainer = isModal ? undefined : this._workbenchLayoutService.getContainer(this.window, Parts.EDITOR_PART);
+        input.webview.container.style.zIndex = isModal ? "2541" : "";
         this._webviewVisibleDisposables.clear();
         this._webviewVisibleDisposables.add(
             this._editorGroupsService.createEditorDropTarget(input.webview.container, {
@@ -167,14 +171,7 @@ let WebviewEditor = class WebviewEditor extends EditorPane {
         if (!this._element?.isConnected) {
             return;
         }
-        const modalEditorContainer = this._editorGroupsService.activeModalEditorPart?.modalElement;
-        let clippingContainer;
-        if (isHTMLElement(modalEditorContainer)) {
-            clippingContainer = modalEditorContainer;
-        } else {
-            clippingContainer = this._workbenchLayoutService.getContainer(this.window, Parts.EDITOR_PART);
-        }
-        webview.layoutWebviewOverElement(this._element.parentElement, dimension, clippingContainer);
+        webview.layoutWebviewOverElement(this._element.parentElement, dimension, this._clippingContainer);
     }
     trackFocus(webview) {
         const store = ( new DisposableStore());

package/vscode/src/vs/workbench/contrib/welcomeOnboarding/common/onboardingService.service.d.ts

@@ -0,0 +1,13 @@
+import { Event } from "../../../../base/common/event.js";
+export declare const IOnboardingService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IOnboardingService>;
+export interface IOnboardingService {
+    readonly _serviceBrand: undefined;
+    /**
+    * Fires when the onboarding modal is dismissed.
+    */
+    readonly onDidDismiss: Event<void>;
+    /**
+    * Show the onboarding modal.
+    */
+    show(): void;
+}

package/vscode/src/vs/workbench/contrib/welcomeOnboarding/common/onboardingService.service.js

@@ -0,0 +1,6 @@
+
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+
+const IOnboardingService = ( createDecorator("onboardingService"));
+
+export { IOnboardingService };

package/vscode/src/vs/workbench/contrib/welcomeOnboarding/common/onboardingTypes.d.ts

@@ -0,0 +1,52 @@
+import { IProductOnboardingTheme } from "../../../../base/common/product.js";
+/**
+ * Step identifiers for the onboarding walkthrough.
+ */
+export declare enum OnboardingStepId {
+    SignIn = "onboarding.signIn",
+    Personalize = "onboarding.personalize",
+    AiPreference = "onboarding.aiPreference",
+    AgentSessions = "onboarding.agentSessions"
+}
+/**
+ * Returns a localized title for each step.
+ */
+export declare function getOnboardingStepTitle(stepId: OnboardingStepId): string;
+/**
+ * Returns a localized subtitle for each step.
+ */
+export declare function getOnboardingStepSubtitle(stepId: OnboardingStepId): string;
+/**
+ * Ordered step IDs for the onboarding flow.
+ */
+export declare const ONBOARDING_STEPS: readonly OnboardingStepId[];
+/**
+ * Theme option for the onboarding personalization step.
+ * Sourced from product.json via `onboardingThemes`.
+ */
+export type IOnboardingThemeOption = IProductOnboardingTheme;
+/**
+ * AI collaboration preference for the AI style step.
+ */
+export declare enum AiCollaborationMode {
+    CodeFirst = "code-first",
+    Balanced = "balanced",
+    AgentForward = "agent-forward"
+}
+/**
+ * AI collaboration preference option.
+ */
+export interface IAiPreferenceOption {
+    readonly id: AiCollaborationMode;
+    readonly label: string;
+    readonly description: string;
+    readonly icon: string;
+}
+/**
+ * AI collaboration preference options shown in the AI style step.
+ */
+export declare const ONBOARDING_AI_PREFERENCE_OPTIONS: readonly IAiPreferenceOption[];
+/**
+ * Storage key for persisting onboarding completion state.
+ */
+export declare const ONBOARDING_STORAGE_KEY = "welcomeOnboarding.state";

package/vscode/src/vs/workbench/contrib/welcomeOnboarding/common/onboardingTypes.js

@@ -0,0 +1,74 @@
+
+import { localize } from '../../../../nls.js';
+import { isMacintosh } from '../../../../base/common/platform.js';
+
+var OnboardingStepId;
+(function(OnboardingStepId) {
+    OnboardingStepId["SignIn"] = "onboarding.signIn";
+    OnboardingStepId["Personalize"] = "onboarding.personalize";
+    OnboardingStepId["AiPreference"] = "onboarding.aiPreference";
+    OnboardingStepId["AgentSessions"] = "onboarding.agentSessions";
+})(OnboardingStepId || (OnboardingStepId = {}));
+function getOnboardingStepTitle(stepId) {
+    switch (stepId) {
+    case OnboardingStepId.SignIn:
+        return localize(15700, "Sign In");
+    case OnboardingStepId.Personalize:
+        return localize(15701, "Make It Yours");
+    case OnboardingStepId.AiPreference:
+        return localize(15702, "Your AI Style");
+    case OnboardingStepId.AgentSessions:
+        return localize(15703, "Meet Your Agentic Coding Partner");
+    }
+}
+function getOnboardingStepSubtitle(stepId) {
+    switch (stepId) {
+    case OnboardingStepId.SignIn:
+        return localize(15704, "Sync settings, unlock AI features, and connect to GitHub");
+    case OnboardingStepId.Personalize:
+        return localize(15705, "Choose your theme and keyboard mapping");
+    case OnboardingStepId.AiPreference:
+        return localize(15706, "Choose how much AI collaboration fits your workflow");
+    case OnboardingStepId.AgentSessions:
+        return localize(15707, "Tip: Press {0} to open Chat", isMacintosh ? "⌘⌃I" : "Ctrl+Alt+I");
+    }
+}
+const ONBOARDING_STEPS = [
+    OnboardingStepId.SignIn,
+    OnboardingStepId.Personalize,
+    OnboardingStepId.AgentSessions
+];
+var AiCollaborationMode;
+(function(AiCollaborationMode) {
+    AiCollaborationMode["CodeFirst"] = "code-first";
+    AiCollaborationMode["Balanced"] = "balanced";
+    AiCollaborationMode["AgentForward"] = "agent-forward";
+})(AiCollaborationMode || (AiCollaborationMode = {}));
+const ONBOARDING_AI_PREFERENCE_OPTIONS = [{
+    id: AiCollaborationMode.CodeFirst,
+    label: ( localize(15708, "I Write the Code")),
+    description: ( localize(
+        15709,
+        "AI assists with suggestions and answers questions when you ask. You stay in control of every edit."
+    )),
+    icon: "edit"
+}, {
+    id: AiCollaborationMode.Balanced,
+    label: ( localize(15710, "Side by Side")),
+    description: ( localize(
+        15711,
+        "Inline suggestions plus a chat panel for deeper collaboration. A balance of writing and delegating."
+    )),
+    icon: "layoutSidebarRight"
+}, {
+    id: AiCollaborationMode.AgentForward,
+    label: ( localize(15712, "AI Takes the Lead")),
+    description: ( localize(
+        15713,
+        "Let the agent drive — describe what you want and review the result. Great for scaffolding and exploration."
+    )),
+    icon: "copilot"
+}];
+const ONBOARDING_STORAGE_KEY = "welcomeOnboarding.state";
+
+export { AiCollaborationMode, ONBOARDING_AI_PREFERENCE_OPTIONS, ONBOARDING_STEPS, ONBOARDING_STORAGE_KEY, OnboardingStepId, getOnboardingStepSubtitle, getOnboardingStepTitle };

package/vscode/src/vs/workbench/contrib/workspace/common/workspace.js

@@ -3,8 +3,8 @@ import { localize } from '../../../../nls.js';
 import { RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';
 
 const WorkspaceTrustContext = {
-    IsEnabled: ( new RawContextKey("isWorkspaceTrustEnabled", false, ( localize(15649, "Whether the workspace trust feature is enabled.")))),
-    IsTrusted: ( new RawContextKey("isWorkspaceTrusted", false, ( localize(15650, "Whether the current workspace has been trusted by the user."))))
+    IsEnabled: ( new RawContextKey("isWorkspaceTrustEnabled", false, ( localize(15866, "Whether the workspace trust feature is enabled.")))),
+    IsTrusted: ( new RawContextKey("isWorkspaceTrusted", false, ( localize(15867, "Whether the current workspace has been trusted by the user."))))
 };
 const MANAGE_TRUST_COMMAND_ID = "workbench.trust.manage";
 

package/vscode/src/vs/workbench/services/accounts/browser/defaultAccount.d.ts

@@ -22,7 +22,9 @@ export declare class DefaultAccountService extends Disposable implements IDefaul
     getDefaultAccount(): Promise<IDefaultAccount | null>;
     getDefaultAccountAuthenticationProvider(): IDefaultAccountAuthenticationProvider;
     setDefaultAccountProvider(provider: IDefaultAccountProvider): void;
-    refresh(): Promise<IDefaultAccount | null>;
+    refresh(options?: {
+        forceRefresh?: boolean;
+    }): Promise<IDefaultAccount | null>;
     signIn(options?: {
         additionalScopes?: readonly string[];
         [key: string]: unknown;

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

@@ -247,20 +247,20 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
         }));
         this._register(this.hostService.onDidChangeFocus(focused => {
             if (focused) {
-                this.refetchDefaultAccount(true);
+                this.refetchDefaultAccount();
             }
         }));
     }
-    async refresh() {
+    async refresh(options) {
         if (!this.initialized) {
             await this.initPromise;
             return this.defaultAccount;
         }
         this.logService.debug("[DefaultAccount] Refreshing default account");
-        await this.updateDefaultAccount();
+        await this.updateDefaultAccount(options);
         return this.defaultAccount;
     }
-    async refetchDefaultAccount(useExistingEntitlements) {
+    async refetchDefaultAccount() {
         if (this.accountDataPollScheduler.isScheduled()) {
             this.accountDataPollScheduler.cancel();
         }
@@ -272,14 +272,14 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
             return;
         }
         this.logService.debug("[DefaultAccount] Refetching default account");
-        await this.updateDefaultAccount(useExistingEntitlements);
+        await this.updateDefaultAccount();
     }
-    async updateDefaultAccount(useExistingEntitlements) {
-        await this.updateThrottler.trigger(() => this.doUpdateDefaultAccount(useExistingEntitlements));
+    async updateDefaultAccount(options) {
+        await this.updateThrottler.trigger(() => this.doUpdateDefaultAccount(options));
     }
-    async doUpdateDefaultAccount(useExistingEntitlements = false) {
+    async doUpdateDefaultAccount(options) {
         try {
-            const defaultAccount = await this.fetchDefaultAccount(useExistingEntitlements);
+            const defaultAccount = await this.fetchDefaultAccount(options);
             this.setDefaultAccount(defaultAccount);
             this.scheduleAccountDataPoll();
         } catch (error) {
@@ -289,7 +289,7 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
             );
         }
     }
-    async fetchDefaultAccount(useExistingEntitlements) {
+    async fetchDefaultAccount(options) {
         const defaultAccountProvider = this.getDefaultAccountAuthenticationProvider();
         this.logService.debug("[DefaultAccount] Default account provider ID:", defaultAccountProvider.id);
         const declaredProvider = this.authenticationService.declaredProviders.find(provider => provider.id === defaultAccountProvider.id);
@@ -300,7 +300,7 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
             );
             return null;
         }
-        return await this.getDefaultAccountForAuthenticationProvider(defaultAccountProvider, useExistingEntitlements);
+        return await this.getDefaultAccountForAuthenticationProvider(defaultAccountProvider, options);
     }
     setDefaultAccount(account) {
         if (equals(this._defaultAccount, account)) {
@@ -379,7 +379,7 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
         );
         return result;
     }
-    async getDefaultAccountForAuthenticationProvider(authenticationProvider, useExistingEntitlements) {
+    async getDefaultAccountForAuthenticationProvider(authenticationProvider, options) {
         try {
             this.logService.debug(
                 "[DefaultAccount] Getting Default Account from authenticated sessions for provider:",
@@ -396,7 +396,7 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
                 );
                 return null;
             }
-            return this.getDefaultAccountFromAuthenticatedSessions(authenticationProvider, sessions, useExistingEntitlements);
+            return this.getDefaultAccountFromAuthenticatedSessions(authenticationProvider, sessions, options);
         } catch (error) {
             this.logService.error(
                 "[DefaultAccount] Failed to get default account for provider:",
@@ -406,29 +406,27 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
             return null;
         }
     }
-    async getDefaultAccountFromAuthenticatedSessions(authenticationProvider, sessions, useExistingEntitlements) {
+    async getDefaultAccountFromAuthenticatedSessions(authenticationProvider, sessions, options) {
         try {
             const accountId = sessions[0].account.id;
-            const existingEntitlementsData = this._defaultAccount?.accountId === accountId ? this._defaultAccount?.defaultAccount.entitlementsData : undefined;
             const accountPolicyData = this._policyData?.accountId === accountId ? this._policyData : undefined;
-            const [entitlementsData, tokenEntitlementsResult] = await Promise.all([
-                useExistingEntitlements && existingEntitlementsData ? existingEntitlementsData : this.getEntitlements(sessions),
-                this.getTokenEntitlements(sessions, accountPolicyData)
-            ]);
-            let tokenEntitlementsFetchedAt;
+            const entitlementsResult = await this.getEntitlements(sessions, accountPolicyData, options);
+            const entitlementsData = entitlementsResult?.data;
+            const entitlementsFetchedAt = entitlementsResult?.fetchedAt;
+            const tokenEntitlementsResult = entitlementsData?.chat_enabled ? await this.getTokenEntitlements(sessions, accountPolicyData, options) : undefined;
+            const tokenEntitlementsFetchedAt = tokenEntitlementsResult?.fetchedAt;
             let mcpRegistryDataFetchedAt;
             let policyData = accountPolicyData?.policyData ? {
                 ...accountPolicyData.policyData
             } : undefined;
-            if (tokenEntitlementsResult) {
-                tokenEntitlementsFetchedAt = tokenEntitlementsResult.fetchedAt;
+            if (tokenEntitlementsResult?.data) {
                 const tokenEntitlementsData = tokenEntitlementsResult.data;
                 policyData = policyData ?? {};
                 policyData.chat_agent_enabled = tokenEntitlementsData.policyData.chat_agent_enabled;
                 policyData.chat_preview_features_enabled = tokenEntitlementsData.policyData.chat_preview_features_enabled;
                 policyData.mcp = tokenEntitlementsData.policyData.mcp;
                 if (policyData.mcp) {
-                    const mcpRegistryResult = await this.getMcpRegistryProvider(sessions, accountPolicyData);
+                    const mcpRegistryResult = await this.getMcpRegistryProvider(sessions, accountPolicyData, options);
                     mcpRegistryDataFetchedAt = mcpRegistryResult?.fetchedAt;
                     policyData.mcpRegistryUrl = mcpRegistryResult?.data?.url;
                     policyData.mcpAccess = mcpRegistryResult?.data?.registry_access;
@@ -448,16 +446,18 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
                 "[DefaultAccount] Successfully created default account for provider:",
                 authenticationProvider.id
             );
+            const accountPolicyResult = policyData || entitlementsFetchedAt ? {
+                accountId,
+                policyData: policyData ?? {},
+                entitlementsFetchedAt,
+                tokenEntitlementsFetchedAt,
+                mcpRegistryDataFetchedAt
+            } : null;
             return {
                 defaultAccount,
                 accountId,
-                policyData: policyData ? {
-                    accountId,
-                    policyData,
-                    tokenEntitlementsFetchedAt,
-                    mcpRegistryDataFetchedAt
-                } : null,
-                copilotTokenInfo: tokenEntitlementsResult?.data.copilotTokenInfo ?? null
+                policyData: accountPolicyResult,
+                copilotTokenInfo: tokenEntitlementsResult?.data?.copilotTokenInfo ?? null
             };
         } catch (error) {
             this.logService.error(
@@ -517,8 +517,8 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
     scopesMatch(scopes, expectedScopes) {
         return expectedScopes.every(scope => scopes.includes(scope));
     }
-    async getTokenEntitlements(sessions, accountPolicyData) {
-        if (accountPolicyData?.tokenEntitlementsFetchedAt && !this.isDataStale(accountPolicyData.tokenEntitlementsFetchedAt)) {
+    async getTokenEntitlements(sessions, accountPolicyData, options) {
+        if (!options?.forceRefresh && accountPolicyData?.tokenEntitlementsFetchedAt && !this.isDataStale(accountPolicyData.tokenEntitlementsFetchedAt)) {
             this.logService.debug("[DefaultAccount] Using last fetched token entitlements data");
             return {
                 data: {
@@ -529,10 +529,10 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
             };
         }
         const data = await this.requestTokenEntitlements(sessions);
-        return data ? {
+        return {
             data,
             fetchedAt: Date.now()
-        } : undefined;
+        };
     }
     async requestTokenEntitlements(sessions) {
         const tokenEntitlementsUrl = this.getTokenEntitlementUrl();
@@ -566,7 +566,7 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
                     policyData: {
                         chat_preview_features_enabled: tokenMap.get("editor_preview_features") !== "0",
                         chat_agent_enabled: tokenMap.get("agent_mode") !== "0",
-                        mcp: tokenMap.get("mcp") !== "0"
+                        mcp: tokenMap.get("mcp") === "1"
                     },
                     copilotTokenInfo: {
                         sn: tokenMap.get("sn"),
@@ -580,11 +580,23 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
         }
         return undefined;
     }
-    async getEntitlements(sessions) {
+    async getEntitlements(sessions, accountPolicyData, options) {
+        const accountId = sessions[0].account.id;
+        const existingData = this._defaultAccount?.accountId === accountId ? this._defaultAccount?.defaultAccount.entitlementsData : undefined;
+        if (!options?.forceRefresh && existingData && accountPolicyData?.entitlementsFetchedAt && !this.isDataStale(accountPolicyData.entitlementsFetchedAt)) {
+            this.logService.debug("[DefaultAccount] Using last fetched entitlements data");
+            return {
+                data: existingData,
+                fetchedAt: accountPolicyData.entitlementsFetchedAt
+            };
+        }
         const entitlementUrl = this.getEntitlementUrl();
         if (!entitlementUrl) {
             this.logService.debug("[DefaultAccount] No chat entitlements URL found");
-            return undefined;
+            return {
+                data: undefined,
+                fetchedAt: undefined
+            };
         }
         this.logService.debug("[DefaultAccount] Fetching entitlements from:", entitlementUrl);
         const response = await this.request(
@@ -596,30 +608,42 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
             "defaultAccount.entitlements"
         );
         if (!response) {
-            return undefined;
+            return {
+                data: undefined,
+                fetchedAt: Date.now()
+            };
         }
         if (response.res.statusCode && response.res.statusCode !== 200) {
             this.logService.trace(
                 `[DefaultAccount] unexpected status code ${response.res.statusCode} while fetching entitlements`
             );
-            return (
-                (
-                response.res.statusCode === 401 || response.res.statusCode === 404) ? null : undefined
-            );
+            const data =
+            (
+            response.res.statusCode === 401 || response.res.statusCode === 404) ? null : undefined;
+            return {
+                data,
+                fetchedAt: Date.now()
+            };
         }
         try {
             const data = await asJson(response);
             if (data) {
-                return data;
+                return {
+                    data,
+                    fetchedAt: Date.now()
+                };
             }
             this.logService.error("[DefaultAccount] Failed to fetch entitlements", "No data returned");
         } catch (error) {
             this.logService.error("[DefaultAccount] Failed to fetch entitlements", getErrorMessage(error));
         }
-        return undefined;
+        return {
+            data: undefined,
+            fetchedAt: Date.now()
+        };
     }
-    async getMcpRegistryProvider(sessions, accountPolicyData) {
-        if (accountPolicyData?.mcpRegistryDataFetchedAt && !this.isDataStale(accountPolicyData.mcpRegistryDataFetchedAt)) {
+    async getMcpRegistryProvider(sessions, accountPolicyData, options) {
+        if (!options?.forceRefresh && accountPolicyData?.mcpRegistryDataFetchedAt && !this.isDataStale(accountPolicyData.mcpRegistryDataFetchedAt)) {
             this.logService.debug("[DefaultAccount] Using last fetched MCP registry data");
             const data = accountPolicyData.policyData.mcpRegistryUrl && accountPolicyData.policyData.mcpAccess ? {
                 url: accountPolicyData.policyData.mcpRegistryUrl,
@@ -806,7 +830,7 @@ let DefaultAccountProvider = class DefaultAccountProvider extends Disposable {
         if (!this.defaultAccount) {
             return;
         }
-        this.commandService.executeCommand("_signOutOfAccount", {
+        await this.commandService.executeCommand("_signOutOfAccount", {
             providerId: this.defaultAccount.authenticationProvider.id,
             accountLabel: this.defaultAccount.accountName
         });
@@ -833,7 +857,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: DEFAULT_ACCOUNT_SIGN_IN_COMMAND,
-            title: ( localize2(15657, "Sign In"))
+            title: ( localize2(15874, "Sign In"))
         });
     }
     async run(accessor) {

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

@@ -0,0 +1,17 @@
+import { IDisposable } from "../../../../base/common/lifecycle.js";
+import { IRemoteFilesystemConnection } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/agentHostFileSystemProvider";
+export declare const IAgentHostFileSystemService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IAgentHostFileSystemService>;
+export interface IAgentHostFileSystemService {
+    readonly _serviceBrand: undefined;
+    /**
+    * Register a mapping from a URI authority to a connection so that
+    * `vscode-agent-host://[authority]/…` URIs resolve through this connection.
+    */
+    registerAuthority(authority: string, connection: IRemoteFilesystemConnection): IDisposable;
+    /**
+    * Ensures the in-memory filesystem provider for synced customizations
+    * (`vscode-synced-customization:` scheme) is registered. Called lazily
+    * by {@link SyncedCustomizationBundler} — safe to call multiple times.
+    */
+    ensureSyncedCustomizationProvider(): void;
+}

package/vscode/src/vs/workbench/services/agentHost/common/agentHostFileSystemService.service.js

@@ -0,0 +1,6 @@
+
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+
+const IAgentHostFileSystemService = ( createDecorator("agentHostFileSystemService"));
+
+export { IAgentHostFileSystemService };

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

@@ -58,7 +58,7 @@ export declare class AuthenticationService extends Disposable implements IAuthen
     createSession(id: string, scopeListOrRequest: ReadonlyArray<string> | IAuthenticationWwwAuthenticateRequest, options?: IAuthenticationCreateSessionOptions): Promise<AuthenticationSession>;
     removeSession(id: string, sessionId: string): Promise<void>;
     getOrActivateProviderIdForServer(authorizationServer: URI, resourceServer?: URI): Promise<string | undefined>;
-    createDynamicAuthenticationProvider(authorizationServer: URI, serverMetadata: IAuthorizationServerMetadata, resource: IAuthorizationProtectedResourceMetadata | undefined): Promise<IAuthenticationProvider | undefined>;
+    createDynamicAuthenticationProvider(authorizationServer: URI, serverMetadata: IAuthorizationServerMetadata, resource: IAuthorizationProtectedResourceMetadata | undefined, clientId?: string): Promise<IAuthenticationProvider | undefined>;
     registerAuthenticationProviderHostDelegate(delegate: IAuthenticationProviderHostDelegate): IDisposable;
     private matchesProvider;
     private tryActivateProvider;

package/vscode/src/vs/workbench/services/authentication/browser/authenticationService.js

@@ -42,23 +42,23 @@ const authenticationDefinitionSchema = {
     properties: {
         id: {
             type: "string",
-            description: ( localize(15814, "The id of the authentication provider."))
+            description: ( localize(16031, "The id of the authentication provider."))
         },
         label: {
             type: "string",
-            description: ( localize(15815, "The human readable name of the authentication provider."))
+            description: ( localize(16032, "The human readable name of the authentication provider."))
         },
         authorizationServerGlobs: {
             type: "array",
             items: {
                 type: "string",
                 description: ( localize(
-                    15816,
+                    16033,
                     "A list of globs that match the authorization servers that this provider supports."
                 ))
             },
             description: ( localize(
-                15817,
+                16034,
                 "A list of globs that match the authorization servers that this provider supports."
             ))
         }
@@ -67,7 +67,7 @@ const authenticationDefinitionSchema = {
 const authenticationExtPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: "authentication",
     jsonSchema: {
-        description: ( localize(15818, "Contributes authentication")),
+        description: ( localize(16035, "Contributes authentication")),
         type: "array",
         items: authenticationDefinitionSchema
     },
@@ -145,11 +145,11 @@ let AuthenticationService = class AuthenticationService extends Disposable {
             added.forEach(point => {
                 for (const provider of point.value) {
                     if (isFalsyOrWhitespace(provider.id)) {
-                        point.collector.error(( localize(15819, "An authentication contribution must specify an id.")));
+                        point.collector.error(( localize(16036, "An authentication contribution must specify an id.")));
                         continue;
                     }
                     if (isFalsyOrWhitespace(provider.label)) {
-                        point.collector.error(( localize(15820, "An authentication contribution must specify a label.")));
+                        point.collector.error(( localize(16037, "An authentication contribution must specify a label.")));
                         continue;
                     }
                     if (!( this.declaredProviders.some(p => p.id === provider.id))) {
@@ -157,7 +157,7 @@ let AuthenticationService = class AuthenticationService extends Disposable {
                         this._logService.debug(`Declared authentication provider: ${provider.id}`);
                     } else {
                         point.collector.error(( localize(
-                            15821,
+                            16038,
                             "This authentication id '{0}' has already been registered",
                             provider.id
                         )));
@@ -176,14 +176,14 @@ let AuthenticationService = class AuthenticationService extends Disposable {
     }
     registerDeclaredAuthenticationProvider(provider) {
         if (isFalsyOrWhitespace(provider.id)) {
-            throw ( new Error(( localize(15819, "An authentication contribution must specify an id."))));
+            throw ( new Error(( localize(16036, "An authentication contribution must specify an id."))));
         }
         if (isFalsyOrWhitespace(provider.label)) {
-            throw ( new Error(( localize(15820, "An authentication contribution must specify a label."))));
+            throw ( new Error(( localize(16037, "An authentication contribution must specify a label."))));
         }
         if (( this.declaredProviders.some(p => p.id === provider.id))) {
             throw ( new Error(( localize(
-                15821,
+                16038,
                 "This authentication id '{0}' has already been registered",
                 provider.id
             ))));
@@ -350,13 +350,13 @@ let AuthenticationService = class AuthenticationService extends Disposable {
         }
         return undefined;
     }
-    async createDynamicAuthenticationProvider(authorizationServer, serverMetadata, resource) {
+    async createDynamicAuthenticationProvider(authorizationServer, serverMetadata, resource, clientId) {
         const delegate = this._delegates[0];
         if (!delegate) {
             this._logService.error("No authentication provider host delegate found");
             return undefined;
         }
-        const providerId = await delegate.create(authorizationServer, serverMetadata, resource);
+        const providerId = await delegate.create(authorizationServer, serverMetadata, resource, clientId);
         const provider = this._authenticationProviders.get(providerId);
         if (provider) {
             this._logService.debug(`Created dynamic authentication provider: ${providerId}`);

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

@@ -116,7 +116,7 @@ export interface AllowedExtension {
 export interface IAuthenticationProviderHostDelegate {
     /** Priority for this delegate, delegates are tested in descending priority order */
     readonly priority: number;
-    create(authorizationServer: URI, serverMetadata: IAuthorizationServerMetadata, resource: IAuthorizationProtectedResourceMetadata | undefined): Promise<string>;
+    create(authorizationServer: URI, serverMetadata: IAuthorizationServerMetadata, resource: IAuthorizationProtectedResourceMetadata | undefined, clientId?: string): Promise<string>;
 }
 export declare function isAuthenticationSession(thing: unknown): thing is AuthenticationSession;
 /**

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

@@ -113,7 +113,7 @@ export interface IAuthenticationService {
     * Creates a dynamic authentication provider for the given server metadata
     * @param serverMetadata The metadata for the server that is being authenticated against
     */
-    createDynamicAuthenticationProvider(authorizationServer: URI, serverMetadata: IAuthorizationServerMetadata, resourceMetadata: IAuthorizationProtectedResourceMetadata | undefined): Promise<IAuthenticationProvider | undefined>;
+    createDynamicAuthenticationProvider(authorizationServer: URI, serverMetadata: IAuthorizationServerMetadata, resourceMetadata: IAuthorizationProtectedResourceMetadata | undefined, clientId?: string): Promise<IAuthenticationProvider | undefined>;
 }
 export declare const IAuthenticationExtensionsService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IAuthenticationExtensionsService>;
 export interface IAuthenticationExtensionsService {