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

package/vscode/src/vs/sessions/services/sessions/browser/sessionsManagementService.js

@@ -0,0 +1,1212 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { raceCancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { CancellationTokenSource, CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Disposable, DisposableMap, DisposableStore, toDisposable, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { agentHostAuthority } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
+import { IRemoteAgentHostService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService.service';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+import { ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { IChatWidgetHistoryService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/widget/chatWidgetHistoryService.service';
+import { dedupeMigratedCopilotCliSessions, getCopilotCliSessionRawId, buildHostLocalEventsPath } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/copilotCliEventsUri';
+import { IPathService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService.service';
+import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
+import { getSessionReferenceResource } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionReference';
+import { WorkspaceNotTrustedError } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ISessionsProvidersService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service';
+import { SessionStatus, ChatModelSource } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { IWorkspaceTrustManagementService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+
+const LAST_USED_QUICK_CHAT_SESSION_TYPE_STORAGE_KEY = "sessions.quickChat.lastUsedSessionType";
+let SessionsManagementService = class SessionsManagementService extends Disposable {
+    constructor(
+        logService,
+        sessionsProvidersService,
+        uriIdentityService,
+        chatService,
+        chatWidgetHistoryService,
+        storageService,
+        pathService,
+        remoteAgentHostService,
+        workspaceTrustManagementService
+    ) {
+        super();
+        this.logService = logService;
+        this.sessionsProvidersService = sessionsProvidersService;
+        this.uriIdentityService = uriIdentityService;
+        this.chatService = chatService;
+        this.chatWidgetHistoryService = chatWidgetHistoryService;
+        this.storageService = storageService;
+        this.pathService = pathService;
+        this.remoteAgentHostService = remoteAgentHostService;
+        this.workspaceTrustManagementService = workspaceTrustManagementService;
+        this._onDidChangeSessions = this._register(( new Emitter()));
+        this.onDidChangeSessions = this._onDidChangeSessions.event;
+        this._onDidStartSession = this._register(( new Emitter()));
+        this.onDidStartSession = this._onDidStartSession.event;
+        this._onWillSendRequest = this._register(( new Emitter()));
+        this.onWillSendRequest = this._onWillSendRequest.event;
+        this._onDidSendRequest = this._register(( new Emitter()));
+        this.onDidSendRequest = this._onDidSendRequest.event;
+        this._onDidArchiveSession = this._register(( new Emitter()));
+        this.onDidArchiveSession = this._onDidArchiveSession.event;
+        this._onDidUnarchiveSession = this._register(( new Emitter()));
+        this.onDidUnarchiveSession = this._onDidUnarchiveSession.event;
+        this._onDidDeleteSession = this._register(( new Emitter()));
+        this.onDidDeleteSession = this._onDidDeleteSession.event;
+        this._onDidDeleteChat = this._register(( new Emitter()));
+        this.onDidDeleteChat = this._onDidDeleteChat.event;
+        this._onDidRenameChat = this._register(( new Emitter()));
+        this.onDidRenameChat = this._onDidRenameChat.event;
+        this._onDidRenameSession = this._register(( new Emitter()));
+        this.onDidRenameSession = this._onDidRenameSession.event;
+        this._onDidChangeSessionTypes = this._register(( new Emitter()));
+        this.onDidChangeSessionTypes = this._onDidChangeSessionTypes.event;
+        this._onDidReplaceSession = this._register(( new Emitter()));
+        this.onDidReplaceSession = this._onDidReplaceSession.event;
+        this._onDidDiscardNewSession = this._register(( new Emitter()));
+        this.onDidDiscardNewSession = this._onDidDiscardNewSession.event;
+        this._onDidReplaceNewDraftSession = this._register(( new Emitter()));
+        this.onDidReplaceNewDraftSession = this._onDidReplaceNewDraftSession.event;
+        this._sessionTypes = [];
+        this._newSession = observableValue(this, undefined);
+        this.newSession = this._newSession;
+        this._automationSession = observableValue(this, undefined);
+        this.automationSession = this._automationSession;
+        this._providerListeners = this._register(( new DisposableMap()));
+        this._disposeCts = this._register(( new CancellationTokenSource()));
+        this._unlistedNewSessions = ( new ResourceMap());
+        this._inFlightNewSessionRequests = ( new ResourceMap());
+        this._pendingSendChatResources = ( new Set());
+        this._register(this.sessionsProvidersService.onDidChangeProviders(e => {
+            this._onProvidersChanged(e);
+            this._updateSessionTypes();
+        }));
+        this._subscribeToProviders(this.sessionsProvidersService.getProviders());
+        this._sessionTypes = this._collectSessionTypes();
+        this._register(this.chatService.onDidSubmitRequest((
+            {
+                chatSessionResource,
+                message,
+                attachedContext
+            }
+        ) => {
+            if (( this._pendingSendChatResources.has(( chatSessionResource.toString())))) {
+                return;
+            }
+            const ownedChat = this.getSessionForChatResource(chatSessionResource);
+            if (ownedChat) {
+                this._onDidSendRequest.fire({
+                    session: ownedChat.session,
+                    chat: ownedChat.chat,
+                    isNewSession: false,
+                    isNewChat: false,
+                    options: {
+                        query: message?.text ?? "",
+                        attachedContext
+                    }
+                });
+            }
+        }));
+    }
+    _onProvidersChanged(e) {
+        for (const provider of e.removed) {
+            this._providerListeners.deleteAndDispose(provider.id);
+        }
+        if (e.added.length) {
+            this._subscribeToProviders(e.added);
+        }
+    }
+    _subscribeToProviders(providers) {
+        for (const provider of providers) {
+            const disposables = ( new DisposableStore());
+            disposables.add(
+                provider.onDidChangeSessions(e => this.onDidChangeSessionsFromSessionsProviders(e))
+            );
+            if (provider.onDidReplaceSession) {
+                disposables.add(
+                    provider.onDidReplaceSession(e => this._handleDidReplaceSession(e.from, e.to))
+                );
+            }
+            if (provider.onDidChangeSessionTypes) {
+                disposables.add(provider.onDidChangeSessionTypes(() => this._updateSessionTypes()));
+            }
+            this._providerListeners.set(provider.id, disposables);
+        }
+    }
+    _handleDidReplaceSession(from, to) {
+        this.chatWidgetHistoryService.moveHistory(ChatAgentLocation.Chat, from.sessionId, to.sessionId);
+        this._onDidReplaceSession.fire({
+            from,
+            to
+        });
+        this._onDidChangeSessions.fire({
+            added: [],
+            removed: from.sessionId === to.sessionId ? [] : [from],
+            changed: [to]
+        });
+    }
+    onDidChangeSessionsFromSessionsProviders(e) {
+        if (e.removed.length) {
+            const current = this._newSession.get();
+            if (current && ( e.removed.some(r => r.sessionId === current.sessionId))) {
+                this._newSession.set(undefined, undefined);
+            }
+            const automationSession = this._automationSession.get();
+            if (automationSession && ( e.removed.some(r => r.sessionId === automationSession.sessionId))) {
+                this._automationSession.set(undefined, undefined);
+            }
+        }
+        this._onDidChangeSessions.fire(e);
+    }
+    async resolveSessionResource(resource, reason) {
+        for (const provider of this.sessionsProvidersService.getProviders()) {
+            if (!provider.resolveSessionResource) {
+                continue;
+            }
+            try {
+                const resolved = await provider.resolveSessionResource(resource, reason);
+                if (resolved) {
+                    return resolved;
+                }
+            } catch (error) {
+                this.logService.warn(
+                    `[SessionsManagement] provider '${provider.id}' failed to resolve ${( resource.toString())}`,
+                    error
+                );
+            }
+        }
+        return resource;
+    }
+    getSessions() {
+        return this._dedupeMigratedCopilotCliSessions(this._getMergedSessions());
+    }
+    getInFlightNewSessionRequests() {
+        return Array.from(( this._inFlightNewSessionRequests.values()), entry => entry.session);
+    }
+    trackInFlightNewSessionRequest(session) {
+        const entry = this._inFlightNewSessionRequests.get(session.resource);
+        if (entry) {
+            entry.count++;
+        } else {
+            this._inFlightNewSessionRequests.set(session.resource, {
+                session,
+                count: 1
+            });
+        }
+        return toDisposable(() => {
+            const current = this._inFlightNewSessionRequests.get(session.resource);
+            if (current?.count === 1) {
+                this._inFlightNewSessionRequests.delete(session.resource);
+            } else if (current) {
+                current.count--;
+            }
+        });
+    }
+    _getMergedSessions() {
+        const sessions = [];
+        for (const provider of this.sessionsProvidersService.getProviders()) {
+            sessions.push(...provider.getSessions());
+        }
+        return sessions;
+    }
+    _dedupeMigratedCopilotCliSessions(sessions) {
+        return dedupeMigratedCopilotCliSessions(sessions, session => session.resource);
+    }
+    getSession(resource) {
+        const unlistedSession = this._unlistedNewSessions.get(resource);
+        if (unlistedSession) {
+            return unlistedSession;
+        }
+        return this._getMergedSessions().find(s => this.uriIdentityService.extUri.isEqual(s.resource, resource));
+    }
+    getSessionForChatResource(resource) {
+        for (const session of this._getMergedSessions()) {
+            const chat = session.chats.get().find(c => this.uriIdentityService.extUri.isEqual(c.resource, resource));
+            if (chat) {
+                return {
+                    session,
+                    chat
+                };
+            }
+            const mainChat = session.mainChat.get();
+            if (this.uriIdentityService.extUri.isEqual(mainChat.resource, resource)) {
+                return {
+                    session,
+                    chat: mainChat
+                };
+            }
+        }
+        return undefined;
+    }
+    getAllSessionTypes() {
+        return [...this._sessionTypes];
+    }
+    getAllProviderSessionTypes() {
+        const result = [];
+        for (const provider of this.sessionsProvidersService.getProviders()) {
+            for (const sessionType of provider.sessionTypes) {
+                result.push({
+                    providerId: provider.id,
+                    sessionType
+                });
+            }
+        }
+        return result;
+    }
+    getSessionTypesForFolder(folderUri) {
+        const result = [];
+        for (const provider of this.sessionsProvidersService.getProviders()) {
+            if (!provider.resolveWorkspace(folderUri)) {
+                continue;
+            }
+            for (const sessionType of provider.getSessionTypes(folderUri)) {
+                result.push({
+                    providerId: provider.id,
+                    sessionType
+                });
+            }
+        }
+        return result;
+    }
+    getQuickChatSessionTypes() {
+        const result = [];
+        for (const provider of this.sessionsProvidersService.getProviders()) {
+            if (!provider.supportsQuickChats) {
+                continue;
+            }
+            for (const sessionType of provider.sessionTypes) {
+                result.push({
+                    providerId: provider.id,
+                    sessionType
+                });
+            }
+        }
+        return result;
+    }
+    isNewSessionTargetAvailable(folderUri, options) {
+        return this._isTargetAvailable(this.getSessionTypesForFolder(folderUri), options);
+    }
+    isQuickChatTargetAvailable(options) {
+        return this._isTargetAvailable(this.getQuickChatSessionTypes(), options);
+    }
+    _isTargetAvailable(sessionTypes, options) {
+        return ( sessionTypes.some(
+            candidate => (!options?.providerId || candidate.providerId === options.providerId) && (!options?.sessionTypeId || candidate.sessionType.id === options.sessionTypeId)
+        ));
+    }
+    resolveWorkspace(folderUri, preferredProviderId) {
+        if (preferredProviderId) {
+            const preferred = this.sessionsProvidersService.getProvider(preferredProviderId);
+            const workspace = preferred?.resolveWorkspace(folderUri);
+            if (workspace) {
+                return {
+                    providerId: preferredProviderId,
+                    workspace
+                };
+            }
+        }
+        for (const provider of this.sessionsProvidersService.getProviders()) {
+            const workspace = provider.resolveWorkspace(folderUri);
+            if (workspace) {
+                return {
+                    providerId: provider.id,
+                    workspace
+                };
+            }
+        }
+        return undefined;
+    }
+    _collectSessionTypes() {
+        const types = [];
+        const seen = ( new Set());
+        for (const provider of this.sessionsProvidersService.getProviders()) {
+            for (const type of provider.sessionTypes) {
+                if (!( seen.has(type.id))) {
+                    seen.add(type.id);
+                    types.push(type);
+                }
+            }
+        }
+        return types;
+    }
+    _updateSessionTypes() {
+        this._sessionTypes = this._collectSessionTypes();
+        this._onDidChangeSessionTypes.fire();
+    }
+    discardNewSession(session) {
+        const current = this._newSession.get();
+        if (!current) {
+            return;
+        }
+        if (session && session.sessionId !== current.sessionId) {
+            return;
+        }
+        this._newSession.set(undefined, undefined);
+        this._getProvider(current)?.deleteNewSession(current.sessionId);
+        this._onDidDiscardNewSession.fire(current);
+    }
+    discardAutomationSession(session) {
+        const current = this._automationSession.get();
+        if (!current || (session && session.sessionId !== current.sessionId)) {
+            return;
+        }
+        this._automationSession.set(undefined, undefined);
+        this._getProvider(current)?.deleteNewSession(current.sessionId);
+    }
+    _resolveProviderForNewSession(folderUri, options) {
+        const providers = this.sessionsProvidersService.getProviders();
+        let provider;
+        let workspace;
+        let sessionTypeId;
+        const requiresWorktreeConfiguration = options?.isolationMode === "worktree" || options?.worktreeBranchTrack !== undefined || options?.worktreeCreateNewBranch !== undefined || options?.branch !== undefined;
+        const resolveSessionTypeId = candidate => {
+            const sessionTypes = candidate.getSessionTypes(folderUri);
+            if (options?.sessionTypeId) {
+                const requested = sessionTypes.find(type => type.id === options.sessionTypeId);
+                return requested && (!requiresWorktreeConfiguration || requested.supportsWorktreeConfiguration === true) ? requested.id : undefined;
+            }
+            return (requiresWorktreeConfiguration ? sessionTypes.find(type => type.supportsWorktreeConfiguration === true) : sessionTypes[0])?.id;
+        };
+        if (options?.providerId) {
+            provider = providers.find(p => p.id === options.providerId);
+            if (!provider) {
+                throw ( new Error(`Sessions provider '${options.providerId}' not found`));
+            }
+            workspace = provider.resolveWorkspace(folderUri);
+            if (!workspace) {
+                throw ( new Error(
+                    `Sessions provider '${options.providerId}' cannot resolve folder '${( folderUri.toString())}'`
+                ));
+            }
+            sessionTypeId = resolveSessionTypeId(provider);
+            if (!sessionTypeId) {
+                if (requiresWorktreeConfiguration) {
+                    throw ( new Error(
+                        `Sessions provider '${options.providerId}' does not support worktree configuration for folder '${( folderUri.toString())}'`
+                    ));
+                }
+                if (options.sessionTypeId) {
+                    throw ( new Error(
+                        `Sessions provider '${options.providerId}' does not advertise session type '${options.sessionTypeId}'`
+                    ));
+                }
+                throw ( new Error(`No session types available for provider '${provider.id}'`));
+            }
+        } else {
+            for (const candidate of providers) {
+                const candidateWorkspace = candidate.resolveWorkspace(folderUri);
+                if (!candidateWorkspace) {
+                    continue;
+                }
+                const candidateSessionTypeId = resolveSessionTypeId(candidate);
+                if (!candidateSessionTypeId) {
+                    continue;
+                }
+                provider = candidate;
+                workspace = candidateWorkspace;
+                sessionTypeId = candidateSessionTypeId;
+                break;
+            }
+            if (!provider || !workspace) {
+                throw ( new Error(
+                    requiresWorktreeConfiguration ? `No sessions provider supports worktree configuration for folder '${( folderUri.toString())}'` : `No sessions provider can resolve folder '${( folderUri.toString())}'`
+                ));
+            }
+        }
+        if (!sessionTypeId) {
+            throw ( new Error(`No session types available for provider '${provider.id}'`));
+        }
+        return {
+            provider,
+            sessionTypeId,
+            workspace
+        };
+    }
+    createNewSession(folderUri, options) {
+        const {
+            provider,
+            sessionTypeId
+        } = this._resolveProviderForNewSession(folderUri, options);
+        const previousNewSession = this._newSession.get();
+        const session = provider.createNewSession(
+            folderUri,
+            sessionTypeId,
+            this._providerCreateSessionOptions(provider, options)
+        );
+        if (previousNewSession && previousNewSession.sessionId !== session.sessionId) {
+            this._getProvider(previousNewSession)?.deleteNewSession(previousNewSession.sessionId);
+            this._onDidReplaceNewDraftSession.fire({
+                from: previousNewSession,
+                to: session
+            });
+        }
+        this._newSession.set(session, undefined);
+        return session;
+    }
+    createAutomationSession(folderUri, options) {
+        const {
+            provider,
+            sessionTypeId
+        } = this._resolveProviderForNewSession(folderUri, options);
+        const previousAutomationSession = this._automationSession.get();
+        const session = provider.createNewSession(
+            folderUri,
+            sessionTypeId,
+            this._providerCreateSessionOptions(provider, options)
+        );
+        if (previousAutomationSession && previousAutomationSession.sessionId !== session.sessionId) {
+            this._getProvider(previousAutomationSession)?.deleteNewSession(previousAutomationSession.sessionId);
+        }
+        this._automationSession.set(session, undefined);
+        return session;
+    }
+    _resolveProviderForQuickChat(options) {
+        const providers = this.sessionsProvidersService.getProviders();
+        let provider;
+        if (options?.providerId) {
+            provider = providers.find(p => p.id === options.providerId);
+            if (!provider) {
+                throw ( new Error(`Sessions provider '${options.providerId}' not found`));
+            }
+            if (!provider.supportsQuickChats) {
+                throw ( new Error(`Sessions provider '${options.providerId}' does not support quick chats`));
+            }
+            if (options.sessionTypeId && !( provider.sessionTypes.some(t => t.id === options.sessionTypeId))) {
+                throw ( new Error(
+                    `Sessions provider '${options.providerId}' does not advertise session type '${options.sessionTypeId}'`
+                ));
+            }
+        } else {
+            for (const candidate of providers) {
+                if (!candidate.supportsQuickChats) {
+                    continue;
+                }
+                if (options?.sessionTypeId && !( candidate.sessionTypes.some(t => t.id === options.sessionTypeId))) {
+                    continue;
+                }
+                provider = candidate;
+                break;
+            }
+            if (!provider) {
+                throw ( new Error("No sessions provider supports quick chats"));
+            }
+        }
+        const sessionTypeId = options?.sessionTypeId ?? this._defaultQuickChatSessionType(provider);
+        if (!sessionTypeId) {
+            throw ( new Error(`No session types available for provider '${provider.id}'`));
+        }
+        return {
+            provider,
+            sessionTypeId
+        };
+    }
+    _defaultQuickChatSessionType(provider) {
+        const lastUsed = this.storageService.get(LAST_USED_QUICK_CHAT_SESSION_TYPE_STORAGE_KEY, StorageScope.PROFILE);
+        if (lastUsed && ( provider.sessionTypes.some(t => t.id === lastUsed))) {
+            return lastUsed;
+        }
+        return provider.sessionTypes[0]?.id;
+    }
+    createQuickChat(options) {
+        const {
+            provider,
+            sessionTypeId
+        } = this._resolveProviderForQuickChat(options);
+        const previousNewSession = this._newSession.get();
+        const session = provider.createQuickChat(sessionTypeId, this._providerCreateSessionOptions(provider, options));
+        this._newSession.set(session, undefined);
+        this.storageService.store(
+            LAST_USED_QUICK_CHAT_SESSION_TYPE_STORAGE_KEY,
+            sessionTypeId,
+            StorageScope.PROFILE,
+            StorageTarget.USER
+        );
+        if (previousNewSession && previousNewSession.sessionId !== session.sessionId) {
+            this._getProvider(previousNewSession)?.deleteNewSession(previousNewSession.sessionId);
+        }
+        return session;
+    }
+    createAutomationQuickChat(options) {
+        const {
+            provider,
+            sessionTypeId
+        } = this._resolveProviderForQuickChat(options);
+        const previousAutomationSession = this._automationSession.get();
+        const session = provider.createQuickChat(sessionTypeId, this._providerCreateSessionOptions(provider, options));
+        if (previousAutomationSession && previousAutomationSession.sessionId !== session.sessionId) {
+            this._getProvider(previousAutomationSession)?.deleteNewSession(previousAutomationSession.sessionId);
+        }
+        this._automationSession.set(session, undefined);
+        return session;
+    }
+    _providerCreateSessionOptions(provider, options) {
+        const sessionTemplate = options?.sessionTemplate ?? options?.automationConfiguration?.sessionTemplate;
+        if (sessionTemplate && provider.supportsAutomationSessionConfiguration !== true) {
+            throw ( new Error(
+                `Sessions provider '${provider.id}' does not support Automation session templates.`
+            ));
+        }
+        const automationConfiguration = sessionTemplate ? {
+            sessionTemplate
+        } : options?.automationConfiguration;
+        return {
+            metadata: options?.metadata,
+            ...(automationConfiguration ? {
+                automationConfiguration
+            } : {})
+        };
+    }
+    async getAutomationSessionConfiguration(session) {
+        const provider = this._getProvider(session);
+        return provider?.supportsAutomationSessionConfiguration === true && provider.getAutomationSessionConfiguration ? provider.getAutomationSessionConfiguration(session.sessionId) : null;
+    }
+    supportsAutomationSessionConfiguration(session) {
+        return this._getProvider(session)?.supportsAutomationSessionConfiguration === true;
+    }
+    usesCombinedNewSessionConfigPicker(session) {
+        return this._getProvider(session)?.usesCombinedNewSessionConfigPicker === true;
+    }
+    async createNewChatInSession(session, options) {
+        const provider = this._getProvider(session);
+        if (!provider) {
+            this.logService.warn(
+                `[SessionsManagement] createNewChatInSession: provider '${session.providerId}' not found`
+            );
+            return undefined;
+        }
+        if (!options?.forceNew) {
+            const existingUntitled = session.chats.get().find(c => c.status.get() === SessionStatus.Untitled);
+            if (existingUntitled) {
+                return existingUntitled;
+            }
+        }
+        const created = await provider.createNewChat(session.sessionId);
+        return created;
+    }
+    async forkChatInSession(session, sourceChat, turnId) {
+        const provider = this._getProvider(session);
+        if (!provider) {
+            throw ( new Error(
+                `Provider '${session.providerId}' not found for session '${session.sessionId}'`
+            ));
+        }
+        if (!session.capabilities.get().supportsMultipleChats) {
+            throw ( new Error(`Session '${session.sessionId}' does not support forking into a chat`));
+        }
+        return provider.forkChat(session.sessionId, sourceChat, turnId);
+    }
+    async createSideChatInSession(session, sourceChat, turnId, selection) {
+        const provider = this._getProvider(session);
+        if (!provider) {
+            throw ( new Error(
+                `Provider '${session.providerId}' not found for session '${session.sessionId}'`
+            ));
+        }
+        if (!session.capabilities.get().supportsSideChat) {
+            throw ( new Error(`Session '${session.sessionId}' does not support side chats`));
+        }
+        return provider.createSideChat(session.sessionId, sourceChat, turnId, selection);
+    }
+    _augmentOptionsForTroubleshoot(session, options) {
+        const referencedResources = [];
+        let remainingAttachments;
+        if (options.attachedContext?.length) {
+            const remaining = [];
+            for (const entry of options.attachedContext) {
+                const referenced = getSessionReferenceResource(entry);
+                if (referenced) {
+                    referencedResources.push(referenced);
+                } else {
+                    remaining.push(entry);
+                }
+            }
+            if (referencedResources.length) {
+                remainingAttachments = remaining;
+            }
+        }
+        const isTroubleshoot = /^\s*\/troubleshoot\b/.test(options.query);
+        if (!isTroubleshoot && referencedResources.length === 0) {
+            return options;
+        }
+        let result = options;
+        if (remainingAttachments) {
+            result = {
+                ...result,
+                attachedContext: remainingAttachments.length ? remainingAttachments : undefined
+            };
+        }
+        if (!isTroubleshoot) {
+            return result;
+        }
+        const targets = referencedResources.length ? referencedResources : (getCopilotCliSessionRawId(session.resource) ? [session.resource] : []);
+        const userHome = this.pathService.userHome({
+            preferLocal: true
+        });
+        const getConnection = authority => this.remoteAgentHostService.connections.find(c => agentHostAuthority(c.address) === authority);
+        const eventPaths = Array.from(( new Set(
+            targets.map(resource => buildHostLocalEventsPath(resource, userHome, getConnection)).filter(path => !!path)
+        )));
+        if (eventPaths.length === 0) {
+            return result;
+        }
+        return {
+            ...result,
+            query: `${result.query}\n\nSession log: ${eventPaths.join(", ")}`
+        };
+    }
+    async sendNewChatRequest(session, options) {
+        let provider = this._getProvider(session);
+        if (!provider) {
+            throw ( new Error(`Sessions provider '${session.providerId}' not found`));
+        }
+        const isNewSessionRequest = session.status.get() === SessionStatus.Untitled;
+        const inFlightRequest = isNewSessionRequest ? this.trackInFlightNewSessionRequest(session) : undefined;
+        if (options.background) {
+            this._newSession.set(undefined, undefined);
+            void this._prepareAndSendNewChatRequestInBackground(provider, session, options).catch(e => {
+                this.logService.error("[SessionsManagement] Failed to send background request:", e);
+            }).finally(() => inFlightRequest?.dispose());
+            return;
+        }
+        const requestActivity = ( new MutableDisposable());
+        try {
+            requestActivity.value = provider.startNewSessionRequest?.(session.sessionId);
+            ({
+                provider,
+                session
+            } = await this._prepareNewSessionForSend(provider, session, requestActivity, true, options.query));
+            this._newSession.set(undefined, undefined);
+            this._onWillSendRequest.fire(session);
+            const chat = await provider.createNewChat(session.sessionId, options.query);
+            const sendOptions = this._augmentOptionsForTroubleshoot(session, options);
+            const chatResourceKey = ( chat.resource.toString());
+            this._pendingSendChatResources.add(chatResourceKey);
+            let updatedSession;
+            try {
+                updatedSession = await provider.sendRequest(session.sessionId, chat.resource, sendOptions);
+            } finally {
+                this._pendingSendChatResources.delete(chatResourceKey);
+            }
+            if (updatedSession.sessionId !== session.sessionId) {
+                this.logService.info(
+                    `[SessionsManagement] sendRequest: active session replaced: ${session.sessionId} -> ${updatedSession.sessionId}`
+                );
+            }
+            this._onDidStartSession.fire(updatedSession);
+            this._onDidSendRequest.fire({
+                session: updatedSession,
+                chat,
+                isNewSession: true,
+                isNewChat: true,
+                options
+            });
+        } finally {
+            requestActivity.dispose();
+            inFlightRequest?.dispose();
+        }
+    }
+    async _prepareNewSessionForSend(provider, session, requestActivity, replaceCurrentDraft, query) {
+        if (!provider.prepareNewSession) {
+            return {
+                provider,
+                session
+            };
+        }
+        const originalSession = session;
+        const preparationTokenSource = ( new CancellationTokenSource(this._disposeCts.token));
+        const preparationListeners = ( new DisposableStore());
+        preparationListeners.add(this.onDidReplaceNewDraftSession((
+            {
+                from
+            }
+        ) => {
+            if (from.sessionId === originalSession.sessionId) {
+                preparationTokenSource.cancel();
+            }
+        }));
+        preparationListeners.add(this.onDidDiscardNewSession(discarded => {
+            if (discarded.sessionId === originalSession.sessionId) {
+                preparationTokenSource.cancel();
+            }
+        }));
+        let prepared;
+        try {
+            prepared = await provider.prepareNewSession(session.sessionId, preparationTokenSource.token, query);
+        } finally {
+            preparationListeners.dispose();
+            preparationTokenSource.dispose();
+        }
+        const preparedSession = prepared.session;
+        if (preparedSession.sessionId === originalSession.sessionId) {
+            return {
+                provider,
+                session
+            };
+        }
+        const preparedProvider = this._getProvider(preparedSession);
+        if (!preparedProvider) {
+            await prepared.discard?.();
+            throw ( new Error(
+                `Sessions provider '${preparedSession.providerId}' not found after preparing the new session`
+            ));
+        }
+        if (replaceCurrentDraft && this._newSession.get()?.sessionId !== originalSession.sessionId) {
+            if (prepared.discard) {
+                await prepared.discard();
+            } else {
+                preparedProvider.deleteNewSession(preparedSession.sessionId);
+            }
+            throw ( new CancellationError());
+        }
+        const preparedRequestActivity = requestActivity ? preparedProvider.startNewSessionRequest?.(preparedSession.sessionId) : undefined;
+        provider.deleteNewSession(originalSession.sessionId);
+        if (requestActivity) {
+            requestActivity.value = preparedRequestActivity;
+        }
+        if (replaceCurrentDraft) {
+            this._onDidReplaceNewDraftSession.fire({
+                from: originalSession,
+                to: preparedSession
+            });
+        }
+        return {
+            provider: preparedProvider,
+            session: preparedSession
+        };
+    }
+    async createAndSendNewChatRequest(folderUri, options, createOptions, token = CancellationToken.None) {
+        const {
+            provider,
+            sessionTypeId,
+            workspace
+        } = this._resolveProviderForNewSession(folderUri, createOptions);
+        if (workspace.requiresWorkspaceTrust) {
+            const trustInfo = await this.workspaceTrustManagementService.getUriTrustInfo(folderUri);
+            if (!trustInfo.trusted) {
+                throw ( new WorkspaceNotTrustedError());
+            }
+        }
+        const session = provider.createNewSession(
+            folderUri,
+            sessionTypeId,
+            this._providerCreateSessionOptions(provider, createOptions)
+        );
+        this._unlistedNewSessions.set(session.resource, session);
+        const requestActivity = ( new MutableDisposable());
+        try {
+            try {
+                requestActivity.value = isDeferredNewSessionRequestOptions(options) ? provider.startNewSessionRequest?.(session.sessionId, options.activity) : provider.startNewSessionRequest?.(session.sessionId);
+                createOptions?.onSessionCreated?.(session);
+            } catch (error) {
+                provider.deleteNewSession(session.sessionId);
+                throw error;
+            }
+            const supportsWorktreeConfiguration = provider.getSessionTypes(folderUri).find(sessionType => sessionType.id === sessionTypeId)?.supportsWorktreeConfiguration === true;
+            return await this._configureAndSendNewSession(
+                provider,
+                session,
+                options,
+                createOptions,
+                supportsWorktreeConfiguration,
+                token,
+                folderUri,
+                requestActivity
+            );
+        } finally {
+            requestActivity.dispose();
+            this._unlistedNewSessions.delete(session.resource);
+        }
+    }
+    async createAndSendQuickChatRequest(options, createOptions, token = CancellationToken.None) {
+        const {
+            provider,
+            sessionTypeId
+        } = this._resolveProviderForQuickChat(createOptions);
+        const session = provider.createQuickChat(sessionTypeId, this._providerCreateSessionOptions(provider, createOptions));
+        return this._configureAndSendNewSession(provider, session, options, createOptions, false, token);
+    }
+    async _configureAndSendNewSession(
+        provider,
+        session,
+        options,
+        createOptions,
+        supportsWorktreeConfiguration,
+        token,
+        folderUri,
+        requestActivity
+    ) {
+        const inFlightRequest = this.trackInFlightNewSessionRequest(session);
+        try {
+            if (token.isCancellationRequested) {
+                throw ( new CancellationError());
+            }
+            const requestOptionsPromise = (async () => {
+                try {
+                    return isDeferredNewSessionRequestOptions(options) ? await options.resolve() : options;
+                } finally {
+                    requestActivity?.clear();
+                }
+            })();
+            const configurationPromise = this._configureNewSession(
+                provider,
+                session,
+                createOptions,
+                supportsWorktreeConfiguration,
+                token,
+                folderUri
+            );
+            const [resolvedOptions] = await raceCancellationError(Promise.all([requestOptionsPromise, configurationPromise]), token);
+            if (token.isCancellationRequested) {
+                throw ( new CancellationError());
+            }
+            return await raceCancellationError(
+                this._sendNewChatRequestInBackground(provider, session, resolvedOptions, token),
+                token
+            );
+        } catch (e) {
+            provider.deleteNewSession(session.sessionId);
+            throw e;
+        } finally {
+            inFlightRequest.dispose();
+        }
+    }
+    async _configureNewSession(
+        provider,
+        session,
+        createOptions,
+        supportsWorktreeConfiguration,
+        token,
+        folderUri
+    ) {
+        if (createOptions?.modelId) {
+            const resolvedModelId = await this._waitForRequestedModel(provider, session, createOptions.modelId, token, folderUri);
+            provider.setModel(
+                session.sessionId,
+                session.mainChat.get().resource,
+                resolvedModelId,
+                ChatModelSource.Chosen
+            );
+        }
+        if (createOptions?.modeId) {
+            provider.setMode?.(session.sessionId, createOptions.modeId);
+        }
+        if (createOptions?.permissionLevel) {
+            provider.setPermissionLevel?.(session.sessionId, createOptions.permissionLevel);
+        }
+        if (supportsWorktreeConfiguration && (createOptions?.isolationMode || createOptions?.worktreeBranchTrack !== undefined || createOptions?.worktreeCreateNewBranch !== undefined || createOptions?.branch)) {
+            if (provider.setWorktreeConfiguration) {
+                await raceCancellationError(provider.setWorktreeConfiguration(session.sessionId, {
+                    isolationMode: createOptions.isolationMode,
+                    worktreeBranchTrack: createOptions.worktreeBranchTrack,
+                    worktreeCreateNewBranch: createOptions.worktreeCreateNewBranch,
+                    branch: createOptions.branch
+                }), token);
+            } else {
+                if (createOptions.isolationMode && provider.setIsolationMode) {
+                    await raceCancellationError(
+                        provider.setIsolationMode(session.sessionId, createOptions.isolationMode),
+                        token
+                    );
+                }
+                if (createOptions.worktreeBranchTrack !== undefined && provider.setWorktreeBranchTrack) {
+                    await raceCancellationError(
+                        provider.setWorktreeBranchTrack(session.sessionId, createOptions.worktreeBranchTrack),
+                        token
+                    );
+                }
+                if (createOptions.worktreeCreateNewBranch !== undefined && provider.setWorktreeCreateNewBranch) {
+                    await raceCancellationError(
+                        provider.setWorktreeCreateNewBranch(session.sessionId, createOptions.worktreeCreateNewBranch),
+                        token
+                    );
+                }
+                if (createOptions.branch && provider.setBranch) {
+                    await raceCancellationError(provider.setBranch(session.sessionId, createOptions.branch), token);
+                }
+            }
+        }
+    }
+    async _waitForRequestedModel(provider, session, modelId, token, folderUri) {
+        const resolveCurrent = () => provider.getModelsSnapshot(session.sessionId, modelId).desiredModelResolution;
+        const initial = resolveCurrent();
+        if (initial.kind === "available") {
+            return initial.model.identifier;
+        }
+        if (initial.kind === "notRequested") {
+            return modelId;
+        }
+        if (initial.kind === "unavailable") {
+            throw ( new Error(`Model '${modelId}' is unavailable for sessions provider '${provider.id}'`));
+        }
+        if (token.isCancellationRequested) {
+            throw ( new CancellationError());
+        }
+        return ( new Promise((resolve, reject) => {
+            const disposables = ( new DisposableStore());
+            let settled = false;
+            const finish = result => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                disposables.dispose();
+                if (result instanceof Error) {
+                    reject(result);
+                } else {
+                    resolve(result);
+                }
+            };
+            const check = () => {
+                const resolution = resolveCurrent();
+                if (resolution.kind === "available") {
+                    finish(resolution.model.identifier);
+                } else if (resolution.kind === "notRequested") {
+                    finish(modelId);
+                } else if (resolution.kind === "unavailable") {
+                    finish(( new Error(`Model '${modelId}' is unavailable for sessions provider '${provider.id}'`)));
+                }
+            };
+            disposables.add(provider.onDidChangeModels(check));
+            disposables.add(provider.onDidChangeSessionTypes(() => {
+                const sessionTypes = folderUri ? provider.getSessionTypes(folderUri) : provider.sessionTypes;
+                if (!( sessionTypes.some(type => type.id === session.sessionType))) {
+                    finish(( new Error(
+                        `Session type '${session.sessionType}' is no longer available for sessions provider '${provider.id}'`
+                    )));
+                }
+            }));
+            disposables.add(this.sessionsProvidersService.onDidChangeProviders(event => {
+                if (event.removed.includes(provider)) {
+                    finish(( new Error(`Sessions provider '${provider.id}' is no longer available`)));
+                }
+            }));
+            disposables.add(token.onCancellationRequested(() => finish(( new CancellationError()))));
+            disposables.add(this._disposeCts.token.onCancellationRequested(() => finish(( new CancellationError()))));
+            check();
+        }));
+    }
+    dispose() {
+        this._disposeCts.cancel();
+        super.dispose();
+    }
+    async _prepareAndSendNewChatRequestInBackground(provider, session, options) {
+        let graduatingProvider = provider;
+        let graduatingSession = session;
+        try {
+            ({
+                provider: graduatingProvider,
+                session: graduatingSession
+            } = await this._prepareNewSessionForSend(provider, session, undefined, false, options.query));
+            await this._sendNewChatRequestInBackground(graduatingProvider, graduatingSession, options);
+        } catch (error) {
+            graduatingProvider.deleteNewSession(graduatingSession.sessionId);
+            throw error;
+        }
+    }
+    async _sendNewChatRequestInBackground(provider, session, options, token = CancellationToken.None) {
+        if (token.isCancellationRequested) {
+            throw ( new CancellationError());
+        }
+        this._onWillSendRequest.fire(session);
+        const chatPromise = provider.createNewChat(session.sessionId, options.query);
+        const chat = token === CancellationToken.None ? await chatPromise : await raceCancellationError(chatPromise, token);
+        const sendOptions = this._augmentOptionsForTroubleshoot(session, options);
+        const chatResourceKey = ( chat.resource.toString());
+        this._pendingSendChatResources.add(chatResourceKey);
+        const cancellationListener = token.onCancellationRequested(() => {
+            void this.chatService.cancelCurrentRequestForSession(chat.resource, "sessionsManagement").catch(error => {
+                this.logService.warn("[SessionsManagement] Failed to cancel headless request:", error);
+            });
+        });
+        let updatedSession;
+        try {
+            updatedSession = await provider.sendRequest(session.sessionId, chat.resource, sendOptions);
+        } finally {
+            cancellationListener.dispose();
+            this._pendingSendChatResources.delete(chatResourceKey);
+        }
+        if (token.isCancellationRequested) {
+            throw ( new CancellationError());
+        }
+        if (this._store.isDisposed) {
+            return undefined;
+        }
+        this._onDidStartSession.fire(updatedSession);
+        this._onDidSendRequest.fire({
+            session: updatedSession,
+            chat,
+            isNewSession: true,
+            isNewChat: true,
+            options
+        });
+        return updatedSession;
+    }
+    async sendRequest(session, chat, options) {
+        this.discardNewSession();
+        const provider = this._getProvider(session);
+        if (!provider) {
+            throw ( new Error(`Sessions provider '${session.providerId}' not found`));
+        }
+        if (options.background) {
+            this._sendRequestInBackground(provider, session, chat, options).catch(e => {
+                this.logService.error("[SessionsManagement] Failed to send background request:", e);
+            });
+            return;
+        }
+        this._onWillSendRequest.fire(session);
+        const sendOptions = this._augmentOptionsForTroubleshoot(session, options);
+        const chatResourceKey = ( chat.resource.toString());
+        this._pendingSendChatResources.add(chatResourceKey);
+        let updatedSession;
+        try {
+            updatedSession = await provider.sendRequest(session.sessionId, chat.resource, sendOptions);
+        } finally {
+            this._pendingSendChatResources.delete(chatResourceKey);
+        }
+        if (updatedSession.sessionId !== session.sessionId) {
+            this.logService.info(
+                `[SessionsManagement] sendRequest: active session replaced: ${session.sessionId} -> ${updatedSession.sessionId}`
+            );
+        }
+        this._onDidSendRequest.fire({
+            session: updatedSession,
+            chat,
+            isNewSession: false,
+            isNewChat: true,
+            options
+        });
+    }
+    async _sendRequestInBackground(provider, session, chat, options) {
+        const sendOptions = this._augmentOptionsForTroubleshoot(session, options);
+        const chatResourceKey = ( chat.resource.toString());
+        this._pendingSendChatResources.add(chatResourceKey);
+        let updatedSession;
+        try {
+            updatedSession = await provider.sendRequest(session.sessionId, chat.resource, sendOptions);
+        } finally {
+            this._pendingSendChatResources.delete(chatResourceKey);
+        }
+        if (this._store.isDisposed) {
+            return;
+        }
+        this._onDidSendRequest.fire({
+            session: updatedSession,
+            chat,
+            isNewSession: false,
+            isNewChat: true,
+            options
+        });
+    }
+    _getProvider(session) {
+        return this.sessionsProvidersService.getProviders().find(p => p.id === session.providerId);
+    }
+    async cancelCurrentRequest(session) {
+        const resource = session.mainChat.get().resource;
+        const modelRef = await this.chatService.acquireOrLoadSession(
+            resource,
+            ChatAgentLocation.Chat,
+            CancellationToken.None,
+            "sessionsManagement:cancel"
+        );
+        if (!modelRef) {
+            throw ( new Error(( localize(4903, "Failed to load chat session for cancellation."))));
+        }
+        try {
+            await this.chatService.cancelCurrentRequestForSession(resource, "sessionsManagement");
+        } finally {
+            modelRef.dispose();
+        }
+    }
+    async archiveSession(session) {
+        await this._getProvider(session)?.archiveSession(session.sessionId);
+        this._onDidArchiveSession.fire(session);
+    }
+    async unarchiveSession(session) {
+        await this._getProvider(session)?.unarchiveSession(session.sessionId);
+        this._onDidUnarchiveSession.fire(session);
+    }
+    async setSessionReadState(session, isRead) {
+        await this._getProvider(session)?.setSessionReadState(session.sessionId, isRead);
+    }
+    markRead(session) {
+        return this.setSessionReadState(session, true);
+    }
+    markUnread(session) {
+        return this.setSessionReadState(session, false);
+    }
+    async markAllRead(sessions) {
+        await Promise.all(sessions.map(session => this.setSessionReadState(session, true)));
+    }
+    async deleteSession(session) {
+        await this._getProvider(session)?.deleteSession(session.sessionId);
+        this._onDidDeleteSession.fire(session);
+    }
+    async deleteSessions(sessions) {
+        const byProvider = ( new Map());
+        for (const session of sessions) {
+            const provider = this._getProvider(session);
+            if (!provider) {
+                continue;
+            }
+            const group = byProvider.get(provider);
+            if (group) {
+                group.push(session);
+            } else {
+                byProvider.set(provider, [session]);
+            }
+        }
+        let firstError;
+        for (const [provider, providerSessions] of byProvider) {
+            try {
+                await provider.deleteSessions(providerSessions.map(session => session.sessionId));
+                for (const session of providerSessions) {
+                    this._onDidDeleteSession.fire(session);
+                }
+            } catch (error) {
+                firstError ??= error;
+            }
+        }
+        if (firstError !== undefined) {
+            throw firstError;
+        }
+    }
+    async deleteChat(session, chatUri, options) {
+        const deleted = await this._getProvider(session)?.deleteChat(session.sessionId, chatUri, options);
+        if (deleted) {
+            this._onDidDeleteChat.fire(session);
+        }
+    }
+    async renameChat(session, chatUri, title) {
+        await this._getProvider(session)?.renameChat(session.sessionId, chatUri, title);
+        this._onDidRenameChat.fire(session);
+    }
+    async renameSession(session, title) {
+        await this._getProvider(session)?.renameSession(session.sessionId, title);
+        this._onDidRenameSession.fire(session);
+    }
+    async removeSessionArtifact(session, artifactId) {
+        const provider = this._getProvider(session);
+        if (!session.capabilities.get().supportsRemoveArtifacts || !provider?.removeSessionArtifact) {
+            throw ( new Error(( localize(4904, "Removing artifacts is not supported for this session."))));
+        }
+        await provider.removeSessionArtifact(session.sessionId, artifactId);
+    }
+};
+SessionsManagementService = ( __decorate([( __param(0, ILogService)), ( __param(1, ISessionsProvidersService)), ( __param(2, IUriIdentityService)), ( __param(3, IChatService)), ( __param(4, IChatWidgetHistoryService)), ( __param(5, IStorageService)), ( __param(6, IPathService)), ( __param(7, IRemoteAgentHostService)), ( __param(8, IWorkspaceTrustManagementService))], SessionsManagementService));
+function isDeferredNewSessionRequestOptions(options) {
+    return options.kind === "deferred";
+}
+
+export { SessionsManagementService };