@codingame/monaco-vscode-chat-service-override 36.2.7 → 37.1.0

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostSessionListContribution.js

@@ -0,0 +1,129 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable, DisposableMap, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { affectsAgentHostProviderPreference, shouldSurfaceLocalAgentHostProvider } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService';
+import { IAgentHostService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService.service';
+import { IAgentHostEnablementService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostEnablementService.service';
+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 { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
+import { IChatSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service';
+import { IAgentHostSessionWorkingDirectoryResolver } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostSessionWorkingDirectoryResolver.service';
+import { AgentHostSessionListController } from './agentHostSessionListController.js';
+import { AgentHostSessionListStore } from './agentHostSessionListStore.js';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+let AgentHostSessionListContribution = class AgentHostSessionListContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.agentHostSessionListContribution";
+    }
+    constructor(
+        _agentHostService,
+        _chatSessionsService,
+        _configurationService,
+        _instantiationService,
+        environmentService,
+        _workingDirectoryResolver,
+        _agentHostEnablementService
+    ) {
+        super();
+        this._agentHostService = _agentHostService;
+        this._chatSessionsService = _chatSessionsService;
+        this._configurationService = _configurationService;
+        this._instantiationService = _instantiationService;
+        this._workingDirectoryResolver = _workingDirectoryResolver;
+        this._agentHostEnablementService = _agentHostEnablementService;
+        this._agentRegistrations = this._register(( new DisposableMap()));
+        this._initialized = false;
+        this._isSessionsWindow = environmentService.isSessionsWindow;
+        if (this._isSessionsWindow) {
+            return;
+        }
+        this._register(autorun(reader => {
+            if (this._agentHostEnablementService.enabled.read(reader)) {
+                const wasInitialized = this._initialized;
+                this._initialize();
+                const current = this._agentHostService.rootState.value;
+                if (wasInitialized && current && !(current instanceof Error) && this._sessionListStore) {
+                    this._handleRootStateChange(current, this._sessionListStore);
+                }
+            } else {
+                this._agentRegistrations.clearAndDisposeAll();
+            }
+        }));
+    }
+    _initialize() {
+        if (this._initialized) {
+            return;
+        }
+        this._initialized = true;
+        const sessionListStore = this._register(
+            this._instantiationService.createInstance(AgentHostSessionListStore, this._agentHostService)
+        );
+        this._sessionListStore = sessionListStore;
+        this._register(this._agentHostService.rootState.onDidChange(rootState => {
+            this._handleRootStateChange(rootState, sessionListStore);
+        }));
+        this._register(this._agentHostService.onAgentHostStart(() => {
+            sessionListStore.resetCache();
+        }));
+        const initialRootState = this._agentHostService.rootState.value;
+        if (initialRootState && !(initialRootState instanceof Error)) {
+            this._handleRootStateChange(initialRootState, sessionListStore);
+        }
+        this._register(this._configurationService.onDidChangeConfiguration(e => {
+            if (!affectsAgentHostProviderPreference(e, this._isSessionsWindow)) {
+                return;
+            }
+            const current = this._agentHostService.rootState.value;
+            if (current && !(current instanceof Error)) {
+                this._handleRootStateChange(current, sessionListStore);
+            }
+        }));
+    }
+    _shouldRegisterAgent(provider) {
+        return shouldSurfaceLocalAgentHostProvider(provider, this._configurationService, this._isSessionsWindow);
+    }
+    _handleRootStateChange(rootState, sessionListStore) {
+        if (!this._agentHostEnablementService.enabled.get()) {
+            return;
+        }
+        const allowed = rootState.agents.filter(agent => this._shouldRegisterAgent(agent.provider));
+        const incoming = ( new Set(( allowed.map(agent => agent.provider))));
+        for (const [provider] of this._agentRegistrations) {
+            if (!( incoming.has(provider))) {
+                this._agentRegistrations.deleteAndDispose(provider);
+            }
+        }
+        for (const agent of allowed) {
+            if (!( this._agentRegistrations.has(agent.provider))) {
+                this._registerAgent(agent, sessionListStore);
+            }
+        }
+    }
+    _registerAgent(agent, sessionListStore) {
+        const store = ( new DisposableStore());
+        this._agentRegistrations.set(agent.provider, store);
+        const sessionType = `agent-host-${agent.provider}`;
+        const listController = store.add(this._instantiationService.createInstance(
+            AgentHostSessionListController,
+            sessionType,
+            agent.provider,
+            sessionListStore,
+            undefined,
+            "local"
+        ));
+        store.add(
+            this._chatSessionsService.registerChatSessionItemController(sessionType, listController)
+        );
+        store.add(this._workingDirectoryResolver.registerResolver(
+            sessionType,
+            _sessionResource => undefined,
+            sessionResource => listController.isNewSession(sessionResource)
+        ));
+    }
+};
+AgentHostSessionListContribution = ( __decorate([( __param(0, IAgentHostService)), ( __param(1, IChatSessionsService)), ( __param(2, IConfigurationService)), ( __param(3, IInstantiationService)), ( __param(4, IWorkbenchEnvironmentService)), ( __param(5, IAgentHostSessionWorkingDirectoryResolver)), ( __param(6, IAgentHostEnablementService))], AgentHostSessionListContribution));
+
+export { AgentHostSessionListContribution };

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostSessionListController.d.ts

@@ -0,0 +1,42 @@
+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 { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
+import { IChatNewSessionRequest, IChatSessionItem, IChatSessionItemController, IChatSessionItemsDelta } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService";
+import { IAgentHostUntitledProvisionalSessionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostUntitledProvisionalSessionService.service";
+import { IAgentHostImportConversationStore } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostImportConversationStore.service";
+import { IAgentHostNewSessionFolderService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostNewSessionFolderService.service";
+import { AgentHostSessionListStore } from "./agentHostSessionListStore.js";
+/**
+ * Provides provider-specific session list items for the chat sessions sidebar
+ * by projecting the shared {@link AgentHostSessionListStore} state. The
+ * controller is a stateless view: items are derived from the store on demand
+ * and change events are a filtered/mapped projection of the store's event.
+ */
+export declare class AgentHostSessionListController extends Disposable implements IChatSessionItemController {
+    private readonly _sessionType;
+    private readonly _provider;
+    private readonly _sessionListStore;
+    private readonly _description;
+    private readonly _provisional;
+    private readonly _workspaceContextService;
+    private readonly _newSessionFolderService;
+    private readonly _importConversationStore;
+    readonly onDidChangeChatSessionItems: Event<IChatSessionItemsDelta>;
+    constructor(_sessionType: string, _provider: string, _sessionListStore: AgentHostSessionListStore, _description: string | undefined, _connectionAuthority: string, _provisional: IAgentHostUntitledProvisionalSessionService, _workspaceContextService: IWorkspaceContextService, _newSessionFolderService: IAgentHostNewSessionFolderService, _importConversationStore: IAgentHostImportConversationStore, chatService: IChatService);
+    get items(): readonly IChatSessionItem[];
+    isNewSession(resource: URI): boolean;
+    notifySessionMaterialized(resource: URI): void;
+    newChatSessionItem(request: IChatNewSessionRequest, token: CancellationToken): Promise<IChatSessionItem | undefined>;
+    deleteChatSessionItem(resource: URI, _token: CancellationToken): Promise<void>;
+    setChatSessionItemArchived(resource: URI, archived: boolean): void;
+    setChatSessionItemRead(resource: URI, isRead: boolean): void;
+    refresh(token: CancellationToken): Promise<void>;
+    private _projectDelta;
+    private _makeItemFromSummary;
+    private _makeItem;
+    private _resource;
+    private _buildMetadata;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostSessionListController.js

@@ -0,0 +1,221 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService';
+import { withEphemeralSessionMeta } from '../../../../../../platform/agentHost/common/meta/agentEphemeralSessionMeta.js';
+import { readSessionEhcliAdoptable, SESSION_META_EHCLI_ADOPTABLE_KEY } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+import { ChatSessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
+import { getAgentSessionProviderIcon } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessions';
+import { IAgentHostUntitledProvisionalSessionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostUntitledProvisionalSessionService.service';
+import { IAgentHostImportConversationStore } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostImportConversationStore.service';
+import { IAgentHostNewSessionFolderService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostNewSessionFolderService.service';
+import { AgentSession } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agent';
+import { SessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-session/state';
+
+function mapSessionStatus(status) {
+    if (status !== undefined && (status & SessionStatus.InputNeeded) === SessionStatus.InputNeeded) {
+        return ChatSessionStatus.NeedsInput;
+    }
+    if (status !== undefined && (status & SessionStatus.InProgress)) {
+        return ChatSessionStatus.InProgress;
+    }
+    if (status !== undefined && (status & SessionStatus.Error)) {
+        return ChatSessionStatus.Failed;
+    }
+    return ChatSessionStatus.Completed;
+}
+let AgentHostSessionListController = class AgentHostSessionListController extends Disposable {
+    constructor(
+        _sessionType,
+        _provider,
+        _sessionListStore,
+        _description,
+        _connectionAuthority,
+        _provisional,
+        _workspaceContextService,
+        _newSessionFolderService,
+        _importConversationStore,
+        chatService
+    ) {
+        super();
+        this._sessionType = _sessionType;
+        this._provider = _provider;
+        this._sessionListStore = _sessionListStore;
+        this._description = _description;
+        this._provisional = _provisional;
+        this._workspaceContextService = _workspaceContextService;
+        this._newSessionFolderService = _newSessionFolderService;
+        this._importConversationStore = _importConversationStore;
+        this._register(chatService.onDidDisposeSession(event => {
+            for (const resource of event.sessionResources) {
+                if (resource.scheme === this._sessionType) {
+                    this._sessionListStore.clearPendingNewSession(this._provider, AgentSession.id(resource));
+                }
+            }
+        }));
+        this.onDidChangeChatSessionItems = Event.filter(( Event.map(
+            this._sessionListStore.onDidChangeSessions,
+            delta => this._projectDelta(delta),
+            this._store
+        )), delta => delta !== undefined, this._store);
+    }
+    get items() {
+        return ( this._sessionListStore.getSessions(this._provider).map(
+            entry => this._makeItemFromSummary(entry.rawId, entry.summary, entry.statusKnown)
+        ));
+    }
+    isNewSession(resource) {
+        return resource.scheme === this._sessionType && this._sessionListStore.isPendingNewSession(this._provider, resource.path.substring(1));
+    }
+    notifySessionMaterialized(resource) {
+        if (resource.scheme === this._sessionType) {
+            this._sessionListStore.clearPendingNewSession(this._provider, AgentSession.id(resource));
+        }
+    }
+    async newChatSessionItem(request, token) {
+        if (token.isCancellationRequested) {
+            return undefined;
+        }
+        const rawId = generateUuid();
+        this._sessionListStore.addPendingNewSession(this._provider, rawId);
+        const now = Date.now();
+        const item = this._makeItem(rawId, {
+            title: request.prompt.trim(),
+            status: SessionStatus.InProgress,
+            createdAt: now,
+            modifiedAt: now
+        });
+        const metadata = withEphemeralSessionMeta(request._meta, request.isEphemeral ? true : undefined);
+        if (metadata) {
+            this._provisional.setSessionCreationMetadata(item.resource, metadata);
+        }
+        if (request.untitledResource) {
+            const workingDirectory = this._newSessionFolderService.getFolder(request.untitledResource) ?? this._newSessionFolderService.getDefaultFolder() ?? this._workspaceContextService.getWorkspace().folders[0]?.uri;
+            if (workingDirectory) {
+                this._newSessionFolderService.setFolder(item.resource, workingDirectory);
+            }
+            this._importConversationStore.rename(request.untitledResource, item.resource);
+            await this._provisional.tryRebind(request.untitledResource, item.resource, this._provider);
+        }
+        return item;
+    }
+    async deleteChatSessionItem(resource, _token) {
+        if (resource.scheme !== this._sessionType) {
+            return;
+        }
+        const rawId = AgentSession.id(resource);
+        await this._sessionListStore.disposeSession(this._provider, rawId);
+        this._sessionListStore.removeSession(this._provider, rawId);
+    }
+    setChatSessionItemArchived(resource, archived) {
+        if (resource.scheme !== this._sessionType) {
+            return;
+        }
+        this._sessionListStore.setSessionArchived(this._provider, AgentSession.id(resource), archived);
+    }
+    setChatSessionItemRead(resource, isRead) {
+        if (resource.scheme !== this._sessionType) {
+            return;
+        }
+        this._sessionListStore.setSessionRead(this._provider, AgentSession.id(resource), isRead);
+    }
+    async refresh(token) {
+        await this._sessionListStore.refresh(token);
+    }
+    _projectDelta(delta) {
+        let addedOrUpdated;
+        for (const entry of delta.addedOrUpdated ?? []) {
+            if (entry.provider !== this._provider) {
+                continue;
+            }
+            (addedOrUpdated ??= []).push(this._makeItemFromSummary(entry.rawId, entry.summary, entry.statusKnown));
+        }
+        let removed;
+        for (const removal of delta.removed ?? []) {
+            if (removal.provider !== this._provider) {
+                continue;
+            }
+            (removed ??= []).push(this._resource(removal.rawId));
+        }
+        if (!addedOrUpdated && !removed) {
+            return undefined;
+        }
+        return {
+            ...(addedOrUpdated ? {
+                addedOrUpdated
+            } : undefined),
+            ...(removed ? {
+                removed
+            } : undefined)
+        };
+    }
+    _makeItemFromSummary(rawId, summary, statusKnown) {
+        const workingDir = typeof summary.workingDirectories?.[0] === "string" ? ( URI.parse(summary.workingDirectories?.[0])) : summary.workingDirectories?.[0];
+        return this._makeItem(rawId, {
+            title: summary.title,
+            status: summary.status,
+            statusKnown,
+            activity: summary.activity,
+            workingDirectory: workingDir,
+            createdAt: Date.parse(summary.createdAt),
+            modifiedAt: Date.parse(summary.modifiedAt),
+            changesSummary: summary.changes,
+            adoptable: readSessionEhcliAdoptable(summary._meta)
+        });
+    }
+    _makeItem(rawId, opts) {
+        const inProgress = opts.status !== undefined && (opts.status & SessionStatus.InProgress) !== 0;
+        const description = inProgress && opts.activity ? opts.activity : this._description;
+        const metadata = opts.adoptable ? {
+            ...(this._buildMetadata(opts.workingDirectory) ?? {}),
+            [SESSION_META_EHCLI_ADOPTABLE_KEY]: true
+        } : this._buildMetadata(opts.workingDirectory);
+        return {
+            resource: this._resource(rawId),
+            label: opts.title || `Session ${rawId.substring(0, 8)}`,
+            description,
+            iconPath: getAgentSessionProviderIcon(this._sessionType),
+            status: mapSessionStatus(opts.status),
+            archived: opts.status !== undefined && (opts.status & SessionStatus.IsArchived) === SessionStatus.IsArchived,
+            isRead: opts.status !== undefined && opts.statusKnown !== false ? (opts.status & SessionStatus.IsRead) === SessionStatus.IsRead : undefined,
+            metadata,
+            timing: {
+                created: opts.createdAt,
+                lastRequestStarted: opts.modifiedAt,
+                lastRequestEnded: opts.modifiedAt
+            },
+            changes: opts.changesSummary ? {
+                files: opts.changesSummary.files ?? 0,
+                insertions: opts.changesSummary.additions ?? 0,
+                deletions: opts.changesSummary.deletions ?? 0
+            } : undefined
+        };
+    }
+    _resource(rawId) {
+        return ( URI.from({
+            scheme: this._sessionType,
+            path: `/${rawId}`
+        }));
+    }
+    _buildMetadata(workingDirectory) {
+        if (!this._description && !workingDirectory) {
+            return undefined;
+        }
+        const result = {};
+        if (this._description) {
+            result.remoteAgentHost = this._description;
+        }
+        if (workingDirectory) {
+            result.workingDirectoryPath = workingDirectory.fsPath;
+        }
+        return ( Object.keys(result)).length > 0 ? result : undefined;
+    }
+};
+AgentHostSessionListController = ( __decorate([( __param(5, IAgentHostUntitledProvisionalSessionService)), ( __param(6, IWorkspaceContextService)), ( __param(7, IAgentHostNewSessionFolderService)), ( __param(8, IAgentHostImportConversationStore)), ( __param(9, IChatService))], AgentHostSessionListController));
+
+export { AgentHostSessionListController };

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostSessionListStore.d.ts

@@ -0,0 +1,125 @@
+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 { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { type IAgentSessionMetadata } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService";
+import { type INotification, type SessionAction } from "../../../../../../platform/agentHost/common/state/sessionActions.js";
+import { type SessionSummary } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState";
+import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+/**
+ * Minimal agent-host connection surface needed by the session list store.
+ */
+export interface IAgentHostSessionListConnection {
+    readonly onDidNotification: Event<INotification>;
+    listSessions(): Promise<IAgentSessionMetadata[]>;
+    disposeSession(session: URI): Promise<void>;
+    dispatch(channel: string, action: SessionAction): void;
+}
+/**
+ * Provider-tagged backend session entry owned by the shared session-list store.
+ */
+export interface IAgentHostSessionListEntry {
+    readonly provider: string;
+    readonly rawId: string;
+    readonly summary: SessionSummary;
+    /**
+     * Whether {@link summary}'s status came from the host. `listSessions()`
+     * metadata carries no status for a cold session that has never been marked
+     * read or archived, and `SessionSummary.status` is required — so the status
+     * is synthesized and the session-scoped flags on it mean nothing.
+     */
+    readonly statusKnown: boolean;
+}
+/**
+ * Provider-tagged backend session removal emitted by the shared session-list store.
+ */
+export interface IAgentHostSessionListRemoval {
+    readonly provider: string;
+    readonly rawId: string;
+    readonly session: URI;
+}
+/**
+ * Backend session delta emitted by the shared session-list store. Every delta
+ * carries the affected entries, so consumers can apply them incrementally:
+ * narrow notifications carry the single changed/removed entry, while a refresh
+ * carries the full current entry set (plus any sessions that dropped out).
+ */
+export interface IAgentHostSessionListDelta {
+    readonly addedOrUpdated?: readonly IAgentHostSessionListEntry[];
+    readonly removed?: readonly IAgentHostSessionListRemoval[];
+}
+/**
+ * Shared provider-agnostic cache of agent-host sessions. It owns the
+ * provider-wide listSessions refresh, workspace filtering, and root session
+ * notifications. Per-provider list controllers project this state into chat
+ * session items.
+ */
+export declare class AgentHostSessionListStore extends Disposable {
+    private readonly _connection;
+    private readonly _workspaceContextService;
+    private readonly _logService;
+    private readonly _onDidChangeSessions;
+    readonly onDidChangeSessions: Event<IAgentHostSessionListDelta>;
+    private readonly _entries;
+    /**
+     * Backend session keys for sessions a controller created locally (via
+     * `newChatSessionItem`) that the backend has not yet announced. Tracked here
+     * so per-provider controllers stay stateless; cleared once the backend
+     * surfaces or removes the session.
+     */
+    private readonly _pendingNewSessions;
+    private _cacheValid;
+    private _refreshInFlight;
+    /**
+     * Incremented whenever the in-memory list is mutated outside of
+     * {@link refresh}. Used to detect races where a `root/sessionAdded`,
+     * `root/sessionRemoved`, or `root/sessionSummaryChanged` notification
+     * arrives while a `listSessions()` round-trip is in flight.
+     */
+    private _mutationGeneration;
+    /** Sessions already reported as having an unusable (non-local) project root. */
+    private readonly _reportedNonLocalProjects;
+    constructor(_connection: IAgentHostSessionListConnection, _workspaceContextService: IWorkspaceContextService, _logService: ILogService);
+    getSessions(provider: string): readonly IAgentHostSessionListEntry[];
+    /** Record a session created locally before the backend has announced it. */
+    addPendingNewSession(provider: string, rawId: string): void;
+    /** Whether a session was created locally and the backend has not surfaced it yet. */
+    isPendingNewSession(provider: string, rawId: string): boolean;
+    /** Stop treating a locally-created session as pending without adding it to the visible list. */
+    clearPendingNewSession(provider: string, rawId: string): void;
+    resetCache(): void;
+    disposeSession(provider: string, rawId: string): Promise<void>;
+    setSessionArchived(provider: string, rawId: string, archived: boolean): void;
+    setSessionRead(provider: string, rawId: string, isRead: boolean): void;
+    /**
+     * Optimistically flips a session-scoped status flag and dispatches the owning
+     * action, so the host can fan the change out to other connected clients. An
+     * uncached session still dispatches; the summary notification seeds the entry.
+     */
+    private _setSessionFlag;
+    removeSession(provider: string, rawId: string): void;
+    private _removeSessionFromList;
+    refresh(token: CancellationToken): Promise<void>;
+    private _doRefresh;
+    private _onNotification;
+    private _makeEntryFromMetadata;
+    private _makeEntryFromSummary;
+    /** Uses workspace-file provenance for multi-root workspaces and path containment otherwise. */
+    private _isSessionInWorkspace;
+    private _computeSessionInWorkspace;
+    private _filterEntriesToWorkspace;
+    private _matchesAnyFolder;
+    /**
+     * The directories a session may be matched against a workspace folder by: its
+     * working directories plus - for legacy Copilot CLI sessions only - its
+     * server-owned project (repository) root. Those legacy sessions run out of a
+     * `copilot-worktrees/` directory outside the repository, so working
+     * directories alone would hide them from a window opened on that repository.
+     * The marker has to outlive adoption: a migrated session is still a legacy
+     * session and must not drop out of the list the moment it migrates.
+     */
+    private _containmentCandidates;
+    private _toRemoval;
+    private _key;
+}