@codingame/monaco-vscode-chat-service-override 37.2.0 → 37.3.0

package/vscode/src/vs/sessions/contrib/providers/remoteAgentHost/browser/wslAgentHost.contribution.js

@@ -0,0 +1,171 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { IntervalTimer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { isCancellationError, onUnexpectedError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { RemoteAgentHostEntryType, RemoteAgentHostsEnabledSettingId, getEntryAddress, RemoteAgentHostConnectionStatus, getEntryTypeConfig } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService';
+import { IRemoteAgentHostService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService.service';
+import { WslAutoStartSettingId, WSL_ADDRESS_PREFIX } from '../../../../../platform/agentHost/common/wslRemoteAgentHost.js';
+import { IWSLRemoteAgentHostService } from '../../../../../platform/agentHost/common/wslRemoteAgentHost.service.js';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { INotificationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service';
+import { observableConfigValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/observable/common/platformObservableUtils';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { ISessionsProvidersService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service';
+import { ManagedReconnectAgentHostContribution } from './managedReconnectAgentHostContribution.js';
+
+function shouldPauseWSLReconnectAfterFailure(err) {
+    return isCancellationError(err);
+}
+const WSL_RUNNING_POLL_MS = 5 * 60 * 1000;
+let WSLAgentHostContribution = class WSLAgentHostContribution extends ManagedReconnectAgentHostContribution {
+    static {
+        this.ID = "sessions.contrib.wslAgentHostContribution";
+    }
+    constructor(
+        remoteAgentHostService,
+        _wslService,
+        configurationService,
+        logService,
+        instantiationService,
+        sessionsProvidersService,
+        notificationService
+    ) {
+        super(
+            remoteAgentHostService,
+            configurationService,
+            logService,
+            instantiationService,
+            sessionsProvidersService,
+            notificationService
+        );
+        this._wslService = _wslService;
+        this._entryType = RemoteAgentHostEntryType.WSL;
+        this._autoConnect = {
+            label: ( localize(4461, "Automatically Start WSL When Opening Chats")),
+            enabled: observableConfigValue(WslAutoStartSettingId, false, this._configurationService),
+            setEnabled: enabled => {
+                this._configurationService.updateValue(WslAutoStartSettingId, enabled).catch(onUnexpectedError);
+            }
+        };
+        this._register(this._remoteAgentHostService.onDidChangeConnections(() => {
+            this._resumeReconnects("WSL");
+            this._reconcile();
+        }));
+        this._register(this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(RemoteAgentHostsEnabledSettingId)) {
+                this._resumeReconnects("WSL");
+                this._reconcile();
+            }
+        }));
+        this._register(( new IntervalTimer())).cancelAndSet(() => this._reconnectNewlyRunningDistros(), WSL_RUNNING_POLL_MS);
+        this._reconcile();
+    }
+    async _reconnectNewlyRunningDistros() {
+        if (!this._enabled) {
+            return;
+        }
+        const entries = this._getProviderEntries();
+        if (entries.length === 0) {
+            return;
+        }
+        const running = ( new Set(await this._wslService.listRunningDistros().catch(() => [])));
+        for (const entry of entries) {
+            if (entry.connection.type !== RemoteAgentHostEntryType.WSL || !( running.has(entry.connection.distro))) {
+                continue;
+            }
+            const address = getEntryAddress(entry);
+            if (( this._remoteAgentHostService.connections.some(connection => connection.address === address))) {
+                continue;
+            }
+            this._logService.info(
+                `[RemoteAgentHost] WSL distro '${entry.connection.distro}' is running again; reconnecting`
+            );
+            this._remoteAgentHostService.reconnect(address, false);
+        }
+    }
+    _getProviderEntries() {
+        if (!this._enabled) {
+            return [];
+        }
+        return this._wslService.getCachedDistros().map((
+            {
+                distro,
+                name
+            }
+        ) => ({
+            name,
+            connection: {
+                type: RemoteAgentHostEntryType.WSL,
+                address: `${WSL_ADDRESS_PREFIX}${distro}`,
+                distro
+            }
+        }));
+    }
+    _getProviderOptions(entry) {
+        if (entry.connection.type !== RemoteAgentHostEntryType.WSL) {
+            return {};
+        }
+        const {
+            distro,
+            address
+        } = entry.connection;
+        return {
+            connectOnDemand: () => this._connectWSLOnDemand(distro, entry.name, address),
+            disconnectOnDemand: () => this._disconnectWSLOnDemand(distro, address),
+            onDidReportConnectProgress: this._wslService.onDidReportConnectProgress,
+            autoConnect: this._autoConnect
+        };
+    }
+    async _connectWSLOnDemand(distro, name, address) {
+        while (true) {
+            const inFlight = this._pendingReconnects.get(distro);
+            if (!inFlight) {
+                break;
+            }
+            this._logService.info(
+                `[WSLAgentHost] connectOnDemand: awaiting in-flight reconnect for ${distro}`
+            );
+            await inFlight.catch(() => undefined);
+            const live = this._remoteAgentHostService.connections.find(connection => connection.address === address);
+            if (live && RemoteAgentHostConnectionStatus.isConnected(live.status)) {
+                this._logService.info(
+                    `[WSLAgentHost] connectOnDemand: ${distro} connected by in-flight reconnect`
+                );
+                return;
+            }
+        }
+        this._logService.info(
+            `[WSLAgentHost] connectOnDemand: starting user-initiated reconnect for ${distro}`
+        );
+        this._reconnectStates.get(distro)?.resetForResume();
+        await this._attemptWSLReconnect(distro, name, address, true);
+    }
+    async _attemptWSLReconnect(distro, name, address, userInitiated) {
+        await this._attemptManagedReconnect({
+            kind: "WSL",
+            key: distro,
+            address,
+            userInitiated,
+            reconnectPolicy: getEntryTypeConfig(RemoteAgentHostEntryType.WSL).reconnect,
+            shouldPause: shouldPauseWSLReconnectAfterFailure,
+            doConnect: () => this._wslService.reconnect(distro, name, userInitiated).then(() => undefined)
+        });
+    }
+    async _disconnectWSLOnDemand(distro, address) {
+        this._reconnectStates.deleteAndDispose(distro);
+        await this._wslService.disconnect(distro);
+        await this._remoteAgentHostService.removeRemoteAgentHost(address);
+        this._reconcile();
+    }
+};
+WSLAgentHostContribution = ( __decorate([( __param(0, IRemoteAgentHostService)), ( __param(1, IWSLRemoteAgentHostService)), ( __param(2, IConfigurationService)), ( __param(3, ILogService)), ( __param(4, IInstantiationService)), ( __param(5, ISessionsProvidersService)), ( __param(6, INotificationService))], WSLAgentHostContribution));
+registerWorkbenchContribution2(
+    WSLAgentHostContribution.ID,
+    WSLAgentHostContribution,
+    WorkbenchPhase.AfterRestored
+);
+
+export { WSLAgentHostContribution, shouldPauseWSLReconnectAfterFailure };

package/vscode/src/vs/sessions/contrib/sessions/browser/mobile/mobileOverlayContribution.d.ts

@@ -0,0 +1 @@
+export {};

package/vscode/src/vs/sessions/contrib/sessions/browser/mobile/mobileOverlayContribution.js

@@ -0,0 +1,98 @@
+
+import { MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Action2, registerAction2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { ILanguageService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service';
+import { ILayoutService } from '@codingame/monaco-vscode-api/vscode/vs/platform/layout/browser/layoutService.service';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { INotificationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service';
+import { ITextFileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/textfile/common/textfiles.service';
+import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
+import { MOBILE_OPEN_DIFF_VIEW_COMMAND_ID, openMobileDiffView } from '../../../../browser/parts/mobile/contributions/mobileDiffView.js';
+import { MOBILE_OPEN_CHANGES_VIEW_COMMAND_ID, toRow, rowToDiffData } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/parts/mobile/contributions/mobileChangesView';
+import { MobileMultiDiffView } from '../../../../browser/parts/mobile/contributions/mobileMultiDiffView.js';
+import { IsPhoneLayoutContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
+import { localize2, localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+
+const activeDiffView = ( new MutableDisposable());
+const activeMultiDiffView = ( new MutableDisposable());
+class MobileOpenDiffViewAction extends Action2 {
+    constructor() {
+        super({
+            id: MOBILE_OPEN_DIFF_VIEW_COMMAND_ID,
+            title: ( localize2(4521, "Open File Diff")),
+            precondition: IsPhoneLayoutContext,
+            f1: false
+        });
+    }
+    run(accessor, arg) {
+        const layoutService = accessor.get(ILayoutService);
+        const textFileService = accessor.get(ITextFileService);
+        const languageService = accessor.get(ILanguageService);
+        const data = isMobileDiffViewData(arg) ? arg : {
+            diff: arg
+        };
+        activeDiffView.value = openMobileDiffView(layoutService.mainContainer, data, textFileService, languageService);
+        const view = activeDiffView.value;
+        Event.once(view.onDidDispose)(() => {
+            if (activeDiffView.value === view) {
+                activeDiffView.clear();
+            }
+        });
+    }
+}
+class MobileOpenChangesViewAction extends Action2 {
+    constructor() {
+        super({
+            id: MOBILE_OPEN_CHANGES_VIEW_COMMAND_ID,
+            title: ( localize2(4522, "Open Session Changes")),
+            precondition: IsPhoneLayoutContext,
+            f1: false
+        });
+    }
+    run(accessor) {
+        const layoutService = accessor.get(ILayoutService);
+        const textFileService = accessor.get(ITextFileService);
+        const fileService = accessor.get(IFileService);
+        const languageService = accessor.get(ILanguageService);
+        const notificationService = accessor.get(INotificationService);
+        const sessionsService = accessor.get(ISessionsService);
+        const session = sessionsService.activeSession.get();
+        const changes = session?.changes.get() ?? [];
+        const rows = changes.map(c => toRow(c));
+        const diffs = rows.map(r => rowToDiffData(r)).filter(d => d.originalURI || d.modifiedURI);
+        if (diffs.length === 0) {
+            notificationService.info(( localize(4523, "File-level changes are not available for this session yet.")));
+            return;
+        }
+        if (diffs.length === 1) {
+            const commandService = accessor.get(ICommandService);
+            commandService.executeCommand(MOBILE_OPEN_DIFF_VIEW_COMMAND_ID, {
+                diff: diffs[0]
+            });
+            return;
+        }
+        const data = {
+            diffs
+        };
+        activeMultiDiffView.value = ( new MobileMultiDiffView(
+            layoutService.mainContainer,
+            data,
+            textFileService,
+            fileService,
+            languageService
+        ));
+        const view = activeMultiDiffView.value;
+        Event.once(view.onDidDispose)(() => {
+            if (activeMultiDiffView.value === view) {
+                activeMultiDiffView.clear();
+            }
+        });
+    }
+}
+function isMobileDiffViewData(arg) {
+    return arg && typeof arg === "object" && "diff" in arg;
+}
+registerAction2(MobileOpenDiffViewAction);
+registerAction2(MobileOpenChangesViewAction);

package/vscode/src/vs/sessions/services/agentHost/browser/agentHostCustomizationService.d.ts

@@ -0,0 +1,24 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { AbstractAgentHostCustomizationService, type IAgentHostCustomizationTarget } from "../../../../workbench/contrib/chat/browser/agentSessions/agentHost/agentHostCustomizationService.js";
+import { ISessionsProvidersService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service";
+import { ISessionsManagementService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service";
+import { ISessionsService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service";
+import { AgentCustomization } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IAgentHostActiveClientService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostActiveClientService.service";
+export declare class AgentHostCustomizationService extends AbstractAgentHostCustomizationService {
+    private readonly _sessionsManagementService;
+    private readonly _sessionsService;
+    private readonly _sessionsProvidersService;
+    private readonly _activeClientService;
+    private readonly _providerListeners;
+    constructor(_sessionsManagementService: ISessionsManagementService, _sessionsService: ISessionsService, _sessionsProvidersService: ISessionsProvidersService, instantiationService: IInstantiationService, logService: ILogService, _activeClientService: IAgentHostActiveClientService);
+    private _getSession;
+    private _getAHSProvider;
+    protected _resolveTarget(sessionResource: URI): IAgentHostCustomizationTarget | undefined;
+    getCustomAgents(sessionResource: URI): readonly AgentCustomization[];
+    private _ensureProviderListener;
+    private _serverIdMatchesRawId;
+    private _agentFromMode;
+}

package/vscode/src/vs/sessions/services/agentHost/browser/agentHostCustomizationService.js

@@ -0,0 +1,142 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { fromAgentHostUri } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
+import { DisposableMap, combinedDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { isEqual, basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import { AbstractAgentHostCustomizationService } from '../../../../workbench/contrib/chat/browser/agentSessions/agentHost/agentHostCustomizationService.js';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { isAgentHostProvider } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/agentHostSessionsProvider';
+import { ISessionsProvidersService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service';
+import { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service';
+import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IAgentHostActiveClientService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostActiveClientService.service';
+import { CustomizationType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-session/state';
+
+let AgentHostCustomizationService = class AgentHostCustomizationService extends AbstractAgentHostCustomizationService {
+    constructor(
+        _sessionsManagementService,
+        _sessionsService,
+        _sessionsProvidersService,
+        instantiationService,
+        logService,
+        _activeClientService
+    ) {
+        super(instantiationService, logService);
+        this._sessionsManagementService = _sessionsManagementService;
+        this._sessionsService = _sessionsService;
+        this._sessionsProvidersService = _sessionsProvidersService;
+        this._activeClientService = _activeClientService;
+        this._providerListeners = this._register(( new DisposableMap()));
+        this._register(this._sessionsManagementService.onDidChangeSessions(e => {
+            for (const session of e.removed) {
+                this._disposeMcpDiagnostics(session.resource);
+            }
+            this._fireCustomAgentsChanged();
+            this._fireCustomizationsChanged();
+        }));
+    }
+    _getSession(sessionResource) {
+        const activeSession = this._sessionsService.activeSession.get();
+        if (activeSession && isEqual(activeSession.resource, sessionResource)) {
+            return activeSession;
+        }
+        return this._sessionsManagementService.getSession(sessionResource);
+    }
+    _getAHSProvider(session) {
+        const provider = this._sessionsProvidersService.getProvider(session.providerId);
+        if (provider && isAgentHostProvider(provider)) {
+            this._ensureProviderListener(provider);
+            return provider;
+        }
+        return undefined;
+    }
+    _resolveTarget(sessionResource) {
+        const session = this._getSession(sessionResource);
+        if (!session) {
+            return undefined;
+        }
+        const provider = this._getAHSProvider(session);
+        if (!provider) {
+            return undefined;
+        }
+        return {
+            customizations: provider.getCustomizations(session.sessionId),
+            resourceUris: {
+                fromAgentHost: resource => provider.mapAgentHostResource(resource),
+                toAgentHost: fromAgentHostUri
+            },
+            workingDirectory: provider.getWorkingDirectory(session.sessionId),
+            workingDirectories: provider.getWorkingDirectories(session.sessionId),
+            rootConfig: provider.getRootConfig(),
+            isBundledMcpServer: (pluginUri, serverName) => this._activeClientService.isBundledMcpServer(pluginUri, serverName),
+            authenticate: request => provider.authenticate(request),
+            setCustomizationEnablement: (rawId, enablement) => {
+                provider.setCustomizationEnablement(session.sessionId, rawId, enablement);
+            },
+            startMcpServer: rawId => {
+                return provider.getMcpServers(session.sessionId).find(server => this._serverIdMatchesRawId(server.id, rawId))?.start() ?? Promise.resolve();
+            },
+            stopMcpServer: rawId => {
+                return provider.getMcpServers(session.sessionId).find(server => this._serverIdMatchesRawId(server.id, rawId))?.stop() ?? Promise.resolve();
+            },
+            setRootConfigValue: (property, value) => {
+                void provider.setRootConfigValue(property, value);
+            }
+        };
+    }
+    getCustomAgents(sessionResource) {
+        const session = this._getSession(sessionResource);
+        if (session) {
+            const provider = this._getAHSProvider(session);
+            if (provider) {
+                const agents = provider.getCustomAgents(session.sessionId);
+                const activeMode = session.mode.get()?.id;
+                return agents.length === 0 && activeMode ? [this._agentFromMode(activeMode)] : agents;
+            }
+        }
+        return [];
+    }
+    _ensureProviderListener(provider) {
+        if (( this._providerListeners.has(provider))) {
+            return;
+        }
+        this._providerListeners.set(provider, combinedDisposable(provider.onDidChangeCustomAgents(() => {
+            this._fireCustomAgentsChanged();
+        }), provider.onDidChangeCustomizations(() => {
+            this._fireCustomizationsChanged();
+        })));
+    }
+    _serverIdMatchesRawId(serverId, rawId) {
+        const separator = serverId.indexOf("/");
+        return serverId === rawId || (separator >= 0 && serverId.slice(separator + 1) === rawId);
+    }
+    _agentFromMode(uri) {
+        return {
+            id: uri,
+            uri,
+            name: agentNameFromUri(uri),
+            type: CustomizationType.Agent
+        };
+    }
+};
+AgentHostCustomizationService = ( __decorate([( __param(0, ISessionsManagementService)), ( __param(1, ISessionsService)), ( __param(2, ISessionsProvidersService)), ( __param(3, IInstantiationService)), ( __param(4, ILogService)), ( __param(5, IAgentHostActiveClientService))], AgentHostCustomizationService));
+function agentNameFromUri(uri) {
+    try {
+        let name = basename(( URI.parse(uri)));
+        for (const suffix of [".agent.md", ".md"]) {
+            if (name.endsWith(suffix)) {
+                name = name.substring(0, name.length - suffix.length);
+                break;
+            }
+        }
+        return name || uri;
+    } catch {
+        return uri;
+    }
+}
+
+export { AgentHostCustomizationService };

package/vscode/src/vs/workbench/api/browser/mainThreadChatAgents2.js

@@ -26,8 +26,8 @@ import { PromptsStorage } from '@codingame/monaco-vscode-api/vscode/vs/workbench
 import { IPromptsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service';
 import { PromptsType, isValidPromptType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
 import { ChatRequestAgentPart } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/requestParser/chatParserTypes';
-import { ChatRequestParser } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/common/requestParser/chatRequestParser';
-import { getDynamicVariablesForWidget, getSelectedToolAndToolSetsForWidget } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/attachments/chatVariables';
+import { ChatRequestParser } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/requestParser/chatRequestParser';
+import { getDynamicVariablesForWidget, getSelectedToolAndToolSetsForWidget } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/attachments/chatVariables';
 import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
 import { ChatSessionOptionsMap } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
 import { IChatSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service';
@@ -36,14 +36,14 @@ import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/
 import { extHostNamedCustomer } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extHostCustomers';
 import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
 import { ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
-import { NotebookDto } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/api/browser/mainThreadNotebookDto';
+import { NotebookDto } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/browser/mainThreadNotebookDto';
 import { isUntitledChatSession, getChatSessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
 import { ICustomizationHarnessService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/customizationHarnessService.service';
 import { AICustomizationManagementSection } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/aiCustomizationWorkspaceService';
 import { IAgentPluginService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/agentPluginService.service';
 import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
 import { getAgentSessionProvider, AgentSessionProviders } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessions';
-import { addDynamicVariableActionId } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/widget/input/editor/chatDynamicVariablesConstant';
+import { addDynamicVariableActionId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/editor/chatDynamicVariablesConstant';
 import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
 
 class MainThreadChatTask {
@@ -262,27 +262,27 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
     }
     async $provideCustomAgents(token) {
         const customAgents = await this._promptsService.getCustomAgents(token);
-        return ( customAgents.map(agent => this._toCustomAgentDto(agent)));
+        return customAgents.map(agent => this._toCustomAgentDto(agent));
     }
     async $provideInstructions(token) {
         const instructions = await this._promptsService.getInstructionFiles(token);
-        return ( instructions.map(instruction => this._toInstructionDto(instruction)));
+        return instructions.map(instruction => this._toInstructionDto(instruction));
     }
     async $provideSkills(token) {
         const skills = (await this._promptsService.findAgentSkills(token)) ?? [];
-        return ( skills.map(skill => this._toSkillDto(skill)));
+        return skills.map(skill => this._toSkillDto(skill));
     }
     async $provideSlashCommands(token) {
         const slashCommands = await this._promptsService.getPromptSlashCommands(token);
-        return ( slashCommands.map(slashCommand => this._toSlashCommandDto(slashCommand)));
+        return slashCommands.map(slashCommand => this._toSlashCommandDto(slashCommand));
     }
     async $provideHooks(token) {
         const hookFiles = await this._promptsService.listPromptFiles(PromptsType.hook, token);
-        return ( hookFiles.map(hookFile => this._toHookDto(hookFile)));
+        return hookFiles.map(hookFile => this._toHookDto(hookFile));
     }
     async $providePlugins(_token) {
         const plugins = this._agentPluginService.plugins.get();
-        return ( plugins.map(plugin => this._toPluginDto(plugin)));
+        return plugins.map(plugin => this._toPluginDto(plugin));
     }
     $unregisterAgent(handle) {
         this._agents.deleteAndDispose(handle);
@@ -551,10 +551,10 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
     $registerAgentCompletionsProvider(handle, id, triggerCharacters) {
         const provide = async (query, token) => {
             const completions = await this._proxy.$invokeCompletionProvider(handle, query, token);
-            return ( completions.map(c => ({
+            return completions.map(c => ({
                 ...c,
                 icon: c.icon ? ThemeIcon.fromId(c.icon) : undefined
-            })));
+            }));
         };
         this._agentIdsToCompletionProviders.set(id, this._chatAgentService.registerAgentCompletionProvider(id, provide));
         this._agentCompletionProviders.set(handle, this._languageFeaturesService.completionProvider.register({
@@ -568,7 +568,7 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
                 if (!widget || !widget.viewModel) {
                     return;
                 }
-                const triggerCharsPart = ( triggerCharacters.map(c => escapeRegExpCharacters(c))).join("");
+                const triggerCharsPart = triggerCharacters.map(c => escapeRegExpCharacters(c)).join("");
                 const wordRegex = ( new RegExp(`[${triggerCharsPart}]\\S*`, "g"));
                 const query = getWordAtText(position.column, wordRegex, model.getLineContent(position.lineNumber), 0)?.word ?? "";
                 if (query && !( triggerCharacters.some(c => query.startsWith(c)))) {
@@ -594,7 +594,7 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
                     return null;
                 }
                 const result = await provide(query, token);
-                const variableItems = ( result.map(v => {
+                const variableItems = result.map(v => {
                     const insertText = v.insertText ?? (typeof v.label === "string" ? v.label : v.label.label);
                     const rangeAfterInsert = ( new Range(
                         range.insert.startLineNumber,
@@ -621,7 +621,7 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
                             }]
                         }
                     };
-                }));
+                });
                 return {
                     suggestions: variableItems
                 };
@@ -670,7 +670,7 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
                 if (!contributions) {
                     return undefined;
                 }
-                return ( contributions.map(c => {
+                return contributions.map(c => {
                     return {
                         name: c.name,
                         description: c.description,
@@ -678,7 +678,7 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
                         when: c.when,
                         uri: URI.revive(c.uri)
                     };
-                }));
+                });
             }
         });
         this._promptFileProviders.set(handle, disposable);
@@ -714,7 +714,7 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
                 if (!items) {
                     return undefined;
                 }
-                return ( items.map(item => ({
+                return items.map(item => ({
                     uri: URI.revive(item.uri),
                     type: item.type,
                     name: item.name,
@@ -727,19 +727,19 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
                     pluginUri: item.pluginUri ? URI.revive(item.pluginUri) : undefined,
                     pluginLabel: item.pluginLabel,
                     userInvocable: item.userInvocable
-                })));
+                }));
             },
             provideSourceFolders: async (sessionResource, type, token) => {
                 const folders = await this._proxy.$provideSourceFolders(handle, sessionResource, type, token);
                 if (!folders) {
                     return undefined;
                 }
-                return ( folders.map(folder => ({
+                return folders.map(folder => ({
                     uri: URI.revive(folder.uri),
                     label: folder.label,
                     source: folder.source,
                     destinationGroupId: folder.destinationGroupId
-                })));
+                }));
             }
         };
         const typeToSection = {
@@ -818,7 +818,7 @@ var ChatNotebookEdit;
             kind: "notebookEdit",
             uri: URI.revive(part.uri),
             done: part.done,
-            edits: ( part.edits.map(NotebookDto.fromCellEditOperationDto))
+            edits: part.edits.map(NotebookDto.fromCellEditOperationDto)
         };
     }
     ChatNotebookEdit.fromChatEdit = fromChatEdit;

package/vscode/src/vs/workbench/api/browser/mainThreadChatCodeMapper.js

@@ -6,7 +6,7 @@ import { TextEdit } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/l
 import { ICodeMapperService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatCodeMapperService.service';
 import { extHostNamedCustomer } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extHostCustomers';
 import { ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
-import { NotebookDto } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/api/browser/mainThreadNotebookDto';
+import { NotebookDto } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/browser/mainThreadNotebookDto';
 
 var MainThreadChatCodemapper_1;
 let MainThreadChatCodemapper = class MainThreadChatCodemapper extends Disposable {
@@ -60,7 +60,7 @@ let MainThreadChatCodemapper = class MainThreadChatCodemapper extends Disposable
             } else if (edits.every(TextEdit.isTextEdit)) {
                 response.textEdit(resource, edits);
             } else {
-                response.notebookEdit(resource, ( edits.map(NotebookDto.fromCellEditOperationDto)));
+                response.notebookEdit(resource, edits.map(NotebookDto.fromCellEditOperationDto));
             }
         }
         return Promise.resolve();

package/vscode/src/vs/workbench/api/browser/mainThreadChatContext.js

@@ -15,7 +15,7 @@ function reviveContextItem(item) {
     };
 }
 function reviveContextItems(items) {
-    return ( items.map(reviveContextItem));
+    return items.map(reviveContextItem);
 }
 let MainThreadChatContext = class MainThreadChatContext extends Disposable {
     constructor(extHostContext, _chatContextService) {