@codingame/monaco-vscode-katex-common 25.1.2 → 26.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/actions/chatContinueInAction.js

@@ -10,14 +10,14 @@ import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { isITextModel } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model';
 import { localize, localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { ActionWidgetDropdownActionViewItem } from '../../../../../platform/actions/browser/actionWidgetDropdownActionViewItem.js';
-import { IActionViewItemService } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/actionViewItemService.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
 import { Action2, MenuId, MenuItemAction } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
 import { IActionWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/platform/actionWidget/browser/actionWidget.service';
 import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
 import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
 import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
-import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
 import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
 import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service';
 import { ResourceContextKey } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contextkeys';
 import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
@@ -37,56 +37,69 @@ import { toPromptFileVariableEntry, PromptFileVariableKind } from '@codingame/mo
 
 var ChatContinueInSessionActionItem_1;
 var ActionLocation;
-(function (ActionLocation) {
+(function(ActionLocation) {
     ActionLocation["ChatWidget"] = "chatWidget";
     ActionLocation["Editor"] = "editor";
 })(ActionLocation || (ActionLocation = {}));
 class ContinueChatInSessionAction extends Action2 {
-    static { this.ID = 'workbench.action.chat.continueChatInSession'; }
+    static {
+        this.ID = "workbench.action.chat.continueChatInSession";
+    }
     constructor() {
         super({
             id: ContinueChatInSessionAction.ID,
-            title: ( localize2(4724, "Continue Chat in...")),
-            tooltip: ( localize(4724, "Continue Chat in...")),
+            title: ( localize2(4735, "Continue Chat in...")),
+            tooltip: ( localize(4735, "Continue Chat in...")),
             precondition: ( ContextKeyExpr.and(ChatContextKeys.enabled, ( ChatContextKeys.requestInProgress.negate()), ( ChatContextKeys.remoteJobCreating.negate()), ChatContextKeys.hasCanDelegateProviders)),
             menu: [{
-                    id: MenuId.ChatExecute,
-                    group: 'navigation',
-                    order: 3.4,
-                    when: ( ContextKeyExpr.and(( ChatContextKeys.lockedToCodingAgent.negate()), ChatContextKeys.hasCanDelegateProviders)),
-                },
-                {
-                    id: MenuId.EditorContent,
-                    group: 'continueIn',
-                    when: ( ContextKeyExpr.and(( ContextKeyExpr.equals(ResourceContextKey.Scheme.key, Schemas.untitled)), ( ContextKeyExpr.equals(ResourceContextKey.LangId.key, PROMPT_LANGUAGE_ID)), ( ContextKeyExpr.notEquals(chatEditingWidgetFileStateContextKey.key, ModifiedFileEntryState.Modified)), ( ctxHasEditorModification.negate()), ChatContextKeys.hasCanDelegateProviders)),
-                }
-            ]
+                id: MenuId.ChatExecute,
+                group: "navigation",
+                order: 3.4,
+                when: ( ContextKeyExpr.and(( ChatContextKeys.lockedToCodingAgent.negate()), ChatContextKeys.hasCanDelegateProviders))
+            }, {
+                id: MenuId.EditorContent,
+                group: "continueIn",
+                when: ( ContextKeyExpr.and(( ContextKeyExpr.equals(ResourceContextKey.Scheme.key, Schemas.untitled)), ( ContextKeyExpr.equals(ResourceContextKey.LangId.key, PROMPT_LANGUAGE_ID)), ( ContextKeyExpr.notEquals(chatEditingWidgetFileStateContextKey.key, ModifiedFileEntryState.Modified)), ( ctxHasEditorModification.negate()), ChatContextKeys.hasCanDelegateProviders))
+            }]
         });
     }
-    async run() {
-    }
+    async run() {}
 }
 let ChatContinueInSessionActionItem = ChatContinueInSessionActionItem_1 = class ChatContinueInSessionActionItem extends ActionWidgetDropdownActionViewItem {
-    constructor(action, location, actionWidgetService, contextKeyService, keybindingService, chatSessionsService, instantiationService, openerService) {
+    constructor(
+        action,
+        location,
+        actionWidgetService,
+        contextKeyService,
+        keybindingService,
+        chatSessionsService,
+        instantiationService,
+        openerService,
+        telemetryService
+    ) {
         super(action, {
             actionProvider: ChatContinueInSessionActionItem_1.actionProvider(chatSessionsService, instantiationService, location),
-            actionBarActions: ChatContinueInSessionActionItem_1.getActionBarActions(openerService)
-        }, actionWidgetService, keybindingService, contextKeyService);
+            actionBarActions: ChatContinueInSessionActionItem_1.getActionBarActions(openerService),
+            reporter: {
+                name: "ChatContinueInSession",
+                includeOptions: true
+            }
+        }, actionWidgetService, keybindingService, contextKeyService, telemetryService);
         this.location = location;
         this.contextKeyService = contextKeyService;
     }
     static getActionBarActions(openerService) {
-        const learnMoreUrl = 'https://aka.ms/vscode-continue-chat-in';
+        const learnMoreUrl = "https://aka.ms/vscode-continue-chat-in";
         return [{
-                id: 'workbench.action.chat.continueChatInSession.learnMore',
-                label: ( localize(4725, "Learn More")),
-                tooltip: ( localize(4725, "Learn More")),
-                class: undefined,
-                enabled: true,
-                run: async () => {
-                    await openerService.open(( URI.parse(learnMoreUrl)));
-                }
-            }];
+            id: "workbench.action.chat.continueChatInSession.learnMore",
+            label: ( localize(4736, "Learn More")),
+            tooltip: ( localize(4736, "Learn More")),
+            class: undefined,
+            enabled: true,
+            run: async () => {
+                await openerService.open(( URI.parse(learnMoreUrl)));
+            }
+        }];
     }
     static actionProvider(chatSessionsService, instantiationService, location) {
         return {
@@ -95,11 +108,18 @@ let ChatContinueInSessionActionItem = ChatContinueInSessionActionItem_1 = class
                 const contributions = chatSessionsService.getAllChatSessionContributions();
                 const backgroundContrib = contributions.find(contrib => contrib.type === AgentSessionProviders.Background);
                 if (backgroundContrib && backgroundContrib.canDelegate !== false) {
-                    actions.push(this.toAction(AgentSessionProviders.Background, backgroundContrib, instantiationService, location));
+                    actions.push(this.toAction(
+                        AgentSessionProviders.Background,
+                        backgroundContrib,
+                        instantiationService,
+                        location
+                    ));
                 }
                 const cloudContrib = contributions.find(contrib => contrib.type === AgentSessionProviders.Cloud);
                 if (cloudContrib && cloudContrib.canDelegate !== false) {
-                    actions.push(this.toAction(AgentSessionProviders.Cloud, cloudContrib, instantiationService, location));
+                    actions.push(
+                        this.toAction(AgentSessionProviders.Cloud, cloudContrib, instantiationService, location)
+                    );
                 }
                 if (actions.length === 0) {
                     actions.push(this.toSetupAction(AgentSessionProviders.Background, instantiationService));
@@ -117,8 +137,12 @@ let ChatContinueInSessionActionItem = ChatContinueInSessionActionItem_1 = class
             class: undefined,
             description: `@${contrib.name}`,
             label: getAgentSessionProviderName(provider),
-            tooltip: ( localize(4726, "Continue in {0}", getAgentSessionProviderName(provider))),
-            category: { label: ( localize(4727, "Continue In")), order: 0, showHeader: true },
+            tooltip: ( localize(4737, "Continue in {0}", getAgentSessionProviderName(provider))),
+            category: {
+                label: ( localize(4738, "Continue In")),
+                order: 0,
+                showHeader: true
+            },
             run: () => instantiationService.invokeFunction(accessor => {
                 if (location === ActionLocation.Editor) {
                     return ( new CreateRemoteAgentJobFromEditorAction()).run(accessor, contrib);
@@ -134,8 +158,12 @@ let ChatContinueInSessionActionItem = ChatContinueInSessionActionItem_1 = class
             icon: getAgentSessionProviderIcon(provider),
             class: undefined,
             label: getAgentSessionProviderName(provider),
-            tooltip: ( localize(4726, "Continue in {0}", getAgentSessionProviderName(provider))),
-            category: { label: ( localize(4727, "Continue In")), order: 0, showHeader: true },
+            tooltip: ( localize(4737, "Continue in {0}", getAgentSessionProviderName(provider))),
+            category: {
+                label: ( localize(4738, "Continue In")),
+                order: 0,
+                showHeader: true
+            },
             run: () => instantiationService.invokeFunction(accessor => {
                 const commandService = accessor.get(ICommandService);
                 return commandService.executeCommand(CHAT_SETUP_ACTION_ID);
@@ -144,35 +172,26 @@ let ChatContinueInSessionActionItem = ChatContinueInSessionActionItem_1 = class
     }
     renderLabel(element) {
         if (this.location === ActionLocation.Editor) {
-            const view = h('span.action-widget-delegate-label', [
-                h('span', { className: ThemeIcon.asClassName(Codicon.forward) }),
-                h('span', [( localize(4728, "Continue in..."))])
-            ]);
+            const view = h("span.action-widget-delegate-label", [h("span", {
+                className: ThemeIcon.asClassName(Codicon.forward)
+            }), h("span", [( localize(4739, "Continue in..."))])]);
             element.appendChild(view.root);
             return null;
-        }
-        else {
+        } else {
             const icon = this.contextKeyService.contextMatchesRules(ChatContextKeys.remoteJobCreating) ? Codicon.sync : Codicon.forward;
             element.classList.add(...ThemeIcon.asClassNameArray(icon));
             return super.renderLabel(element);
         }
     }
 };
-ChatContinueInSessionActionItem = ChatContinueInSessionActionItem_1 = ( __decorate([
-    ( __param(2, IActionWidgetService)),
-    ( __param(3, IContextKeyService)),
-    ( __param(4, IKeybindingService)),
-    ( __param(5, IChatSessionsService)),
-    ( __param(6, IInstantiationService)),
-    ( __param(7, IOpenerService))
-], ChatContinueInSessionActionItem));
-const NEW_CHAT_SESSION_ACTION_ID = 'workbench.action.chat.openNewSessionEditor';
+ChatContinueInSessionActionItem = ChatContinueInSessionActionItem_1 = ( __decorate([( __param(2, IActionWidgetService)), ( __param(3, IContextKeyService)), ( __param(4, IKeybindingService)), ( __param(5, IChatSessionsService)), ( __param(6, IInstantiationService)), ( __param(7, IOpenerService)), ( __param(8, ITelemetryService))], ChatContinueInSessionActionItem));
+const NEW_CHAT_SESSION_ACTION_ID = "workbench.action.chat.openNewSessionEditor";
 class CreateRemoteAgentJobAction {
-    constructor() { }
+    constructor() {}
     openUntitledEditor(commandService, continuationTarget) {
         commandService.executeCommand(`${NEW_CHAT_SESSION_ACTION_ID}.${continuationTarget.type}`);
     }
-    async run(accessor, continuationTarget) {
+    async run(accessor, continuationTarget, _widget) {
         const contextKeyService = accessor.get(IContextKeyService);
         const commandService = accessor.get(ICommandService);
         const widgetService = accessor.get(IChatWidgetService);
@@ -182,7 +201,7 @@ class CreateRemoteAgentJobAction {
         const remoteJobCreatingKey = ChatContextKeys.remoteJobCreating.bindTo(contextKeyService);
         try {
             remoteJobCreatingKey.set(true);
-            const widget = widgetService.lastFocusedWidget;
+            const widget = _widget ?? widgetService.lastFocusedWidget;
             if (!widget || !widget.viewModel) {
                 return this.openUntitledEditor(commandService, continuationTarget);
             }
@@ -197,7 +216,7 @@ class CreateRemoteAgentJobAction {
                 if (!chatRequests.length) {
                     return this.openUntitledEditor(commandService, continuationTarget);
                 }
-                userPrompt = 'implement this.';
+                userPrompt = "implement this.";
             }
             const attachedContext = widget.input.getAttachedAndImplicitContext(sessionResource);
             widget.input.acceptInput(true);
@@ -212,13 +231,13 @@ class CreateRemoteAgentJobAction {
                     const selection = activeEditor.getSelection();
                     if (activeEditorUri && selection) {
                         attachedContext.add({
-                            kind: 'file',
-                            id: 'vscode.implicit.selection',
+                            kind: "file",
+                            id: "vscode.implicit.selection",
                             name: basename(activeEditorUri),
                             value: {
                                 uri: activeEditorUri,
                                 range: selection
-                            },
+                            }
                         });
                     }
                 }
@@ -228,7 +247,9 @@ class CreateRemoteAgentJobAction {
             const requestParser = instantiationService.createInstance(ChatRequestParser);
             const continuationTargetType = continuationTarget.type;
             const parsedRequest = requestParser.parseChatRequest(sessionResource, userPrompt, ChatAgentLocation.Chat);
-            const addedRequest = chatModel.addRequest(parsedRequest, { variables: attachedContext.asArray() }, 0, undefined, defaultAgent);
+            const addedRequest = chatModel.addRequest(parsedRequest, {
+                variables: attachedContext.asArray()
+            }, 0, undefined, defaultAgent);
             await chatService.removeRequest(sessionResource, addedRequest.id);
             const requestData = await chatService.sendRequest(sessionResource, userPrompt, {
                 agentIdSilent: continuationTargetType,
@@ -239,18 +260,16 @@ class CreateRemoteAgentJobAction {
             if (requestData) {
                 await widget.handleDelegationExitIfNeeded(defaultAgent, requestData.agent);
             }
-        }
-        catch (e) {
-            console.error('Error creating remote coding agent job', e);
+        } catch (e) {
+            console.error("Error creating remote coding agent job", e);
             throw e;
-        }
-        finally {
+        } finally {
             remoteJobCreatingKey.set(false);
         }
     }
 }
 class CreateRemoteAgentJobFromEditorAction {
-    constructor() { }
+    constructor() {}
     async run(accessor, continuationTarget) {
         try {
             const editorService = accessor.get(IEditorService);
@@ -264,32 +283,38 @@ class CreateRemoteAgentJobFromEditorAction {
                 return;
             }
             const uri = model.uri;
-            const attachedContext = [toPromptFileVariableEntry(uri, PromptFileVariableKind.PromptFile, undefined, false, [])];
+            const attachedContext = [
+                toPromptFileVariableEntry(uri, PromptFileVariableKind.PromptFile, undefined, false, [])
+            ];
             const prompt = `Follow instructions in [${basename(uri)}](${( uri.toString())}).`;
-            await commandService.executeCommand(`${NEW_CHAT_SESSION_ACTION_ID}.${continuationTarget.type}`, { prompt, attachedContext });
-        }
-        catch (e) {
-            console.error('Error creating remote agent job from editor', e);
+            await commandService.executeCommand(`${NEW_CHAT_SESSION_ACTION_ID}.${continuationTarget.type}`, {
+                prompt,
+                attachedContext
+            });
+        } catch (e) {
+            console.error("Error creating remote agent job from editor", e);
             throw e;
         }
     }
 }
-let ContinueChatInSessionActionRendering = class ContinueChatInSessionActionRendering extends Disposable {
-    static { this.ID = 'chat.continueChatInSessionActionRendering'; }
+(class ContinueChatInSessionActionRendering extends Disposable {
+    static {
+        this.ID = "chat.continueChatInSessionActionRendering";
+    }
     constructor(actionViewItemService, instantiationService) {
         super();
-        const disposable = actionViewItemService.register(MenuId.EditorContent, ContinueChatInSessionAction.ID, (action, options, instantiationService2) => {
-            if (!(action instanceof MenuItemAction)) {
-                return undefined;
+        const disposable = actionViewItemService.register(
+            MenuId.EditorContent,
+            ContinueChatInSessionAction.ID,
+            (action, options, instantiationService2) => {
+                if (!(action instanceof MenuItemAction)) {
+                    return undefined;
+                }
+                return instantiationService.createInstance(ChatContinueInSessionActionItem, action, ActionLocation.Editor);
             }
-            return instantiationService.createInstance(ChatContinueInSessionActionItem, action, ActionLocation.Editor);
-        });
+        );
         markAsSingleton(disposable);
     }
-};
-ContinueChatInSessionActionRendering = ( __decorate([
-    ( __param(0, IActionViewItemService)),
-    ( __param(1, IInstantiationService))
-], ContinueChatInSessionActionRendering));
+});
 
-export { ActionLocation, ChatContinueInSessionActionItem, ContinueChatInSessionAction, ContinueChatInSessionActionRendering };
+export { ActionLocation, ChatContinueInSessionActionItem, ContinueChatInSessionAction, CreateRemoteAgentJobAction };

package/vscode/src/vs/workbench/contrib/chat/browser/actions/chatElicitationActions.js

@@ -10,12 +10,12 @@ import { isResponseVM } from '@codingame/monaco-vscode-api/vscode/vs/workbench/c
 import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
 import { CHAT_CATEGORY } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
 
-const AcceptElicitationRequestActionId = 'workbench.action.chat.acceptElicitation';
+const AcceptElicitationRequestActionId = "workbench.action.chat.acceptElicitation";
 class AcceptElicitationRequestAction extends Action2 {
     constructor() {
         super({
             id: AcceptElicitationRequestActionId,
-            title: ( localize2(4735, "Accept Request")),
+            title: ( localize2(4770, "Accept Request")),
             f1: false,
             category: CHAT_CATEGORY,
             keybinding: {
@@ -24,8 +24,8 @@ class AcceptElicitationRequestAction extends Action2 {
                     ChatContextKeys.Editing.hasElicitationRequest
                 )),
                 primary: KeyMod.CtrlCmd | KeyCode.Enter,
-                weight: KeybindingWeight.WorkbenchContrib + 1,
-            },
+                weight: KeybindingWeight.WorkbenchContrib + 1
+            }
         });
     }
     async run(accessor) {
@@ -44,7 +44,7 @@ class AcceptElicitationRequestAction extends Action2 {
                 continue;
             }
             for (const content of item.response.value) {
-                if (content.kind === 'elicitation2' && content.state.get() === ElicitationState.Pending) {
+                if (content.kind === "elicitation2" && content.state.get() === ElicitationState.Pending) {
                     await content.accept(true);
                     widget.focusInput();
                     return;

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

@@ -13,27 +13,42 @@ export interface IChatExecuteActionContext {
 }
 declare abstract class SubmitAction extends Action2 {
     run(accessor: ServicesAccessor, ...args: unknown[]): Promise<void>;
+    private handleDelegation;
 }
 export declare class ChatSubmitAction extends SubmitAction {
     static readonly ID = "workbench.action.chat.submit";
     constructor();
 }
-export declare class ChatDelegateToEditSessionAction extends Action2 {
-    static readonly ID = "workbench.action.chat.delegateToEditSession";
-    constructor();
-    run(accessor: ServicesAccessor, ...args: unknown[]): Promise<void>;
-}
 export declare const ToggleAgentModeActionId = "workbench.action.chat.toggleAgentMode";
 export interface IToggleChatModeArgs {
     modeId: ChatModeKind | string;
     sessionResource: URI | undefined;
 }
-export declare const ChatOpenModelPickerActionId = "workbench.action.chat.openModelPicker";
+export declare class OpenModelPickerAction extends Action2 {
+    static readonly ID = "workbench.action.chat.openModelPicker";
+    constructor();
+    run(accessor: ServicesAccessor, ...args: unknown[]): Promise<void>;
+}
 export declare class OpenModePickerAction extends Action2 {
     static readonly ID = "workbench.action.chat.openModePicker";
     constructor();
     run(accessor: ServicesAccessor, ...args: unknown[]): Promise<void>;
 }
+export declare class OpenSessionTargetPickerAction extends Action2 {
+    static readonly ID = "workbench.action.chat.openSessionTargetPicker";
+    constructor();
+    run(accessor: ServicesAccessor, ...args: unknown[]): Promise<void>;
+}
+export declare class OpenDelegationPickerAction extends Action2 {
+    static readonly ID = "workbench.action.chat.openDelegationPicker";
+    constructor();
+    run(accessor: ServicesAccessor, ...args: unknown[]): Promise<void>;
+}
+export declare class OpenWorkspacePickerAction extends Action2 {
+    static readonly ID = "workbench.action.chat.openWorkspacePicker";
+    constructor();
+    run(accessor: ServicesAccessor, ...args: unknown[]): Promise<void>;
+}
 export declare class ChatSessionPrimaryPickerAction extends Action2 {
     static readonly ID = "workbench.action.chat.chatSessionPrimaryPicker";
     constructor();