@codingame/monaco-vscode-api 30.0.1 → 31.0.1

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

@@ -0,0 +1,65 @@
+import { ICommandService } from "../../../../../platform/commands/common/commands.service.js";
+import { ILogService } from "../../../../../platform/log/common/log.service.js";
+import { IExtensionsWorkbenchService } from "../../../extensions/common/extensions.service.js";
+export type InstallChatClassification = {
+    owner: "bpasero";
+    comment: "Provides insight into chat installation.";
+    installResult: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "Whether the extension was installed successfully, cancelled or failed to install.";
+    };
+    installDuration: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "The duration it took to install the extension.";
+    };
+    signUpErrorCode: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "The error code in case of an error signing up.";
+    };
+    provider: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "The provider used for the chat installation.";
+    };
+};
+export type InstallChatEvent = {
+    installResult: "installed" | "alreadyInstalled" | "cancelled" | "failedInstall" | "failedNotSignedIn" | "failedSignUp" | "failedNotTrusted" | "failedNoSession" | "failedMaybeLater" | "failedEnterpriseSetup";
+    installDuration: number;
+    signUpErrorCode: number | undefined;
+    provider: string | undefined;
+};
+export declare enum ChatSetupAnonymous {
+    Disabled = 0,
+    EnabledWithDialog = 1,
+    EnabledWithoutDialog = 2
+}
+export declare enum ChatSetupStep {
+    Initial = 1,
+    SigningIn = 2,
+    Installing = 3
+}
+export declare enum ChatSetupStrategy {
+    Canceled = 0,
+    DefaultSetup = 1,
+    SetupWithoutEnterpriseProvider = 2,
+    SetupWithEnterpriseProvider = 3,
+    SetupWithGoogleProvider = 4,
+    SetupWithAppleProvider = 5
+}
+export type ChatSetupResultValue = boolean | undefined;
+export interface IChatSetupResult {
+    readonly success: ChatSetupResultValue;
+    readonly dialogSkipped: boolean;
+}
+export declare function refreshTokens(commandService: ICommandService): void;
+/**
+ * Ensures the authentication provider extension is enabled.
+ * If the extension is found locally but disabled, it will be
+ * re-enabled and running extensions will be updated.
+ *
+ * @returns `true` if the extension was re-enabled, `false` otherwise.
+ */
+export declare function maybeEnableAuthExtension(extensionsWorkbenchService: IExtensionsWorkbenchService, logService: ILogService): Promise<boolean>;

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

