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

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

@@ -0,0 +1,419 @@
+
+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 { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { themeColorFromId } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+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 { SessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
+import { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+
+var SessionsListModelService_1;
+var SessionListModelChangeKind;
+(function(SessionListModelChangeKind) {
+    SessionListModelChangeKind["Pinned"] = "pinned";
+    SessionListModelChangeKind["Sort"] = "sort";
+})(SessionListModelChangeKind || (SessionListModelChangeKind = {}));
+let SessionsListModelService = class SessionsListModelService extends Disposable {
+    static {
+        SessionsListModelService_1 = this;
+    }
+    static {
+        this.PINNED_SESSIONS_KEY = "sessionsListControl.pinnedSessions";
+    }
+    static {
+        this.SORT_OVERRIDES_KEY = "sessionsListControl.sortOverrides";
+    }
+    static {
+        this.UPDATED_DEFAULT_PLACEMENTS_KEY = "sessionsListControl.updatedDefaultPlacements";
+    }
+    static {
+        this.LEGACY_READ_SESSIONS_KEY = "sessionsListControl.readSessions";
+    }
+    static {
+        this.READ_MIGRATION_DONE_KEY = "sessionsListControl.readMigrationDone";
+    }
+    static {
+        this.UNREAD_DEFAULT_CUTOFF = ( new Date("2026-05-12T00:00:00.000Z"));
+    }
+    constructor(storageService, sessionsManagementService) {
+        super();
+        this.storageService = storageService;
+        this.sessionsManagementService = sessionsManagementService;
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._pinnedSessionIds = this.loadSet(SessionsListModelService_1.PINNED_SESSIONS_KEY);
+        this._sortOverrides = this.loadSortOverrides();
+        this._updatedDefaultPlacements = this.loadUpdatedDefaultPlacements();
+        const legacyRead = this.loadSet(SessionsListModelService_1.LEGACY_READ_SESSIONS_KEY);
+        this._legacyReadSessionIds = legacyRead.size > 0 ? legacyRead : undefined;
+        this._migratedReadSessionIds = this.loadSet(SessionsListModelService_1.READ_MIGRATION_DONE_KEY);
+        this._register(this.sessionsManagementService.onDidChangeSessions(
+            () => this.updateDefaultPlacement(this.sessionsManagementService.getSessions())
+        ));
+        this.updateDefaultPlacement(this.sessionsManagementService.getSessions());
+        this._register(this.sessionsManagementService.onDidDeleteSession(session => {
+            this.deleteSession(session);
+        }));
+    }
+    migrateLegacyReadState(session) {
+        const sessionId = session.sessionId;
+        if (( this._migratedReadSessionIds.has(sessionId))) {
+            return;
+        }
+        const wasRead = (this._legacyReadSessionIds?.has(sessionId) ?? false) || session.updatedAt.get() < SessionsListModelService_1.UNREAD_DEFAULT_CUTOFF;
+        if (!wasRead) {
+            return;
+        }
+        this.sessionsManagementService.markRead(session);
+        this._migratedReadSessionIds.add(sessionId);
+        this.saveSet(
+            SessionsListModelService_1.READ_MIGRATION_DONE_KEY,
+            this._migratedReadSessionIds
+        );
+    }
+    pinSession(session) {
+        if (( this._pinnedSessionIds.has(session.sessionId))) {
+            return;
+        }
+        this._pinnedSessionIds.add(session.sessionId);
+        this.saveSet(SessionsListModelService_1.PINNED_SESSIONS_KEY, this._pinnedSessionIds);
+        this._onDidChange.fire({
+            changes: [{
+                sessionId: session.sessionId,
+                kind: SessionListModelChangeKind.Pinned
+            }]
+        });
+    }
+    unpinSession(session) {
+        if (!( this._pinnedSessionIds.has(session.sessionId))) {
+            return;
+        }
+        this._pinnedSessionIds.delete(session.sessionId);
+        this.saveSet(SessionsListModelService_1.PINNED_SESSIONS_KEY, this._pinnedSessionIds);
+        this._onDidChange.fire({
+            changes: [{
+                sessionId: session.sessionId,
+                kind: SessionListModelChangeKind.Pinned
+            }]
+        });
+    }
+    unpinSessions(sessions) {
+        const changed = [];
+        for (const session of sessions) {
+            if (this._pinnedSessionIds.delete(session.sessionId)) {
+                changed.push({
+                    sessionId: session.sessionId,
+                    kind: SessionListModelChangeKind.Pinned
+                });
+            }
+        }
+        if (changed.length > 0) {
+            this.saveSet(SessionsListModelService_1.PINNED_SESSIONS_KEY, this._pinnedSessionIds);
+            this._onDidChange.fire({
+                changes: changed
+            });
+        }
+    }
+    isSessionPinned(session) {
+        return ( this._pinnedSessionIds.has(session.sessionId));
+    }
+    updateDefaultPlacement(sessionsToCheck) {
+        const sessions = this.sessionsManagementService.getSessions();
+        const changedSessionIds = ( new Set());
+        let sortChanged = this.expireUpdatedDefaultPlacements(sessionsToCheck, changedSessionIds);
+        for (const mode of ["created", "updated"]) {
+            for (const session of sessionsToCheck) {
+                if (this.ensureCreatorAdjacentSortOverride(session, mode, sessions, ( new Set()), changedSessionIds)) {
+                    sortChanged = true;
+                }
+            }
+        }
+        if (sortChanged) {
+            this.saveSortOverrides();
+            this.saveUpdatedDefaultPlacements();
+        }
+        if (changedSessionIds.size > 0) {
+            this._onDidChange.fire({
+                changes: [...changedSessionIds].map(sessionId => ({
+                    sessionId,
+                    kind: SessionListModelChangeKind.Sort
+                }))
+            });
+        }
+    }
+    ensureCreatorAdjacentSortOverride(session, mode, sessions, visiting, changedSessionIds) {
+        if (( this._sortOverrides[mode].has(session.sessionId)) || (mode === "updated" && ( this._updatedDefaultPlacements.has(session.sessionId)))) {
+            return false;
+        }
+        const creatorResource = session.createdBySession?.get()?.session;
+        if (!creatorResource) {
+            return false;
+        }
+        const creator = this.sessionsManagementService.getSession(creatorResource);
+        if (!creator || ( visiting.has(session.sessionId))) {
+            return false;
+        }
+        visiting.add(session.sessionId);
+        this.ensureCreatorAdjacentSortOverride(creator, mode, sessions, visiting, changedSessionIds);
+        visiting.delete(session.sessionId);
+        if (creator.createdBySession?.get() && !( this._sortOverrides[mode].has(creator.sessionId))) {
+            return false;
+        }
+        const creatorKey = this.getSortKey(creator, mode);
+        const sorted = sessions.filter(candidate => candidate.sessionId !== session.sessionId).sort((a, b) => this.getSortKey(b, mode) - this.getSortKey(a, mode));
+        const creatorIndex = sorted.findIndex(candidate => candidate.sessionId === creator.sessionId);
+        if (creatorIndex < 0) {
+            return false;
+        }
+        const below = sorted[creatorIndex + 1];
+        const belowKey = below ? this.getSortKey(below, mode) : undefined;
+        const createdSessionKey = belowKey !== undefined && creatorKey > belowKey ? (creatorKey + belowKey) / 2 : creatorKey - 60_000;
+        this._sortOverrides[mode].set(session.sessionId, createdSessionKey);
+        if (mode === "updated") {
+            this._updatedDefaultPlacements.set(session.sessionId, this.getNaturalSortKey(session, mode));
+        }
+        changedSessionIds.add(session.sessionId);
+        return true;
+    }
+    expireUpdatedDefaultPlacements(sessionsToCheck, changedSessionIds) {
+        let changed = false;
+        for (const session of sessionsToCheck) {
+            const naturalKeyAtPlacement = this._updatedDefaultPlacements.get(session.sessionId);
+            if (naturalKeyAtPlacement === undefined || naturalKeyAtPlacement === null || naturalKeyAtPlacement === this.getNaturalSortKey(session, "updated")) {
+                continue;
+            }
+            this._sortOverrides.updated.delete(session.sessionId);
+            this._updatedDefaultPlacements.set(session.sessionId, null);
+            changedSessionIds.add(session.sessionId);
+            changed = true;
+        }
+        return changed;
+    }
+    getNaturalSortKey(session, mode) {
+        return mode === "updated" ? session.updatedAt.get().getTime() : session.createdAt.getTime();
+    }
+    getSortKey(session, mode) {
+        const override = this._sortOverrides[mode].get(session.sessionId);
+        return override ?? this.getNaturalSortKey(session, mode);
+    }
+    hasSortOverride(sessionId, mode) {
+        return ( this._sortOverrides[mode].has(sessionId));
+    }
+    applySortChanges(mode, set, clear) {
+        const map = this._sortOverrides[mode];
+        const changes = [];
+        let updatedDefaultPlacementChanged = false;
+        for (const sessionId of clear) {
+            if (mode === "updated" && this._updatedDefaultPlacements.delete(sessionId)) {
+                updatedDefaultPlacementChanged = true;
+            }
+            const session = this.sessionsManagementService.getSessions().find(session => session.sessionId === sessionId);
+            if (session?.createdBySession?.get()) {
+                const naturalKey = this.getNaturalSortKey(session, mode);
+                if (map.get(sessionId) !== naturalKey) {
+                    map.set(sessionId, naturalKey);
+                    changes.push({
+                        sessionId,
+                        kind: SessionListModelChangeKind.Sort
+                    });
+                }
+            } else if (map.delete(sessionId)) {
+                changes.push({
+                    sessionId,
+                    kind: SessionListModelChangeKind.Sort
+                });
+            }
+        }
+        for (const [sessionId, value] of set) {
+            if (mode === "updated" && this._updatedDefaultPlacements.delete(sessionId)) {
+                updatedDefaultPlacementChanged = true;
+            }
+            if (map.get(sessionId) !== value) {
+                map.set(sessionId, value);
+                changes.push({
+                    sessionId,
+                    kind: SessionListModelChangeKind.Sort
+                });
+            }
+        }
+        if (changes.length > 0) {
+            this.saveSortOverrides();
+            this._onDidChange.fire({
+                changes
+            });
+        }
+        if (updatedDefaultPlacementChanged) {
+            this.saveUpdatedDefaultPlacements();
+        }
+    }
+    getStatusIcon(status, isRead, isArchived, completedStateIcon) {
+        switch (status) {
+        case SessionStatus.InProgress:
+            return {
+                ...Codicon.sessionInProgress,
+                color: themeColorFromId("textLink.foreground")
+            };
+        case SessionStatus.NeedsInput:
+            return {
+                ...Codicon.circleFilled,
+                color: themeColorFromId("list.warningForeground")
+            };
+        case SessionStatus.Error:
+            return {
+                ...Codicon.error,
+                color: themeColorFromId("errorForeground")
+            };
+        default:
+            if (isArchived) {
+                return {
+                    ...Codicon.passFilled,
+                    color: themeColorFromId("agentSessionReadIndicator.foreground")
+                };
+            }
+            if (!isRead) {
+                return {
+                    ...Codicon.circleFilled,
+                    color: themeColorFromId("textLink.foreground")
+                };
+            }
+            if (completedStateIcon) {
+                return completedStateIcon;
+            }
+            return {
+                ...Codicon.circleSmallFilled,
+                color: themeColorFromId("agentSessionReadIndicator.foreground")
+            };
+        }
+    }
+    deleteSession(session) {
+        const changes = [];
+        if (this._pinnedSessionIds.delete(session.sessionId)) {
+            this.saveSet(SessionsListModelService_1.PINNED_SESSIONS_KEY, this._pinnedSessionIds);
+            changes.push({
+                sessionId: session.sessionId,
+                kind: SessionListModelChangeKind.Pinned
+            });
+        }
+        let sortChanged = false;
+        if (this._sortOverrides.created.delete(session.sessionId)) {
+            sortChanged = true;
+        }
+        if (this._sortOverrides.updated.delete(session.sessionId)) {
+            sortChanged = true;
+        }
+        if (this._updatedDefaultPlacements.delete(session.sessionId)) {
+            this.saveUpdatedDefaultPlacements();
+        }
+        if (sortChanged) {
+            this.saveSortOverrides();
+            changes.push({
+                sessionId: session.sessionId,
+                kind: SessionListModelChangeKind.Sort
+            });
+        }
+        if (changes.length > 0) {
+            this._onDidChange.fire({
+                changes
+            });
+        }
+    }
+    loadSet(key) {
+        const raw = this.storageService.get(key, StorageScope.PROFILE);
+        if (raw) {
+            try {
+                const arr = JSON.parse(raw);
+                if (Array.isArray(arr)) {
+                    return ( new Set(arr));
+                }
+            } catch {}
+        }
+        return ( new Set());
+    }
+    saveSet(key, set) {
+        if (set.size === 0) {
+            this.storageService.remove(key, StorageScope.PROFILE);
+        } else {
+            this.storageService.store(key, JSON.stringify([...set]), StorageScope.PROFILE, StorageTarget.USER);
+        }
+    }
+    loadSortOverrides() {
+        const result = {
+            created: ( new Map()),
+            updated: ( new Map())
+        };
+        const raw = this.storageService.get(SessionsListModelService_1.SORT_OVERRIDES_KEY, StorageScope.PROFILE);
+        if (raw) {
+            try {
+                const parsed = JSON.parse(raw);
+                for (const mode of ["created", "updated"]) {
+                    const entries = parsed[mode];
+                    if (entries) {
+                        for (const [sessionId, value] of Object.entries(entries)) {
+                            if (typeof value === "number") {
+                                result[mode].set(sessionId, value);
+                            }
+                        }
+                    }
+                }
+            } catch {}
+        }
+        return result;
+    }
+    saveSortOverrides() {
+        if (this._sortOverrides.created.size === 0 && this._sortOverrides.updated.size === 0) {
+            this.storageService.remove(SessionsListModelService_1.SORT_OVERRIDES_KEY, StorageScope.PROFILE);
+            return;
+        }
+        const serialized = {
+            created: Object.fromEntries(this._sortOverrides.created),
+            updated: Object.fromEntries(this._sortOverrides.updated)
+        };
+        this.storageService.store(
+            SessionsListModelService_1.SORT_OVERRIDES_KEY,
+            JSON.stringify(serialized),
+            StorageScope.PROFILE,
+            StorageTarget.USER
+        );
+    }
+    loadUpdatedDefaultPlacements() {
+        const result = ( new Map());
+        const raw = this.storageService.get(
+            SessionsListModelService_1.UPDATED_DEFAULT_PLACEMENTS_KEY,
+            StorageScope.PROFILE
+        );
+        if (!raw) {
+            return result;
+        }
+        try {
+            const parsed = JSON.parse(raw);
+            for (const [sessionId, value] of Object.entries(parsed)) {
+                if (typeof value === "number" || value === null) {
+                    result.set(sessionId, value);
+                }
+            }
+        } catch {}
+        return result;
+    }
+    saveUpdatedDefaultPlacements() {
+        if (this._updatedDefaultPlacements.size === 0) {
+            this.storageService.remove(
+                SessionsListModelService_1.UPDATED_DEFAULT_PLACEMENTS_KEY,
+                StorageScope.PROFILE
+            );
+            return;
+        }
+        this.storageService.store(
+            SessionsListModelService_1.UPDATED_DEFAULT_PLACEMENTS_KEY,
+            JSON.stringify(Object.fromEntries(this._updatedDefaultPlacements)),
+            StorageScope.PROFILE,
+            StorageTarget.USER
+        );
+    }
+};
+SessionsListModelService = SessionsListModelService_1 = ( __decorate([( __param(0, IStorageService)), ( __param(1, ISessionsManagementService))], SessionsListModelService));
+
+export { SessionListModelChangeKind, SessionsListModelService };

package/vscode/src/vs/sessions/services/sessions/browser/sessionsManagementService.d.ts

@@ -0,0 +1,229 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+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 { IChatWidgetHistoryService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/widget/chatWidgetHistoryService.service";
+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 { ICreateNewChatInSessionOptions, ICreateNewSessionOptions, IProviderSessionType, ISendRequestOptions, ISendRequestSentEvent, ISessionsChangeEvent, NewSessionRequestOptions } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement";
+import { ISessionsManagementService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service";
+import { ISessionsProvidersService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service";
+import { IDeleteChatOptions, type SessionResourceResolveReason } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsProvider";
+import { IChat, ISession, ISessionWorkspace, ISideChatSelection, ISessionType } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session";
+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";
+export declare class SessionsManagementService extends Disposable implements ISessionsManagementService {
+    private readonly logService;
+    private readonly sessionsProvidersService;
+    private readonly uriIdentityService;
+    private readonly chatService;
+    private readonly chatWidgetHistoryService;
+    private readonly storageService;
+    private readonly pathService;
+    private readonly remoteAgentHostService;
+    private readonly workspaceTrustManagementService;
+    readonly _serviceBrand: undefined;
+    private readonly _onDidChangeSessions;
+    readonly onDidChangeSessions: Event<ISessionsChangeEvent>;
+    private readonly _onDidStartSession;
+    readonly onDidStartSession: Event<ISession>;
+    private readonly _onWillSendRequest;
+    readonly onWillSendRequest: Event<ISession>;
+    private readonly _onDidSendRequest;
+    readonly onDidSendRequest: Event<ISendRequestSentEvent>;
+    private readonly _onDidArchiveSession;
+    readonly onDidArchiveSession: Event<ISession>;
+    private readonly _onDidUnarchiveSession;
+    readonly onDidUnarchiveSession: Event<ISession>;
+    private readonly _onDidDeleteSession;
+    readonly onDidDeleteSession: Event<ISession>;
+    private readonly _onDidDeleteChat;
+    readonly onDidDeleteChat: Event<ISession>;
+    private readonly _onDidRenameChat;
+    readonly onDidRenameChat: Event<ISession>;
+    private readonly _onDidRenameSession;
+    readonly onDidRenameSession: Event<ISession>;
+    private readonly _onDidChangeSessionTypes;
+    readonly onDidChangeSessionTypes: Event<void>;
+    private readonly _onDidReplaceSession;
+    readonly onDidReplaceSession: Event<{
+        readonly from: ISession;
+        readonly to: ISession;
+    }>;
+    private readonly _onDidDiscardNewSession;
+    readonly onDidDiscardNewSession: Event<ISession>;
+    private readonly _onDidReplaceNewDraftSession;
+    readonly onDidReplaceNewDraftSession: Event<{
+        readonly from: ISession;
+        readonly to: ISession;
+    }>;
+    private _sessionTypes;
+    /** Tracks the in-progress new session (composed but not yet sent). */
+    private readonly _newSession;
+    readonly newSession: IObservable<ISession | undefined>;
+    /** Tracks the Automation dialog's in-progress session draft. */
+    private readonly _automationSession;
+    readonly automationSession: IObservable<ISession | undefined>;
+    private readonly _providerListeners;
+    private readonly _disposeCts;
+    private readonly _unlistedNewSessions;
+    private readonly _inFlightNewSessionRequests;
+    /**
+     * Chat resources for which this service has just kicked off a
+     * `provider.sendRequest` and will emit `_onDidSendRequest` manually after
+     * the provider call resolves. Used to suppress the duplicate event that
+     * would otherwise arrive via {@link IChatService.onDidSubmitRequest},
+     * which fires synchronously inside the same provider call.
+     */
+    private readonly _pendingSendChatResources;
+    constructor(logService: ILogService, sessionsProvidersService: ISessionsProvidersService, uriIdentityService: IUriIdentityService, chatService: IChatService, chatWidgetHistoryService: IChatWidgetHistoryService, storageService: IStorageService, pathService: IPathService, remoteAgentHostService: IRemoteAgentHostService, workspaceTrustManagementService: IWorkspaceTrustManagementService);
+    private _onProvidersChanged;
+    private _subscribeToProviders;
+    private _handleDidReplaceSession;
+    private onDidChangeSessionsFromSessionsProviders;
+    /**
+     * Resolves a session resource to the one that should actually be opened,
+     * giving providers a chance to supersede another provider's resource (legacy
+     * Copilot CLI adoption). Falls back to `resource` when no provider claims it,
+     * so an unresolvable session still opens the way it does today.
+     */
+    resolveSessionResource(resource: URI, reason?: SessionResourceResolveReason): Promise<URI>;
+    getSessions(): ISession[];
+    getInFlightNewSessionRequests(): readonly ISession[];
+    private trackInFlightNewSessionRequest;
+    private _getMergedSessions;
+    /**
+     * A legacy Copilot CLI session migrated in place to the agent host is briefly
+     * listed by BOTH the extension-host provider (`copilotcli:/<id>`) and the
+     * agent-host provider (`agent-host-copilotcli:/<id>`) for the same underlying
+     * SDK session id — the workbench agent-session model caches the stale legacy
+     * entry even after the extension stops reporting it. Drop the legacy entry so
+     * exactly one row shows per session.
+     *
+     * A legacy row that has no twin yet stays visible: opening it redirects through
+     * {@link resolveSessionResource} and adopts it, so it is never a dead end.
+     */
+    private _dedupeMigratedCopilotCliSessions;
+    getSession(resource: URI): ISession | undefined;
+    getSessionForChatResource(resource: URI): {
+        session: ISession;
+        chat: IChat;
+    } | undefined;
+    getAllSessionTypes(): ISessionType[];
+    getAllProviderSessionTypes(): IProviderSessionType[];
+    getSessionTypesForFolder(folderUri: URI): IProviderSessionType[];
+    getQuickChatSessionTypes(): IProviderSessionType[];
+    isNewSessionTargetAvailable(folderUri: URI, options?: ICreateNewSessionOptions): boolean;
+    isQuickChatTargetAvailable(options?: ICreateNewSessionOptions): boolean;
+    private _isTargetAvailable;
+    resolveWorkspace(folderUri: URI, preferredProviderId?: string): {
+        providerId: string;
+        workspace: ISessionWorkspace;
+    } | undefined;
+    private _collectSessionTypes;
+    private _updateSessionTypes;
+    discardNewSession(session?: ISession): void;
+    discardAutomationSession(session?: ISession): void;
+    /**
+     * Resolve the provider and session type to use for a new session in the
+     * given folder. Includes that provider's resolved workspace so headless
+     * callers can enforce provider-specific trust without resolving it again.
+     */
+    private _resolveProviderForNewSession;
+    createNewSession(folderUri: URI, options?: ICreateNewSessionOptions): ISession;
+    createAutomationSession(folderUri: URI, options?: ICreateNewSessionOptions): ISession;
+    /**
+     * Resolve the provider and session type to use for a quick chat, keyed on
+     * {@link ISessionsProvider.supportsQuickChats} instead of `resolveWorkspace`.
+     * Honors an explicit `options.sessionTypeId` (validated against the chosen
+     * provider) and otherwise defaults to the last-used type, then the first
+     * advertised one. Throws when no capable provider/type can be resolved.
+     */
+    private _resolveProviderForQuickChat;
+    /** Default quick-chat session type: the last-used one if still advertised, else the first. */
+    private _defaultQuickChatSessionType;
+    createQuickChat(options?: ICreateNewSessionOptions): ISession;
+    createAutomationQuickChat(options?: ICreateNewSessionOptions): ISession;
+    private _providerCreateSessionOptions;
+    getAutomationSessionConfiguration(session: ISession): Promise<import("@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsProvider").IAutomationSessionConfiguration | null | undefined>;
+    supportsAutomationSessionConfiguration(session: ISession): boolean;
+    usesCombinedNewSessionConfigPicker(session: ISession): boolean;
+    createNewChatInSession(session: ISession, options?: ICreateNewChatInSessionOptions): Promise<IChat | undefined>;
+    forkChatInSession(session: ISession, sourceChat: URI, turnId: string): Promise<IChat>;
+    createSideChatInSession(session: ISession, sourceChat: URI, turnId: string, selection?: ISideChatSelection): Promise<IChat>;
+    /**
+     * For a `/troubleshoot` request, strip any `#session` marker attachments and
+     * append a `Session log:` line with the resolved host-local `events.jsonl`
+     * path(s) — the referenced sessions if present, otherwise the current one.
+     * Returns `options` unchanged when there is nothing to do.
+     */
+    private _augmentOptionsForTroubleshoot;
+    sendNewChatRequest(session: ISession, options: ISendRequestOptions): Promise<void>;
+    private _prepareNewSessionForSend;
+    /**
+     * Create a new session for the given folder and send a chat request to it,
+     * without navigating into the started session. The started session appears
+     * in the sessions list once the provider commits it, while the user's
+     * current view is left untouched. Returns the committed session,
+     * or `undefined` if the service was disposed during the send.
+     *
+     * Unlike {@link sendNewChatRequest} with `background`, this does not go
+     * through the new-session composer: it creates a fresh session purely for
+     * this request and never sets it as pending/active. Intended for callers
+     * outside the composer that want to kick off a session programmatically.
+     *
+     * If the send or any configuration setter fails, the stranded draft is
+     * disposed through its provider and the error is rethrown.
+     */
+    createAndSendNewChatRequest(folderUri: URI, options: NewSessionRequestOptions, createOptions?: ICreateNewSessionOptions, token?: CancellationToken): Promise<ISession | undefined>;
+    createAndSendQuickChatRequest(options: ISendRequestOptions, createOptions?: ICreateNewSessionOptions, token?: CancellationToken): Promise<ISession | undefined>;
+    private _configureAndSendNewSession;
+    private _configureNewSession;
+    private _waitForRequestedModel;
+    dispose(): void;
+    private _prepareAndSendNewChatRequestInBackground;
+    /**
+     * Commit a new-session request: fire {@link _onWillSendRequest}, create the
+     * new chat via the provider, send the request, and—on success—fire
+     * {@link _onDidStartSession} and {@link _onDidSendRequest}. The started
+     * session is never swapped into the visible chat slot, so it simply appears
+     * in the sessions list once the provider commits it.
+     *
+     * Owns the full will/did send lifecycle so callers do not fire the paired
+     * events themselves. Errors are propagated to the caller; this method does
+     * not clean up the stranded draft, so callers own any view handling and the
+     * error handling (e.g. disposing the stranded draft via
+     * {@link ISessionsProvider.deleteNewSession}).
+     *
+     * Providers are multi-new-session aware, so the graduating session and a
+     * concurrently reseeded composer draft coexist without conflict.
+     */
+    private _sendNewChatRequestInBackground;
+    sendRequest(session: ISession, chat: IChat, options: ISendRequestOptions): Promise<void>;
+    /**
+     * Send a request for an existing chat in the background: commit the send via
+     * the provider and—on success—fire {@link _onDidSendRequest}. Unlike the
+     * foreground {@link sendRequest} path this does not fire
+     * {@link _onWillSendRequest}, so the view's send-follow never navigates the
+     * visible slot into the sent chat. Errors are propagated to the caller.
+     */
+    private _sendRequestInBackground;
+    private _getProvider;
+    cancelCurrentRequest(session: ISession): Promise<void>;
+    archiveSession(session: ISession): Promise<void>;
+    unarchiveSession(session: ISession): Promise<void>;
+    setSessionReadState(session: ISession, isRead: boolean): Promise<void>;
+    markRead(session: ISession): Promise<void>;
+    markUnread(session: ISession): Promise<void>;
+    markAllRead(sessions: readonly ISession[]): Promise<void>;
+    deleteSession(session: ISession): Promise<void>;
+    deleteSessions(sessions: readonly ISession[]): Promise<void>;
+    deleteChat(session: ISession, chatUri: URI, options?: IDeleteChatOptions): Promise<void>;
+    renameChat(session: ISession, chatUri: URI, title: string): Promise<void>;
+    renameSession(session: ISession, title: string): Promise<void>;
+    removeSessionArtifact(session: ISession, artifactId: string): Promise<void>;
+}