@codingame/monaco-vscode-chat-cloud-service-override 0.0.0-stage → 38.1.1

package/vscode/src/vs/sessions/contrib/providers/copilotChatSessions/browser/copilotChatSessionsProvider.d.ts

@@ -0,0 +1,422 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { IMarkdownString } from "@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent";
+import { Disposable, IDisposable, IReference } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable, ISettableObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { ThemeIcon } from "@codingame/monaco-vscode-api/vscode/vs/base/common/themables";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ICommandService } from "@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IAgentSession } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsModel";
+import { IAgentSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsService.service";
+import { AgentSessionTarget } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessions";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
+import { IChatSessionProviderOptionItem } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService";
+import { IChatSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service";
+import { AutomationModelConfiguration } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/automations/browser/automationModelConfiguration";
+import { ChatModelSource, ISession, IChat, ISessionWorkspace, ISideChatSelection, SessionStatus, IGitHubInfo, ISessionArtifact, ISessionType, ISessionWorkspaceBrowseAction, ISessionFileChange, IChatCheckpoints, ISessionChangesSummary, ISessionCreationReference, ISessionPreparationProgress } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session";
+import { IAutomationSessionConfiguration, IDeleteChatOptions, ISendRequestOptions, ISessionChangeEvent, ISessionConfigProvider, ISessionConfigurationSnapshot, ISessionModelPickerOptions, ISessionModelsSnapshot, ISessionsProvider, ISessionsProviderCreateSessionOptions } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsProvider";
+import { ISessionOptionGroup } from "../../../chat/browser/newSession.js";
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { ILanguageModelsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IChatRequestVariableEntry } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/attachments/chatVariableEntries";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { ILabelService } from "@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { INotificationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IGitHubService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/github/browser/githubService.service";
+import { IPullRequestIconCache } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/github/browser/pullRequestIconCache.service";
+import { IUriIdentityService } from "@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
+import { CloudSandboxAgentHostContribution } from "../../remoteAgentHost/browser/cloudSandboxAgentHostContribution.js";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { IPathService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService";
+import { ResolveSessionConfigResult } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/commands";
+import { CloudAutomationStore } from "./cloudAutomationStore.js";
+/** Copilot Cloud session type - cloud-hosted agent. */
+export declare const CopilotCloudSessionType: ISessionType;
+export declare const CopilotSandboxSessionType: ISessionType;
+export interface ICopilotChatSession {
+    /** Globally unique session ID (`providerId:localId`). */
+    readonly sessionId: string;
+    /** Resource URI identifying this session. */
+    readonly resource: URI;
+    /** ID of the provider that owns this session. */
+    readonly providerId: string;
+    /** Session type ID (e.g., 'copilot-cloud-agent', 'copilot-cloud-sandbox'). */
+    readonly sessionType: string;
+    readonly application: ISession["application"];
+    /** Icon for this session. */
+    readonly icon: ThemeIcon;
+    /** When the session was created. */
+    readonly createdAt: Date;
+    /** Workspace this session operates on. */
+    readonly workspace: IObservable<ISessionWorkspace | undefined>;
+    readonly isQuickChat?: IObservable<boolean>;
+    /** Session display title (changes when auto-titled or renamed). */
+    readonly title: IObservable<string>;
+    /** When the session was last updated. */
+    readonly updatedAt: IObservable<Date>;
+    /** Current session status. */
+    readonly status: IObservable<SessionStatus>;
+    /** Summary of file changes produced by the session. */
+    readonly changesSummary?: IObservable<ISessionChangesSummary | undefined>;
+    /** File changes produced by the session. */
+    readonly changes: IObservable<readonly ISessionFileChange[]>;
+    /** Currently selected model identifier. */
+    readonly modelId: IObservable<string | undefined>;
+    readonly modelSource: IObservable<ChatModelSource | undefined>;
+    /** Currently selected mode identifier and kind. */
+    readonly mode: IObservable<{
+        readonly id: string;
+        readonly kind: string;
+    } | undefined>;
+    /** Whether the session is still initializing. */
+    readonly loading: IObservable<boolean>;
+    readonly preparationProgress?: IObservable<ISessionPreparationProgress | undefined>;
+    readonly isNewSessionRequestInProgress?: IObservable<boolean>;
+    /** Whether the session is archived. */
+    readonly isArchived: IObservable<boolean>;
+    /** Whether the session has been read. */
+    readonly isRead: IObservable<boolean>;
+    /** Status description shown while the session is active (e.g., current agent action). */
+    readonly description: IObservable<IMarkdownString | undefined>;
+    /** Timestamp of when the last agent turn ended, if any. */
+    readonly lastTurnEnd: IObservable<Date | undefined>;
+    /** GitHub information associated with this session, if any. */
+    readonly gitHubInfo: IObservable<IGitHubInfo | undefined>;
+    readonly artifacts?: IObservable<readonly ISessionArtifact[]>;
+    /** Checkpoints associated with this session, if any. */
+    readonly checkpoints: IObservable<IChatCheckpoints | undefined>;
+    readonly createdBySession?: IObservable<ISessionCreationReference | undefined>;
+    /** Whether this session is still treated as external to VS Code. Absent means `false`. */
+    readonly isExternal?: IObservable<boolean>;
+    readonly initialAutomationSessionConfiguration?: IAutomationSessionConfiguration;
+    setModelId(modelId: string | undefined, source: ChatModelSource): void;
+    /**
+     * Settable observable holding the {@link IChat} representation of this chat.
+     * For committed chats, the value is stable.
+     */
+    readonly mainChat: ISettableObservable<IChat>;
+}
+/** Provider ID for the Copilot Chat Sessions provider. */
+export declare const COPILOT_PROVIDER_ID = "default-copilot";
+/**
+ * Remote new session for Cloud agent sessions.
+ * Implements {@link ICopilotChatSession} (session facade) and provides
+ * pre-send configuration methods for the new-session flow.
+ */
+export declare class RemoteNewSession extends Disposable implements ICopilotChatSession {
+    readonly resource: URI;
+    readonly sessionWorkspace: ISessionWorkspace | undefined;
+    readonly target: AgentSessionTarget;
+    readonly initialAutomationSessionConfiguration: IAutomationSessionConfiguration | undefined;
+    readonly isAutomationDraft: boolean;
+    private readonly chatSessionsService;
+    private readonly contextKeyService;
+    readonly application: IObservable<import("@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session").ISessionApplication>;
+    readonly lifetimeToken: CancellationToken;
+    readonly sessionId: string;
+    readonly providerId: string;
+    readonly sessionType: string;
+    readonly icon: ThemeIcon;
+    readonly createdAt: Date;
+    private readonly _title;
+    readonly title: IObservable<string>;
+    private readonly _updatedAt;
+    readonly updatedAt: IObservable<Date>;
+    private readonly _status;
+    readonly status: IObservable<SessionStatus>;
+    private readonly _workspaceData;
+    readonly workspace: IObservable<ISessionWorkspace | undefined>;
+    readonly isQuickChat: IObservable<boolean>;
+    readonly changes: IObservable<readonly ISessionFileChange[]>;
+    readonly checkpoints: IObservable<IChatCheckpoints | undefined>;
+    private readonly _modelIdObservable;
+    readonly modelId: IObservable<string | undefined>;
+    protected readonly _modelSourceObservable: ISettableObservable<ChatModelSource | undefined, void>;
+    readonly modelSource: IObservable<ChatModelSource | undefined>;
+    readonly mode: IObservable<{
+        readonly id: string;
+        readonly kind: string;
+    } | undefined>;
+    readonly loading: IObservable<boolean>;
+    readonly preparationProgress: ISettableObservable<ISessionPreparationProgress | undefined, void>;
+    readonly isNewSessionRequestInProgress: IObservable<boolean>;
+    private readonly _preparationCts;
+    private _preparationActivities;
+    private readonly _isArchived;
+    readonly isArchived: IObservable<boolean>;
+    readonly isRead: IObservable<boolean>;
+    readonly description: IObservable<IMarkdownString | undefined>;
+    readonly lastTurnEnd: IObservable<Date | undefined>;
+    readonly gitHubInfo: IObservable<IGitHubInfo | undefined>;
+    readonly mainChat: ISettableObservable<IChat>;
+    private _repoUri;
+    private _project;
+    private _modelId;
+    private _query;
+    private _attachedContext;
+    private readonly _onDidChangeOptionGroups;
+    readonly onDidChangeOptionGroups: Event<void>;
+    readonly selectedOptions: Map<string, IChatSessionProviderOptionItem>;
+    readonly createdBySession: ISettableObservable<ISessionCreationReference | undefined, void>;
+    get project(): ISessionWorkspace | undefined;
+    get selectedModelId(): string | undefined;
+    /**
+     * The repository this session targets, as `owner/repo`. A GitHub workspace root carries a ref
+     * (`/<owner>/<repo>/HEAD`, see {@link CopilotChatSessionsProvider._browseForRepository}), so this
+     * takes only the first two path segments rather than the whole path.
+     */
+    get repoNwo(): string | undefined;
+    get query(): string | undefined;
+    get attachedContext(): IChatRequestVariableEntry[] | undefined;
+    setCreatedBySession(reference: ISessionCreationReference | undefined): void;
+    get disabled(): boolean;
+    private readonly _whenClauseKeys;
+    readonly modelConfiguration: AutomationModelConfiguration;
+    constructor(resource: URI, sessionWorkspace: ISessionWorkspace | undefined, target: AgentSessionTarget, providerId: string, initialAutomationSessionConfiguration: IAutomationSessionConfiguration | undefined, isAutomationDraft: boolean, chatSessionsService: IChatSessionsService, contextKeyService: IContextKeyService, languageModelsService: ILanguageModelsService);
+    setModelId(modelId: string | undefined, source: ChatModelSource): void;
+    setTitle(title: string): void;
+    setStatus(status: SessionStatus): void;
+    startPreparation(): IReference<CancellationToken>;
+    reportPreparationProgress(message: string): void;
+    private clearPreparation;
+    setArchived(archived: boolean): void;
+    setOption(optionId: string, value: IChatSessionProviderOptionItem | string): void;
+    getModelOptionsSnapshot(): {
+        readonly modelOption: ISessionOptionGroup | undefined;
+        readonly isResolved: boolean;
+    };
+    getOtherOptionGroups(): ISessionOptionGroup[];
+    getOptionValue(groupId: string): IChatSessionProviderOptionItem | undefined;
+    setOptionValue(groupId: string, value: IChatSessionProviderOptionItem): void;
+    private _getOptionGroups;
+    private _isOptionGroupVisible;
+    private _updateWhenClauseKeys;
+    private _getValueForGroup;
+    update(_session: IAgentSession): void;
+}
+/**
+ * Default sessions provider for Copilot Cloud sessions.
+ * Wraps the existing session infrastructure into the extensible provider model.
+ */
+export declare class CopilotChatSessionsProvider extends Disposable implements ISessionsProvider {
+    private readonly providerMode;
+    private readonly agentSessionsService;
+    private readonly chatService;
+    private readonly chatSessionsService;
+    private readonly commandService;
+    private readonly instantiationService;
+    private readonly languageModelsService;
+    private readonly configurationService;
+    private readonly logService;
+    private readonly notificationService;
+    private readonly gitHubService;
+    private readonly pullRequestIconCache;
+    private readonly labelService;
+    private readonly uriIdentityService;
+    private readonly fileService;
+    private readonly pathService;
+    private readonly storageService;
+    readonly environment: {
+        id: string;
+        label: string;
+    };
+    /**
+     * How long the first sandbox turn waits for the session's model catalog to arrive before
+     * dispatching without the user's model. Long enough to cover the gap between the relay
+     * connecting and the host publishing its models, short enough not to strand a send behind a
+     * catalog that is never coming. Exceeding it is reported to the user, not only logged.
+     */
+    private static readonly SANDBOX_MODEL_WAIT_MS;
+    get id(): string;
+    get label(): string;
+    readonly icon: ThemeIcon;
+    readonly order = 0;
+    get sessionTypes(): readonly ISessionType[];
+    private readonly _onDidChangeSessionTypes;
+    readonly onDidChangeSessionTypes: Event<void>;
+    private readonly _onDidChangeCapabilities;
+    readonly onDidChangeCapabilities: Event<void>;
+    private readonly _onDidChangeSessions;
+    readonly onDidChangeSessions: Event<ISessionChangeEvent>;
+    private readonly _onDidReplaceSession;
+    readonly onDidReplaceSession: Event<{
+        readonly from: ISession;
+        readonly to: ISession;
+    }>;
+    /** Cache of adapted sessions, keyed by resource URI string. */
+    private readonly _sessionCache;
+    /**
+     * Resources of committed sessions that are currently in-flight (i.e.
+     * between {@link _sendFirstChat} entering the send and the replace
+     * event firing). Protected from spurious removal by
+     * {@link _refreshSessionCache} so that a concurrent model re-resolve
+     * cannot transiently drop them.
+     */
+    private readonly _inFlightCommits;
+    private readonly _sandboxSends;
+    private readonly _repositoryPicker;
+    private readonly _sandboxCatalog;
+    private readonly _onDidChangeSandboxModels;
+    private readonly _sandboxConfigs;
+    private readonly _onDidChangeSessionConfig;
+    readonly onDidChangeSessionConfig: Event<string>;
+    readonly sessionConfig: ISessionConfigProvider;
+    /** Cache of ISession wrappers, keyed by session ID. */
+    private readonly _sessionWrapperCache;
+    private readonly _localGitRepositoryState;
+    private readonly _localGitRepositoryResolutionStarted;
+    get supportsLocalWorkspaces(): boolean;
+    readonly automations: CloudAutomationStore | undefined;
+    get supportsAutomationSessionConfiguration(): boolean;
+    get supportsQuickChats(): boolean;
+    constructor(providerMode: "default" | "sandbox", agentSessionsService: IAgentSessionsService, chatService: IChatService, chatSessionsService: IChatSessionsService, commandService: ICommandService, instantiationService: IInstantiationService, languageModelsService: ILanguageModelsService, configurationService: IConfigurationService, logService: ILogService, notificationService: INotificationService, gitHubService: IGitHubService, pullRequestIconCache: IPullRequestIconCache, labelService: ILabelService, uriIdentityService: IUriIdentityService, fileService: IFileService, pathService: IPathService, storageService: IStorageService);
+    get browseActions(): readonly ISessionWorkspaceBrowseAction[];
+    getSessionTypes(workspaceUri: URI): ISessionType[];
+    getSessions(): ISession[];
+    private readonly _newSessions;
+    private readonly _createdBySessions;
+    private readonly _storedCreatedBySessions;
+    private _createdBySession;
+    private _setCreatedBySession;
+    private _deleteCreatedBySession;
+    private _loadCreatedBySessions;
+    private _saveCreatedBySessions;
+    /**
+     * Clear the tracked new session with the given session's id, but only if
+     * the map still holds exactly that instance. Async flows (commit wait,
+     * cache population) may complete after the entry was already replaced or
+     * removed — acting unconditionally would dispose an unrelated session.
+     *
+     * @param session The session that initiated the async flow.
+     * @param leak When `true` use {@link DisposableMap.deleteAndLeak}
+     *             (the session is still referenced elsewhere, e.g. the session
+     *             cache); otherwise use {@link DisposableMap.deleteAndDispose}.
+     */
+    private _clearCurrentNewSessionIfMatch;
+    deleteNewSession(sessionId: string): void;
+    getSession(sessionId: string): ICopilotChatSession | undefined;
+    createNewSession(workspaceUri: URI, sessionTypeId: string, options?: ISessionsProviderCreateSessionOptions): ISession;
+    private _createDraftSession;
+    private _getCloudWorkspaceForLocalRepository;
+    getAutomationModelConfiguration(sessionId: string): AutomationModelConfiguration | undefined;
+    getAutomationSessionConfiguration(sessionId: string): Promise<IAutomationSessionConfiguration | undefined>;
+    createQuickChat(sessionTypeId: string, options?: ISessionsProviderCreateSessionOptions): ISession;
+    private _applyAutomationSessionConfiguration;
+    get onDidChangeModels(): Event<void>;
+    getModelsSnapshot(sessionId: string, desiredModelId?: string): ISessionModelsSnapshot;
+    getModelsSnapshotForCreation(_workspaceUri: URI, sessionTypeId: string, desiredModelId?: string): ISessionModelsSnapshot;
+    getModelPickerOptions(sessionId: string): ISessionModelPickerOptions;
+    private _usesSandbox;
+    private _getSandboxCatalog;
+    private _sandboxModelsSnapshot;
+    getSessionConfig(sessionId: string): ResolveSessionConfigResult | undefined;
+    getCreateSessionConfig(sessionId: string): Record<string, unknown> | undefined;
+    isSessionConfigResolving(_sessionId: string): IObservable<boolean>;
+    setSessionConfigValue(sessionId: string, property: string, value: unknown): Promise<void>;
+    private _toSyntheticModel;
+    setModel(sessionId: string, chatResource: URI, modelId: string, source: ChatModelSource): void;
+    getNewSessionConfig(sessionId: string): Promise<ISessionConfigurationSnapshot | undefined>;
+    archiveSession(sessionId: string): Promise<void>;
+    unarchiveSession(sessionId: string): Promise<void>;
+    setSessionReadState(sessionId: string, isRead: boolean): Promise<void>;
+    deleteSession(sessionId: string): Promise<void>;
+    deleteSessions(sessionIds: readonly string[]): Promise<void>;
+    renameChat(_sessionId: string, _chatUri: URI, _title: string): Promise<void>;
+    renameSession(_sessionId: string, _title: string): Promise<void>;
+    deleteChat(_sessionId: string, _chatUri: URI, _options?: IDeleteChatOptions): Promise<boolean>;
+    forkChat(sessionId: string, _sourceChat: URI, _turnId: string): Promise<IChat>;
+    createSideChat(sessionId: string, _sourceChat: URI, _turnId: string, _selection?: ISideChatSelection): Promise<IChat>;
+    startNewSessionRequest(sessionId: string): IDisposable | undefined;
+    createNewChat(sessionId: string, _prompt?: string): Promise<IChat>;
+    /** Test seam: the contribution registry is global, so tests override this with a stub. */
+    protected _getCloudSandboxContribution(): Pick<CloudSandboxAgentHostContribution, "provisionSession" | "prepareSession" | "trackSessionCreationProgress">;
+    /** Test seam: overridden so a test can reach the timeout without waiting out the real budget. */
+    protected get _sandboxModelWaitMs(): number;
+    /**
+     * Commit a cloud new-session into a GitHub-managed sandbox instead of the server-run cloud
+     * agent: provision the sandbox, then hand the session over to the remote-agent-host provider
+     * that owns it and send the first turn there.
+     *
+     * The committed session belongs to that other provider, which is why this fires
+     * `onDidReplaceSession` across providers — the same swap {@link _sendFirstChat} performs, just
+     * landing outside this provider. Mission Control starts no run for the task it creates, so the
+     * first turn has to be dispatched here rather than being picked up server-side.
+     */
+    private _sendFirstChatToSandbox;
+    /** Reveal the sandbox session that {@link CloudSandboxAgentHostContribution.provisionSession} withheld from listings. */
+    private _publishSandboxSession;
+    /** Carries the raw model ID and its preferences across the draft and connected host's identifier spaces. */
+    private _selectedCloudModel;
+    /**
+     * Apply the model the user picked in the composer to the sandbox session before its first turn.
+     *
+     * Mission Control starts no run, so this client sends that turn — and a session that has never
+     * run has no model of its own to restore. Without this the turn carries no model at all and
+     * runs on whatever the agent host defaults to.
+     *
+     * A freshly connected sandbox publishes its models asynchronously, so an empty catalog is "not
+     * yet" rather than "no": resolution is awaited while it reports `pending`, bounded because the
+     * turn cannot be held indefinitely.
+     *
+     * Every path that gives up tells the user: an absent `Message.model` means "host decides", so
+     * nothing downstream would report running at a capability and price they did not choose.
+     */
+    private _carryModelToSandbox;
+    /** Name the model so the substitution is attributable. A warning: the turn still runs. */
+    private _notifySandboxModelNotApplied;
+    /** Retire the optimistic placeholder in favour of the session that now exists. */
+    private _retirePlaceholder;
+    sendRequest(sessionId: string, chatResource: URI, options: ISendRequestOptions): Promise<ISession>;
+    private _sendFirstChat;
+    private _createChatSession;
+    private _updateChatSessionState;
+    /**
+     * Waits for the committed (real) URI for a session by listening to the
+     * {@link IChatSessionsService.onDidCommitSession} event.
+     *
+     * Cloud sessions defer their commit behind a confirmation round-trip and
+     * network delegation. Response completion fires early (at the confirmation)
+     * and is not a signal that the commit won't come, so the wait is bounded by
+     * a generous timeout and by the response being cancelled instead.
+     */
+    private _waitForCommittedSession;
+    /**
+     * Waits for an {@link AgentSessionAdapter} with the given resource to appear
+     * in the session cache (populated by {@link _refreshSessionCache}).
+     * Only called once during session initialisation (after the commit event),
+     * so the timeout has no performance impact on steady-state operations.
+     */
+    private _waitForSessionInCache;
+    private _pickRepository;
+    private _browseForRepository;
+    private _supportsLocalRepositoryActions;
+    private _cloneRepository;
+    private _browseForGitHubContext;
+    resolveWorkspace(uri: URI): ISessionWorkspace | undefined;
+    private _getLocalGitRepository;
+    private _getLocalGitRepositoryState;
+    private _resolveLocalGitRepository;
+    private _labelFromUri;
+    private _descriptionFromUri;
+    private _iconFromUri;
+    private _ensureSessionCache;
+    /**
+     * Cleans up a temp session (one that hasn't been committed) from the cache.
+     * Used when delete/archive is invoked on a session that is still pending
+     * commit (e.g. was stopped before the cloud agent picked it up).
+     */
+    private _cleanupTempSession;
+    private _refreshSessionCache;
+    private _findChatSession;
+    private _findAgentSession;
+    private _localIdFromSessionId;
+    /**
+     * Wraps an {@link ICopilotChatSession} into an {@link ISession} with a single chat.
+     * Wrappers are cached per session so repeated lookups return the same instance.
+     */
+    private _chatToSession;
+    private _withChangesets;
+}