@@ -0,0 +1,66 @@
+
+import { ExtensionIdentifier } from '../../../../../platform/extensions/common/extensions.js';
+import product from '../../../../../platform/product/common/product.js';
+import { localize } from '../../../../../nls.js';
+import { EnablementState } from '../../../../services/extensionManagement/common/extensionManagement.js';
+
+const defaultChat = {
+    completionsRefreshTokenCommand: product.defaultChatAgent?.completionsRefreshTokenCommand ?? "",
+    chatRefreshTokenCommand: product.defaultChatAgent?.chatRefreshTokenCommand ?? "",
+    providerExtensionId: product.defaultChatAgent?.providerExtensionId ?? ""
+};
+var ChatSetupAnonymous;
+(function(ChatSetupAnonymous) {
+    ChatSetupAnonymous[ChatSetupAnonymous["Disabled"] = 0] = "Disabled";
+    ChatSetupAnonymous[ChatSetupAnonymous["EnabledWithDialog"] = 1] = "EnabledWithDialog";
+    ChatSetupAnonymous[ChatSetupAnonymous["EnabledWithoutDialog"] = 2] = "EnabledWithoutDialog";
+})(ChatSetupAnonymous || (ChatSetupAnonymous = {}));
+var ChatSetupStep;
+(function(ChatSetupStep) {
+    ChatSetupStep[ChatSetupStep["Initial"] = 1] = "Initial";
+    ChatSetupStep[ChatSetupStep["SigningIn"] = 2] = "SigningIn";
+    ChatSetupStep[ChatSetupStep["Installing"] = 3] = "Installing";
+})(ChatSetupStep || (ChatSetupStep = {}));
+var ChatSetupStrategy;
+(function(ChatSetupStrategy) {
+    ChatSetupStrategy[ChatSetupStrategy["Canceled"] = 0] = "Canceled";
+    ChatSetupStrategy[ChatSetupStrategy["DefaultSetup"] = 1] = "DefaultSetup";
+    ChatSetupStrategy[ChatSetupStrategy["SetupWithoutEnterpriseProvider"] = 2] = "SetupWithoutEnterpriseProvider";
+    ChatSetupStrategy[ChatSetupStrategy["SetupWithEnterpriseProvider"] = 3] = "SetupWithEnterpriseProvider";
+    ChatSetupStrategy[ChatSetupStrategy["SetupWithGoogleProvider"] = 4] = "SetupWithGoogleProvider";
+    ChatSetupStrategy[ChatSetupStrategy["SetupWithAppleProvider"] = 5] = "SetupWithAppleProvider";
+})(ChatSetupStrategy || (ChatSetupStrategy = {}));
+function refreshTokens(commandService) {
+    commandService.executeCommand(defaultChat.completionsRefreshTokenCommand);
+    commandService.executeCommand(defaultChat.chatRefreshTokenCommand);
+}
+async function maybeEnableAuthExtension(extensionsWorkbenchService, logService) {
+    if (!defaultChat.providerExtensionId) {
+        return false;
+    }
+    const providerExtension = extensionsWorkbenchService.local.find(
+        e => ExtensionIdentifier.equals(e.identifier.id, defaultChat.providerExtensionId)
+    );
+    if (!providerExtension) {
+        return false;
+    }
+    if (providerExtension.enablementState === EnablementState.DisabledGlobally || providerExtension.enablementState === EnablementState.DisabledWorkspace) {
+        logService.info(
+            `[chat setup] auth provider extension '${defaultChat.providerExtensionId}' is disabled, re-enabling it`
+        );
+        try {
+            await extensionsWorkbenchService.setEnablement([providerExtension], EnablementState.EnabledGlobally);
+            await extensionsWorkbenchService.updateRunningExtensions(( localize(6300, "Enabling GitHub Authentication")));
+            return true;
+        } catch (error) {
+            logService.error(
+                `[chat setup] failed to re-enable auth provider extension '${defaultChat.providerExtensionId}'`,
+                error
+            );
+            return false;
+        }
+    }
+    return false;
+}
+
+export { ChatSetupAnonymous, ChatSetupStep, ChatSetupStrategy, maybeEnableAuthExtension, refreshTokens };

package/vscode/src/vs/workbench/contrib/chat/browser/widgetHosts/editor/chatEditorInput.d.ts

@@ -31,6 +31,7 @@ export declare class ChatEditorInput extends EditorInput implements IEditorClose
     private didTransferOutEditingSession;
     private cachedIcon;
     private readonly modelRef;
+    private readonly _modelChangeListener;
     private get model();
     static getNewEditorUri(): URI;
     constructor(resource: URI, options: IChatEditorOptions, chatService: IChatService, dialogService: IDialogService, chatSessionsService: IChatSessionsService, instantiationService: IInstantiationService);
@@ -53,6 +54,12 @@ export declare class ChatEditorInput extends EditorInput implements IEditorClose
      */
     getSessionType(): string;
     resolve(): Promise<ChatEditorModel | null>;
