@codingame/monaco-vscode-chat-service-override 37.1.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.d.ts

@@ -0,0 +1,104 @@
+import { DeferredPromise } from "@codingame/monaco-vscode-api/vscode/vs/base/common/async";
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { IMarkdownString } from "@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { UriComponents } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ILanguageFeaturesService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/languageFeatures.service";
+import { ExtensionIdentifier } from "@codingame/monaco-vscode-api/vscode/vs/platform/extensions/common/extensions";
+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 { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IUriIdentityService } from "@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
+import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
+import { IChatAgentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatAgents.service";
+import { IPromptsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service";
+import { IChatContentInlineReference, IChatContentReference, IChatTask, IChatTaskSerialized, IChatWarningMessage } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
+import { IChatSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service";
+import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service";
+import { IExtHostContext } 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 { Dto } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/proxyIdentifier";
+import { IChatSessionCustomizationProviderMetadataDto, IChatProgressDto, ICustomAgentDto, IDynamicChatAgentProps, IExtensionChatAgentMetadata, IHookDto, IInstructionDto, IPluginDto, ISkillDto, ISlashCommandDto, MainThreadChatAgentsShape2 } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
+import { ICustomizationHarnessService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/customizationHarnessService.service";
+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";
+export declare class MainThreadChatTask implements IChatTask {
+    content: IMarkdownString;
+    readonly kind = "progressTask";
+    readonly deferred: DeferredPromise<void | string>;
+    private readonly _onDidAddProgress;
+    get onDidAddProgress(): Event<IChatWarningMessage | IChatContentReference>;
+    readonly progress: (IChatWarningMessage | IChatContentReference)[];
+    constructor(content: IMarkdownString);
+    task(): Promise<void | string>;
+    isSettled(): boolean;
+    complete(v: string | void): void;
+    add(progress: IChatWarningMessage | IChatContentReference): void;
+    toJSON(): IChatTaskSerialized;
+}
+export declare class MainThreadChatAgents2 extends Disposable implements MainThreadChatAgentsShape2 {
+    private readonly _chatAgentService;
+    private readonly _chatSessionService;
+    private readonly _chatService;
+    private readonly _languageFeaturesService;
+    private readonly _chatWidgetService;
+    private readonly _instantiationService;
+    private readonly _logService;
+    private readonly _extensionService;
+    private readonly _uriIdentityService;
+    private readonly _promptsService;
+    private readonly _languageModelToolsService;
+    private readonly _customizationHarnessService;
+    private readonly _telemetryService;
+    private readonly _agentPluginService;
+    private readonly _environmentService;
+    private readonly _agents;
+    private readonly _agentCompletionProviders;
+    private readonly _agentIdsToCompletionProviders;
+    private readonly _chatParticipantDetectionProviders;
+    private readonly _promptFileProviders;
+    private readonly _promptFileProviderEmitters;
+    private readonly _promptFileContentRegistrations;
+    private readonly _customizationProviders;
+    private readonly _customizationProviderEmitters;
+    private readonly _pendingProgress;
+    private readonly _proxy;
+    private readonly _activeTasks;
+    private readonly _unresolvedAnchors;
+    constructor(extHostContext: IExtHostContext, _chatAgentService: IChatAgentService, _chatSessionService: IChatSessionsService, _chatService: IChatService, _languageFeaturesService: ILanguageFeaturesService, _chatWidgetService: IChatWidgetService, _instantiationService: IInstantiationService, _logService: ILogService, _extensionService: IExtensionService, _uriIdentityService: IUriIdentityService, _promptsService: IPromptsService, _languageModelToolsService: ILanguageModelToolsService, _customizationHarnessService: ICustomizationHarnessService, _telemetryService: ITelemetryService, _agentPluginService: IAgentPluginService, _environmentService: IWorkbenchEnvironmentService);
+    private _acceptActiveChatSession;
+    private _toChatResourceSource;
+    private _toCustomAgentDto;
+    private _toInstructionDto;
+    private _toSkillDto;
+    private _toSlashCommandDto;
+    private _toHookDto;
+    private _toPluginDto;
+    $provideCustomAgents(token: CancellationToken): Promise<ICustomAgentDto[]>;
+    $provideInstructions(token: CancellationToken): Promise<IInstructionDto[]>;
+    $provideSkills(token: CancellationToken): Promise<ISkillDto[]>;
+    $provideSlashCommands(token: CancellationToken): Promise<ISlashCommandDto[]>;
+    $provideHooks(token: CancellationToken): Promise<IHookDto[]>;
+    $providePlugins(_token: CancellationToken): Promise<IPluginDto[]>;
+    $unregisterAgent(handle: number): void;
+    $transferActiveChatSession(toWorkspace: UriComponents): Promise<void>;
+    $registerAgent(handle: number, extension: ExtensionIdentifier, id: string, metadata: IExtensionChatAgentMetadata, dynamicProps: IDynamicChatAgentProps | undefined): Promise<void>;
+    $updateAgent(handle: number, metadataUpdate: IExtensionChatAgentMetadata): Promise<void>;
+    $handleProgressChunk(requestId: string, chunks: (IChatProgressDto | [
+        IChatProgressDto,
+        number
+    ])[]): Promise<void>;
+    $handleAnchorResolve(requestId: string, handle: string, resolveAnchor: Dto<IChatContentInlineReference> | undefined): void;
+    $registerAgentCompletionsProvider(handle: number, id: string, triggerCharacters: string[]): void;
+    $unregisterAgentCompletionsProvider(handle: number, id: string): void;
+    $registerChatParticipantDetectionProvider(handle: number): void;
+    $unregisterChatParticipantDetectionProvider(handle: number): void;
+    $registerPromptFileProvider(handle: number, type: string, extensionId: ExtensionIdentifier): Promise<void>;
+    $unregisterPromptFileProvider(handle: number): void;
+    $onDidChangePromptFiles(handle: number): void;
+    $registerChatSessionCustomizationProvider(handle: number, chatSessionType: string, metadata: IChatSessionCustomizationProviderMetadataDto, extensionId: ExtensionIdentifier): Promise<void>;
+    $unregisterChatSessionCustomizationProvider(handle: number): void;
+    $onDidChangeCustomizations(handle: number): void;
+}