+    /**
+     * Updates the editor input to track a new model. Called when the widget swaps
+     * from an untitled session to a real session.
+     */
+    updateModel(model: IChatModel): void;
+    private _trackModelChanges;
     private iconsEqual;
 }
 export declare class ChatEditorModel extends Disposable {

package/vscode/src/vs/workbench/contrib/chat/browser/widgetHosts/editor/chatEditorInput.js

@@ -24,7 +24,7 @@ import { ModifiedFileEntryState } from '../../../common/editing/chatEditingServi
 import { LocalChatSessionUri, getChatSessionType } from '../../../common/model/chatUri.js';
 
 var ChatEditorInput_1;
-const ChatEditorIcon = registerIcon("chat-editor-label-icon", Codicon.chatSparkle, ( localize(7139, "Icon of the chat editor label.")));
+const ChatEditorIcon = registerIcon("chat-editor-label-icon", Codicon.chatSparkle, ( localize(7260, "Icon of the chat editor label.")));
 let ChatEditorInput = class ChatEditorInput extends EditorInput {
     static {
         ChatEditorInput_1 = this;
@@ -61,6 +61,7 @@ let ChatEditorInput = class ChatEditorInput extends EditorInput {
         this.instantiationService = instantiationService;
         this.didTransferOutEditingSession = false;
         this.modelRef = this._register(( new MutableDisposable()));
+        this._modelChangeListener = this._register(( new MutableDisposable()));
         this.closeHandler = this;
         if (resource.scheme === Schemas.vscodeChatEditor) {
             const parsed = ChatEditorUri.parse(resource);
@@ -88,8 +89,8 @@ let ChatEditorInput = class ChatEditorInput extends EditorInput {
         if (!this.model?.editingSession || this.didTransferOutEditingSession || this.getSessionType() !== localChatSessionType) {
             return ConfirmResult.SAVE;
         }
-        const titleOverride = ( localize(7140, "Close Chat Editor"));
-        const messageOverride = ( localize(7141, "Closing the chat editor will end your current edit session."));
+        const titleOverride = ( localize(7261, "Close Chat Editor"));
+        const messageOverride = ( localize(7262, "Closing the chat editor will end your current edit session."));
         const result = await showClearEditingSessionConfirmation(this.model, this.dialogService, {
             titleOverride,
             messageOverride
@@ -131,7 +132,7 @@ let ChatEditorInput = class ChatEditorInput extends EditorInput {
         if (this.options.title?.preferred) {
             return this.options.title.preferred;
         }
-        return this.options.title?.fallback ?? ( localize(7142, "Chat"));
+        return this.options.title?.fallback ?? ( localize(7263, "Chat"));
     }
     getTitle(verbosity) {
         const name = this.getName();
@@ -175,27 +176,31 @@ let ChatEditorInput = class ChatEditorInput extends EditorInput {
         const chatSessionType = searchParams.get("chatSessionType");
         const inputType = chatSessionType ?? this.resource.authority;
         if (this._sessionResource) {
-            this.modelRef.value = await this.chatService.acquireOrLoadSession(this._sessionResource, ChatAgentLocation.Chat, CancellationToken.None);
+            this.modelRef.value = await this.chatService.acquireOrLoadSession(
+                this._sessionResource,
+                ChatAgentLocation.Chat,
+                CancellationToken.None,
+                "ChatEditorInput#resolve"
+            );
             if (!this.model && LocalChatSessionUri.parseLocalSessionId(this._sessionResource)) {
                 this.modelRef.value = this.chatService.startNewLocalSession(ChatAgentLocation.Chat, {
-                    canUseTools: true
+                    canUseTools: true,
+                    debugOwner: "ChatEditorInput#resolveNewLocalSession"
                 });
             }
         } else if (!this.options.target) {
             this.modelRef.value = this.chatService.startNewLocalSession(ChatAgentLocation.Chat, {
-                canUseTools: !inputType
+                canUseTools: !inputType,
+                debugOwner: "ChatEditorInput#resolveUntitled"
             });
         } else if (this.options.target.data) {
-            this.modelRef.value = this.chatService.loadSessionFromData(this.options.target.data);
+            this.modelRef.value = this.chatService.loadSessionFromData(this.options.target.data, "ChatEditorInput#resolveImportedData");
         }
         if (!this.model || this.isDisposed()) {
             return null;
         }
         this._sessionResource = this.model.sessionResource;
-        this._register(this.model.onDidChange(e => {
-            this.cachedIcon = undefined;
-            this._onDidChangeLabel.fire();
-        }));
+        this._trackModelChanges();
         const newIcon = this.resolveIcon();
         if (newIcon && (!this.cachedIcon || !this.iconsEqual(this.cachedIcon, newIcon))) {
             this.cachedIcon = newIcon;
@@ -203,6 +208,22 @@ let ChatEditorInput = class ChatEditorInput extends EditorInput {
         this._onDidChangeLabel.fire();
         return this._register(( new ChatEditorModel(this.model)));
     }
+    updateModel(model) {
+        this._sessionResource = model.sessionResource;
+        this.modelRef.value = this.chatService.acquireExistingSession(model.sessionResource, "ChatEditorInput#updateModel");
+        this._trackModelChanges();
+        this.cachedIcon = undefined;
+        this._onDidChangeLabel.fire();
+    }
+    _trackModelChanges() {
+        if (!this.model) {
+            return;
+        }
+        this._modelChangeListener.value = this.model.onDidChange(() => {
+            this.cachedIcon = undefined;
+            this._onDidChangeLabel.fire();
+        });
+    }
     iconsEqual(a, b) {
         if (ThemeIcon.isThemeIcon(a) && ThemeIcon.isThemeIcon(b)) {
             return a.id === b.id;
@@ -295,25 +316,25 @@ async function showClearEditingSessionConfirmation(model, dialogService, options
     if (!undecidedEdits) {
         return true;
     }
-    const defaultPhrase = ( localize(7143, "Starting a new chat will end your current edit session."));
-    const defaultTitle = ( localize(7144, "Start new chat?"));
+    const defaultPhrase = ( localize(7264, "Starting a new chat will end your current edit session."));
+    const defaultTitle = ( localize(7265, "Start new chat?"));
     const phrase = options?.messageOverride ?? defaultPhrase;
     const title = options?.titleOverride ?? defaultTitle;
     const {
         result
     } = await dialogService.prompt({
         title,
-        message: phrase + " " + ( localize(7145, "Do you want to keep pending edits to {0} files?", undecidedEdits)),
+        message: phrase + " " + ( localize(7266, "Do you want to keep pending edits to {0} files?", undecidedEdits)),
         type: "info",
         cancelButton: true,
         buttons: [{
-            label: ( localize(7146, "Keep & Continue")),
+            label: ( localize(7267, "Keep & Continue")),
             run: async () => {
                 await model.editingSession.accept();
                 return true;
             }
         }, {
-            label: ( localize(7147, "Undo & Continue")),
+            label: ( localize(7268, "Undo & Continue")),
             run: async () => {
                 await model.editingSession.reject();
                 return true;

package/vscode/src/vs/workbench/contrib/chat/common/actions/chatContextKeys.d.ts

@@ -8,6 +8,7 @@ export declare namespace ChatContextKeys {
     const responseIsFiltered: RawContextKey<boolean>;
     const responseHasError: RawContextKey<boolean>;
     const requestInProgress: RawContextKey<boolean>;
+    const hasActiveRequest: RawContextKey<boolean>;
     const currentlyEditing: RawContextKey<boolean>;
     const currentlyEditingInput: RawContextKey<boolean>;
     enum EditingRequestType {
@@ -87,9 +88,11 @@ export declare namespace ChatContextKeys {
         hidden: RawContextKey<boolean>;
         installed: RawContextKey<boolean>;
         disabled: RawContextKey<boolean>;
+        disabledInWorkspace: RawContextKey<boolean>;
         untrusted: RawContextKey<boolean>;
         later: RawContextKey<boolean>;
         registered: RawContextKey<boolean>;
+        completed: RawContextKey<boolean>;
     };
     const Entitlement: {
         signedOut: RawContextKey<boolean>;
@@ -145,7 +148,8 @@ export declare namespace ChatContextKeys {
 export declare namespace ChatContextKeyExprs {
     const inEditingMode: import("../../../../../platform/contextkey/common/contextkey.js").ContextKeyExpression | undefined;
     /**
-     * Context expression that indicates when the welcome/setup view should be shown
+     * True when the locked coding agent is an agent host session (agent-host-* or remote-*).
+     * These sessions use AgentHostEditingSession which supports checkpoint-based undo/redo.
      */
-    const chatSetupTriggerContext: import("../../../../../platform/contextkey/common/contextkey.js").ContextKeyExpression | undefined;
+    const isAgentHostSession: import("../../../../../platform/contextkey/common/contextkey.js").ContextKeyExpression | undefined;
 }