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

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

@@ -0,0 +1,3121 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { raceTimeout, raceCancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { CancellationError, isCancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { markdownStringEqual, MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { Disposable, MutableDisposable, DisposableMap, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { isWeb } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+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 { IDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { AgentSession } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agent';
+import { getAgentSessionPullRequestUri } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsModel';
+import { getRepositoryName } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsViewer';
+import { IAgentSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsService.service';
+import { AgentSessionProviders } 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 { ChatSessionStatus, SessionType } 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 { assertAutomationSessionTemplate } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automation';
+import { AutomationModelConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/automations/browser/automationModelConfiguration';
+import { SessionTypeAuthRequirement, ChatInteractivity, SessionStatus, toSessionId, sessionFileChangesEqual, GITHUB_REMOTE_FILE_SCHEME, sessionWorkspaceEqual, gitHubInfoEqual, SESSION_WORKSPACE_GROUP_GITHUB, SESSION_WORKSPACE_GROUP_LOCAL, ChatModelSource } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
+import { ChatPermissionLevel, isChatPermissionLevel, ChatConfiguration, ChatModeKind, ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { basename, isEqual, dirname } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { UNIFIED_WORKSPACE_PICKER_SETTING } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/chat/common/constants';
+import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service';
+import { ChatMode, isBuiltinChatMode } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes';
+import { IChatModeService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes.service';
+import { CancellationTokenSource, CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { ILanguageModelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service';
+import { resolveModelIdentifier, getRegisteredLanguageModels, resolveModelIdentifierFromLanguageModels } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/modelSelection';
+import { IGitService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/git/common/gitService.service';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { ExtensionIdentifier } from '@codingame/monaco-vscode-api/vscode/vs/platform/extensions/common/extensions';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+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 { SessionConfigKey } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/sessionConfigKeys';
+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 { IGitHubService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/github/browser/githubService.service';
+import { GitHubPullRequestState } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/github/common/types';
+import { computePullRequestRefPresentation } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/github/browser/pullRequestIconStatus';
+import { IPullRequestIconCache } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/github/browser/pullRequestIconCache.service';
+import { structuralEquals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/equals';
+import { CopilotCLISessionType } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/providers/agentHost/browser/baseAgentHostSessionsProvider';
+import { createChangesets } from './copilotChatSessionsChangesets.js';
+import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
+import { IAgentHostEnablementService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostEnablementService.service';
+import { isCloudSandboxEnabled } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/cloudSandboxAgentHost';
+import { getWorkbenchContribution } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { CloudSandboxAgentHostContribution } from '../../remoteAgentHost/browser/cloudSandboxAgentHostContribution.js';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { resolveGitRepositoryFromGitConfig } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/gitHubRepositoryResolver';
+import { IPathService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService.service';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { constObservable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/constObservable';
+import { observableValueOpts } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValueOpts';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { derived, derivedOpts } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+import { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/transaction';
+import { computePullRequestIcon } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/chatPullRequest';
+import { observableFromPromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/utils';
+import { runOnChange } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/runOnChange';
+import { observableSignal } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignal';
+
+var CopilotCLISession_1, CopilotChatSessionsProvider_1;
+const CopilotCloudSessionType = {
+    id: "copilot-cloud-agent",
+    label: ( localize(4214, "Cloud")),
+    icon: Codicon.cloud,
+    authRequirement: SessionTypeAuthRequirement.GitHub
+};
+const STORAGE_KEY_ISOLATION_MODE = "sessions.isolationPicker.selectedMode";
+const STORAGE_KEY_USE_SANDBOX = "sessions.cloudSandboxPicker.useSandbox";
+function getGitHubRepositoryId(repository) {
+    const match = /^(?:(?:https?|ssh|git):\/\/(?:git@)?github\.com\/|git@github\.com:)?(?<owner>[^/:\s]+)\/(?<repo>[^/\s]+?)(?:\.git)?\/?$/i.exec(repository);
+    return match?.groups ? `${match.groups.owner}/${match.groups.repo}` : undefined;
+}
+const OPEN_REPO_COMMAND = "github.copilot.chat.cloudSessions.openRepository";
+const OPEN_ISSUE_COMMAND = "github.copilot.chat.cloudSessions.openIssue";
+const OPEN_PULL_REQUEST_COMMAND = "github.copilot.chat.cloudSessions.openPullRequest";
+const COPILOT_PROVIDER_ID = "default-copilot";
+const COPILOT_MULTI_CHAT_SETTING = "sessions.github.copilot.multiChatSessions";
+const REPOSITORY_OPTION_ID = "repository";
+const PARENT_SESSION_OPTION_ID = "parentSessionId";
+const BRANCH_OPTION_ID = "branch";
+const ISOLATION_OPTION_ID = "isolation";
+const AGENT_OPTION_ID = "agent";
+function isNewSession(session) {
+    return session instanceof CopilotCLISession || session instanceof RemoteNewSession;
+}
+function isChangesSummary(changes) {
+    return !!changes && !Array.isArray(changes);
+}
+function buildChatFromSession(chat) {
+    return {
+        resource: chat.resource,
+        createdAt: chat.createdAt,
+        title: chat.title,
+        updatedAt: chat.updatedAt,
+        status: chat.status,
+        changes: chat.changes,
+        checkpoints: chat.checkpoints,
+        modelId: chat.modelId,
+        modelSource: chat.modelSource,
+        mode: chat.mode,
+        isArchived: chat.isArchived,
+        isRead: chat.isRead,
+        interactivity: constObservable(ChatInteractivity.Full),
+        description: chat.description,
+        lastTurnEnd: chat.lastTurnEnd
+    };
+}
+function setIfChanged(observable, value, tx, equals = Object.is) {
+    if (equals(observable.get(), value)) {
+        return false;
+    }
+    observable.set(value, tx, undefined);
+    return true;
+}
+function dateEquals(a, b) {
+    return a?.getTime() === b?.getTime();
+}
+function markdownStringEquals(a, b) {
+    return a === b || !!a && !!b && markdownStringEqual(a, b);
+}
+let CopilotCLISession = class CopilotCLISession extends Disposable {
+    static {
+        CopilotCLISession_1 = this;
+    }
+    static {
+        this.COPILOT_WORKTREE_PATTERN = "copilot-worktree-";
+    }
+    get selectedModelId() {
+        return this._modelId;
+    }
+    get chatMode() {
+        return this._mode;
+    }
+    get query() {
+        return this._query;
+    }
+    get attachedContext() {
+        return this._attachedContext;
+    }
+    get cancellationToken() {
+        return this._lifetimeCts.token;
+    }
+    get gitRepository() {
+        return this._gitRepository;
+    }
+    get disabled() {
+        if (!this._repoUri) {
+            return true;
+        }
+        if (this._isolationMode === "worktree" && !this._branch) {
+            return true;
+        }
+        return false;
+    }
+    constructor(
+        resource,
+        sessionWorkspace,
+        providerId,
+        initialAutomationSessionConfiguration,
+        chatSessionsService,
+        gitService,
+        gitHubService,
+        pullRequestIconCache,
+        storageService,
+        configurationService,
+        languageModelsService
+    ) {
+        super();
+        this.resource = resource;
+        this.sessionWorkspace = sessionWorkspace;
+        this.initialAutomationSessionConfiguration = initialAutomationSessionConfiguration;
+        this.chatSessionsService = chatSessionsService;
+        this.gitService = gitService;
+        this.gitHubService = gitHubService;
+        this.pullRequestIconCache = pullRequestIconCache;
+        this.storageService = storageService;
+        this.configurationService = configurationService;
+        this._title = observableValue(this, "");
+        this.title = this._title;
+        this._updatedAt = observableValue(this, ( new Date()));
+        this.updatedAt = this._updatedAt;
+        this._status = observableValue(this, SessionStatus.Untitled);
+        this.status = this._status;
+        this._permissionLevel = observableValue(this, ChatPermissionLevel.Default);
+        this.permissionLevel = this._permissionLevel;
+        this._workspaceData = observableValue(this, undefined);
+        this.workspace = this._workspaceData;
+        this._branchObservable = observableValue(this, undefined);
+        this.branch = this._branchObservable;
+        this._isolationModeObservable = observableValue(this, "worktree");
+        this.isolationMode = this._isolationModeObservable;
+        this.useSandbox = constObservable(undefined);
+        this._modelIdObservable = observableValue(this, undefined);
+        this.modelId = this._modelIdObservable;
+        this._modelSourceObservable = observableValue(this, undefined);
+        this.modelSource = this._modelSourceObservable;
+        this._modeObservable = observableValue(this, undefined);
+        this.mode = this._modeObservable;
+        this._loading = observableValue(this, true);
+        this.loading = this._loading;
+        this._hasGitRepository = observableValue(this, false);
+        this.hasGitRepository = this._hasGitRepository;
+        this._isArchived = observableValue(this, false);
+        this.isArchived = this._isArchived;
+        this.isRead = observableValue(this, true);
+        this.lastTurnEnd = observableValue(this, undefined);
+        this.gitHubInfo = observableValue(this, undefined);
+        this._loadBranchesCts = this._register(( new MutableDisposable()));
+        this._branches = observableValue(this, []);
+        this.branches = this._branches;
+        this._lifetimeCts = this._register(( new CancellationTokenSource()));
+        this.target = AgentSessionProviders.Background;
+        this.selectedOptions = ( new Map());
+        this.modelConfiguration = this._register(( new AutomationModelConfiguration(
+            languageModelsService,
+            initialAutomationSessionConfiguration?.sessionTemplate
+        )));
+        this.sessionId = toSessionId(providerId, resource);
+        this.providerId = providerId;
+        this.sessionType = AgentSessionProviders.Background;
+        this.icon = CopilotCLISessionType.icon;
+        this.createdAt = ( new Date());
+        const repoUri = sessionWorkspace.folders[0]?.root;
+        if (repoUri) {
+            this._repoUri = repoUri;
+            this.setOption(REPOSITORY_OPTION_ID, repoUri.fsPath);
+        }
+        this._workspaceData.set(sessionWorkspace, undefined);
+        const storedMode = storageService.get(STORAGE_KEY_ISOLATION_MODE, StorageScope.PROFILE);
+        const initialMode = storedMode === "workspace" ? "workspace" : "worktree";
+        this._isolationMode = initialMode;
+        this._isolationModeObservable.set(initialMode, undefined);
+        this.setOption(ISOLATION_OPTION_ID, initialMode);
+        this._resolveGitRepository();
+        this._description = observableValue(this, undefined);
+        this.description = this._description;
+        this._changes = observableValueOpts({
+            owner: this,
+            equalsFn: sessionFileChangesEqual
+        }, []);
+        this.changes = this._changes;
+        this._checkpoints = observableValueOpts({
+            owner: this,
+            equalsFn: structuralEquals
+        }, undefined);
+        this.checkpoints = this._checkpoints;
+        this.mainChat = observableValue(this, buildChatFromSession(this));
+    }
+    async _resolveGitRepository() {
+        const repoUri = this.sessionWorkspace.folders[0]?.root;
+        if (repoUri) {
+            try {
+                this._gitRepository = await this.gitService.openRepository(repoUri);
+                if (!this._gitRepository) {
+                    this.setIsolationMode("workspace");
+                } else if (!this._gitRepository.state.get().HEAD?.commit) {
+                    this.setIsolationMode("workspace");
+                }
+            } catch {
+                this.setIsolationMode("workspace");
+            }
+        }
+        const gitRepository = this._gitRepository;
+        if (gitRepository) {
+            this._register(autorun(reader => {
+                this._hasGitRepository.set(!!gitRepository.state.read(reader).HEAD?.commit, undefined);
+            }));
+            this._loadBranches(gitRepository);
+            const currentBranchName = derived(reader => {
+                const state = gitRepository.state.read(reader);
+                return state?.HEAD?.commit ? state.HEAD.name : undefined;
+            });
+            this._register(autorun(reader => {
+                const isolationMode = this.isolationMode.read(reader);
+                if (isolationMode === "worktree") {
+                    return;
+                }
+                const currentBranch = currentBranchName.read(reader);
+                this.setBranch(currentBranch ?? this._defaultBranch);
+            }));
+        }
+        this._loading.set(false, undefined);
+    }
+    _loadBranches(repo) {
+        this._loadBranchesCts.value?.cancel();
+        const cts = this._loadBranchesCts.value = ( new CancellationTokenSource());
+        repo.getRefs({
+            pattern: "refs/heads"
+        }, cts.token).then(refs => {
+            if (cts.token.isCancellationRequested) {
+                return;
+            }
+            const hasHeadCommit = !!repo.state.get().HEAD?.commit;
+            const branches = refs.map(r => r.name).filter(name => !!name).filter(name => !name.includes(CopilotCLISession_1.COPILOT_WORKTREE_PATTERN));
+            const defaultBranch = hasHeadCommit ? (branches.find(b => b === "main") ?? branches.find(b => b === "master") ?? branches.find(b => b === repo.state.get().HEAD?.name) ?? branches[0]) : undefined;
+            this._defaultBranch = defaultBranch;
+            transaction(tx => {
+                this._branches.set(branches, tx);
+            });
+            if (defaultBranch && !this._branch) {
+                this.setBranch(defaultBranch);
+            }
+        }).catch(() => {
+            if (!cts.token.isCancellationRequested) {
+                transaction(tx => {
+                    this._branches.set([], tx);
+                });
+            }
+        });
+    }
+    setIsolationMode(mode) {
+        if (this._isolationMode !== mode) {
+            this._isolationMode = mode;
+            this._isolationModeObservable.set(mode, undefined);
+            this.setOption(ISOLATION_OPTION_ID, mode);
+            this.storageService.store(
+                STORAGE_KEY_ISOLATION_MODE,
+                mode,
+                StorageScope.PROFILE,
+                StorageTarget.MACHINE
+            );
+            if (mode === "workspace") {
+                const head = this._gitRepository?.state.get().HEAD;
+                const currentBranch = head?.commit ? head.name : undefined;
+                this.setBranch(currentBranch ?? this._defaultBranch);
+            } else {
+                this.setBranch(this._defaultBranch);
+            }
+        }
+    }
+    setBranch(branch) {
+        if (this._branch !== branch) {
+            this._branch = branch;
+            this._branchObservable.set(branch, undefined);
+            this.setOption(BRANCH_OPTION_ID, branch ?? "");
+        }
+    }
+    setUseSandbox(_useSandbox) {}
+    setModelId(modelId, source) {
+        this._modelId = modelId;
+        transaction(tx => {
+            this._modelSourceObservable.set(modelId ? source : undefined, tx);
+            this._modelIdObservable.set(modelId, tx);
+        });
+    }
+    setModeById(modeId, modeKind) {
+        this._mode = undefined;
+        this._modeObservable.set({
+            id: modeId,
+            kind: modeKind
+        }, undefined);
+    }
+    setPermissionLevel(level) {
+        this._permissionLevel.set(level, undefined);
+    }
+    setTitle(title) {
+        this._title.set(title, undefined);
+    }
+    setStatus(status) {
+        this._status.set(status, undefined);
+    }
+    setArchived(archived) {
+        this._isArchived.set(archived, undefined);
+    }
+    setMode(mode) {
+        if (this._mode !== mode || this._modeObservable.get()?.id !== mode?.id) {
+            this._mode = mode;
+            this._modeObservable.set(mode ? {
+                id: mode.id,
+                kind: mode.kind
+            } : undefined, undefined);
+            const modeName = mode?.isBuiltin ? undefined : mode?.name.get();
+            this.setOption(AGENT_OPTION_ID, modeName ?? "");
+        }
+    }
+    getAgentHostSessionConfig() {
+        const config = {
+            [SessionConfigKey.Isolation]: this._isolationMode === "worktree" ? "worktree" : "folder"
+        };
+        if (this._isolationMode === "worktree" && this._branch) {
+            config[SessionConfigKey.Branch] = this._branch;
+            const branchPrefix = this.configurationService.getValue("git.branchPrefix", {
+                resource: this._repoUri
+            });
+            if (typeof branchPrefix === "string" && branchPrefix.length > 0) {
+                config[SessionConfigKey.WorktreeBranchPrefix] = branchPrefix;
+            }
+            const worktreeIncludeFiles = this.configurationService.getValue("git.worktreeIncludeFiles", {
+                resource: this._repoUri
+            });
+            if (Array.isArray(worktreeIncludeFiles) && worktreeIncludeFiles.length > 0) {
+                config[SessionConfigKey.WorktreeIncludeFiles] = worktreeIncludeFiles;
+            }
+        }
+        return config;
+    }
+    setOption(optionId, value) {
+        if (typeof value === "string") {
+            this.selectedOptions.set(optionId, {
+                id: value,
+                name: value
+            });
+        } else {
+            this.selectedOptions.set(optionId, value);
+        }
+        this.chatSessionsService.setSessionOption(this.resource, optionId, value);
+    }
+    update(agentSession) {
+        transaction(tx => {
+            const session = ( new AgentSessionAdapter(
+                agentSession,
+                this.providerId,
+                this.gitHubService,
+                this.pullRequestIconCache
+            ));
+            this._workspaceData.set(session.workspace.get(), tx);
+            this._title.set(session.title.get(), tx);
+            this._status.set(session.status.get(), tx);
+            this._updatedAt.set(session.updatedAt.get(), tx);
+            this._changes.set(session.changes.get(), tx);
+            this._checkpoints.set(session.checkpoints.get(), tx);
+            this._description.set(session.description.get(), tx);
+        });
+    }
+    dispose() {
+        this._lifetimeCts.cancel();
+        super.dispose();
+    }
+};
+CopilotCLISession = CopilotCLISession_1 = ( __decorate([( __param(4, IChatSessionsService)), ( __param(5, IGitService)), ( __param(6, IGitHubService)), ( __param(7, IPullRequestIconCache)), ( __param(8, IStorageService)), ( __param(9, IConfigurationService)), ( __param(10, ILanguageModelsService))], CopilotCLISession));
+function isModelOptionGroup(group) {
+    if (group.id === "models") {
+        return true;
+    }
+    const nameLower = group.name.toLowerCase();
+    return nameLower === "model" || nameLower === "models";
+}
+function isRepositoriesOptionGroup(group) {
+    return group.id === "repositories";
+}
+let RemoteNewSession = class RemoteNewSession extends Disposable {
+    get project() {
+        return this._project;
+    }
+    get selectedModelId() {
+        return this._modelId;
+    }
+    get repoNwo() {
+        return this._repoUri ? githubRemoteRepoLabel(this._repoUri) : undefined;
+    }
+    get chatMode() {
+        return undefined;
+    }
+    get query() {
+        return this._query;
+    }
+    get attachedContext() {
+        return this._attachedContext;
+    }
+    get disabled() {
+        return !this._repoUri && !( this.selectedOptions.has("repositories"));
+    }
+    constructor(
+        resource,
+        sessionWorkspace,
+        target,
+        providerId,
+        initialAutomationSessionConfiguration,
+        chatSessionsService,
+        contextKeyService,
+        storageService,
+        languageModelsService
+    ) {
+        super();
+        this.resource = resource;
+        this.sessionWorkspace = sessionWorkspace;
+        this.target = target;
+        this.initialAutomationSessionConfiguration = initialAutomationSessionConfiguration;
+        this.chatSessionsService = chatSessionsService;
+        this.contextKeyService = contextKeyService;
+        this.storageService = storageService;
+        this._title = observableValue(this, "");
+        this.title = this._title;
+        this._updatedAt = observableValue(this, ( new Date()));
+        this.updatedAt = this._updatedAt;
+        this._status = observableValue(this, SessionStatus.Untitled);
+        this.status = this._status;
+        this._permissionLevel = observableValue(this, ChatPermissionLevel.Default);
+        this.permissionLevel = this._permissionLevel;
+        this._workspaceData = observableValue(this, undefined);
+        this.workspace = this._workspaceData;
+        this.changes = observableValueOpts({
+            owner: this,
+            equalsFn: sessionFileChangesEqual
+        }, []);
+        this.checkpoints = constObservable(undefined);
+        this._modelIdObservable = observableValue(this, undefined);
+        this.modelId = this._modelIdObservable;
+        this._modelSourceObservable = observableValue(this, undefined);
+        this.modelSource = this._modelSourceObservable;
+        this.mode = observableValue(this, undefined);
+        this.loading = observableValue(this, false);
+        this._isArchived = observableValue(this, false);
+        this.isArchived = this._isArchived;
+        this.isRead = observableValue(this, true);
+        this.description = constObservable(undefined);
+        this.lastTurnEnd = constObservable(undefined);
+        this.gitHubInfo = constObservable(undefined);
+        this.branch = constObservable(undefined);
+        this.isolationMode = constObservable(undefined);
+        this._useSandbox = observableValue(this, false);
+        this.useSandbox = this._useSandbox;
+        this.branches = constObservable([]);
+        this._hasGitRepo = observableValue(this, false);
+        this.hasGitRepo = this._hasGitRepo;
+        this._onDidChangeOptionGroups = this._register(( new Emitter()));
+        this.onDidChangeOptionGroups = this._onDidChangeOptionGroups.event;
+        this.selectedOptions = ( new Map());
+        this._whenClauseKeys = ( new Set());
+        this.modelConfiguration = this._register(( new AutomationModelConfiguration(
+            languageModelsService,
+            initialAutomationSessionConfiguration?.sessionTemplate
+        )));
+        this.sessionId = toSessionId(providerId, resource);
+        this.providerId = providerId;
+        this.sessionType = target;
+        this.icon = CopilotCloudSessionType.icon;
+        this.createdAt = ( new Date());
+        this._useSandbox.set(
+            storageService.getBoolean(STORAGE_KEY_USE_SANDBOX, StorageScope.PROFILE, false),
+            undefined
+        );
+        this._updateWhenClauseKeys();
+        this._register(this.chatSessionsService.onDidChangeOptionGroups(() => {
+            this._updateWhenClauseKeys();
+            this._onDidChangeOptionGroups.fire();
+        }));
+        this._register(this.contextKeyService.onDidChangeContext(e => {
+            if (this._whenClauseKeys.size > 0 && e.affectsSome(this._whenClauseKeys)) {
+                this._onDidChangeOptionGroups.fire();
+            }
+        }));
+        this._workspaceData.set(sessionWorkspace, undefined);
+        this._repoUri = sessionWorkspace.folders[0]?.root;
+        if (this._repoUri) {
+            const id = this._repoUri.path.substring(1);
+            this.setOption("repositories", {
+                id,
+                name: id
+            });
+        }
+        this.mainChat = observableValue(this, buildChatFromSession(this));
+    }
+    setPermissionLevel(level) {
+        throw ( new Error("Method not implemented."));
+    }
+    setIsolationMode(_mode) {}
+    setUseSandbox(useSandbox) {
+        if (this._useSandbox.get() === useSandbox) {
+            return;
+        }
+        this._useSandbox.set(useSandbox, undefined);
+        this.storageService.store(
+            STORAGE_KEY_USE_SANDBOX,
+            useSandbox,
+            StorageScope.PROFILE,
+            StorageTarget.MACHINE
+        );
+    }
+    setBranch(_branch) {}
+    setModelId(modelId, source) {
+        this._modelId = modelId;
+        transaction(tx => {
+            this._modelSourceObservable.set(modelId ? source : undefined, tx);
+            this._modelIdObservable.set(modelId, tx);
+        });
+    }
+    setTitle(title) {
+        this._title.set(title, undefined);
+    }
+    setStatus(status) {
+        this._status.set(status, undefined);
+    }
+    setArchived(archived) {
+        this._isArchived.set(archived, undefined);
+    }
+    setMode(_mode) {}
+    setOption(optionId, value) {
+        if (typeof value !== "string") {
+            this.selectedOptions.set(optionId, value);
+        }
+        this.chatSessionsService.setSessionOption(this.resource, optionId, value);
+    }
+    getModelOptionsSnapshot() {
+        const groups = this._getOptionGroups();
+        if (!groups) {
+            return {
+                modelOption: undefined,
+                isResolved: false
+            };
+        }
+        const group = groups.find(g => isModelOptionGroup(g));
+        if (!group) {
+            return {
+                modelOption: undefined,
+                isResolved: true
+            };
+        }
+        return {
+            modelOption: {
+                group,
+                value: this._getValueForGroup(group)
+            },
+            isResolved: true
+        };
+    }
+    getOtherOptionGroups() {
+        const groups = this._getOptionGroups();
+        if (!groups) {
+            return [];
+        }
+        return groups.filter(
+            g => !isModelOptionGroup(g) && !isRepositoriesOptionGroup(g) && this._isOptionGroupVisible(g)
+        ).map(g => ({
+            group: g,
+            value: this._getValueForGroup(g)
+        }));
+    }
+    getOptionValue(groupId) {
+        return this.selectedOptions.get(groupId);
+    }
+    setOptionValue(groupId, value) {
+        this.setOption(groupId, value);
+    }
+    _getOptionGroups() {
+        return this.chatSessionsService.getOptionGroupsForSessionType(this.target);
+    }
+    _isOptionGroupVisible(group) {
+        if (!group.when) {
+            return true;
+        }
+        const expr = ContextKeyExpr.deserialize(group.when);
+        return !expr || this.contextKeyService.contextMatchesRules(expr);
+    }
+    _updateWhenClauseKeys() {
+        this._whenClauseKeys.clear();
+        const groups = this._getOptionGroups();
+        if (!groups) {
+            return;
+        }
+        for (const group of groups) {
+            if (group.when) {
+                const expr = ContextKeyExpr.deserialize(group.when);
+                if (expr) {
+                    for (const key of ( expr.keys())) {
+                        this._whenClauseKeys.add(key);
+                    }
+                }
+            }
+        }
+    }
+    _getValueForGroup(group) {
+        const selected = this.selectedOptions.get(group.id);
+        if (selected) {
+            return selected;
+        }
+        const sessionOption = this.chatSessionsService.getSessionOption(this.resource, group.id);
+        if (sessionOption && typeof sessionOption !== "string") {
+            return sessionOption;
+        }
+        if (typeof sessionOption === "string") {
+            const item = group.items.find(i => i.id === sessionOption.trim());
+            if (item) {
+                return item;
+            }
+        }
+        return group.items.find(i => i.default === true) ?? group.items[0];
+    }
+    update(_session) {}
+};
+RemoteNewSession = ( __decorate([( __param(5, IChatSessionsService)), ( __param(6, IContextKeyService)), ( __param(7, IStorageService)), ( __param(8, ILanguageModelsService))], RemoteNewSession));
+function toSessionStatus(status) {
+    switch (status) {
+    case ChatSessionStatus.InProgress:
+        return SessionStatus.InProgress;
+    case ChatSessionStatus.NeedsInput:
+        return SessionStatus.NeedsInput;
+    case ChatSessionStatus.Completed:
+        return SessionStatus.Completed;
+    case ChatSessionStatus.Failed:
+        return SessionStatus.Error;
+    }
+}
+function githubRemoteRepoLabel(uri) {
+    if (uri.scheme !== GITHUB_REMOTE_FILE_SCHEME) {
+        return undefined;
+    }
+    const parts = uri.path.replace(/^\//, "").split("/");
+    return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : undefined;
+}
+function resolveGitHubRepositoryId(folder) {
+    const gitHubInfo = folder.gitRepository?.gitHubInfo.get();
+    if (gitHubInfo) {
+        return `${gitHubInfo.owner}/${gitHubInfo.repo}`;
+    }
+    return githubRemoteRepoLabel(folder.root);
+}
+class AgentSessionAdapter {
+    constructor(session, providerId, _gitHubService, _pullRequestIconCache) {
+        this._gitHubService = _gitHubService;
+        this._pullRequestIconCache = _pullRequestIconCache;
+        this._modelSource = observableValue("agentSessionModelSource", undefined);
+        this.modelSource = this._modelSource;
+        this._pullRequestNumberCache = ( new Map());
+        this.permissionLevel = constObservable(ChatPermissionLevel.Default);
+        this.branch = constObservable(undefined);
+        this.isolationMode = constObservable(undefined);
+        this.useSandbox = constObservable(undefined);
+        this.branches = constObservable([]);
+        this.sessionId = toSessionId(providerId, session.resource);
+        this.resource = session.resource;
+        this.providerId = providerId;
+        this.sessionType = session.providerType;
+        this.icon = this._getSessionTypeIcon(session);
+        this.createdAt = ( new Date(session.timing.created));
+        this._baseGitHubInfo = observableValue(this, this._extractGitHubInfo(session));
+        this._pullRequestBranch = observableValue(this, this._extractPullRequestBranch(session));
+        this._pullRequestNumberFromBranch = derived(this, reader => {
+            const base = this._baseGitHubInfo.read(reader);
+            const branch = this._pullRequestBranch.read(reader);
+            if (base?.pullRequest || !base || !branch) {
+                return undefined;
+            }
+            return this._pullRequestNumberForBranch(base.owner, base.repo, branch);
+        });
+        this.gitHubInfo = derived(this, reader => {
+            let info = this._baseGitHubInfo.read(reader);
+            if (!info) {
+                return undefined;
+            }
+            if (!info.pullRequest) {
+                const pullRequestNumber = this._pullRequestNumberFromBranch.read(reader)?.read(reader).value;
+                if (pullRequestNumber === undefined) {
+                    return info;
+                }
+                info = {
+                    ...info,
+                    pullRequest: {
+                        number: pullRequestNumber,
+                        uri: ( URI.parse(`https://github.com/${info.owner}/${info.repo}/pull/${pullRequestNumber}`))
+                    }
+                };
+            }
+            const pullRequest = info.pullRequest;
+            if (!pullRequest) {
+                return info;
+            }
+            if (pullRequest.uri.authority.toLowerCase() !== "github.com") {
+                return info;
+            }
+            const presentation = computePullRequestRefPresentation(reader, this._gitHubService, this._pullRequestIconCache, {
+                owner: info.owner,
+                repo: info.repo,
+                number: pullRequest.number,
+                uri: pullRequest.uri,
+                icon: pullRequest.icon,
+                title: pullRequest.title
+            }, computePullRequestIcon(GitHubPullRequestState.Open));
+            return {
+                ...info,
+                pullRequest: {
+                    ...pullRequest,
+                    ...presentation
+                }
+            };
+        });
+        this._workspace = observableValue(this, this._buildWorkspace(session));
+        this.workspace = this._workspace;
+        this._title = observableValue(this, session.label);
+        this.title = this._title;
+        const updatedTime = session.timing.lastRequestEnded ?? session.timing.lastRequestStarted ?? session.timing.created;
+        this._updatedAt = observableValue(this, ( new Date(updatedTime)));
+        this.updatedAt = this._updatedAt;
+        this._status = observableValue(this, toSessionStatus(session.status));
+        this.status = this._status;
+        this._changes = observableValueOpts({
+            owner: this,
+            equalsFn: sessionFileChangesEqual
+        }, this._extractChanges(session));
+        this.changes = this._changes;
+        this._changesSummary = observableValueOpts({
+            owner: this,
+            equalsFn: structuralEquals
+        }, this._extractChangesSummary(session));
+        this.changesSummary = this._changesSummary;
+        this._checkpoints = observableValueOpts({
+            owner: this,
+            equalsFn: structuralEquals
+        }, this._extractCheckpoints(session));
+        this.checkpoints = this._checkpoints;
+        this._modelId = observableValue(this, undefined);
+        this.modelId = this._modelId;
+        this.mode = observableValue(this, undefined);
+        this.loading = observableValue(this, false);
+        this._isArchived = observableValue(this, session.isArchived());
+        this.isArchived = this._isArchived;
+        this._isRead = observableValue(this, session.isRead());
+        this.isRead = this._isRead;
+        this._description = observableValue(this, this._extractDescription(session));
+        this.description = this._description;
+        this._lastTurnEnd = observableValue(this, session.timing.lastRequestEnded ? ( new Date(session.timing.lastRequestEnded)) : undefined);
+        this.lastTurnEnd = this._lastTurnEnd;
+        this.mainChat = observableValue(this, buildChatFromSession(this));
+    }
+    setPermissionLevel(level) {
+        throw ( new Error("Method not implemented."));
+    }
+    setBranch(branch) {
+        throw ( new Error("Method not implemented."));
+    }
+    setIsolationMode(mode) {
+        throw ( new Error("Method not implemented."));
+    }
+    setUseSandbox(useSandbox) {}
+    setModelId(modelId, source) {
+        transaction(tx => {
+            this._modelSource.set(modelId ? source : undefined, tx);
+            this._modelId.set(modelId, tx);
+        });
+    }
+    setMode(chatMode) {
+        throw ( new Error("Method not implemented."));
+    }
+    update(session) {
+        let changed = false;
+        transaction(tx => {
+            const gitHubInfo = this._extractGitHubInfo(session);
+            const pullRequestBranch = this._extractPullRequestBranch(session);
+            changed = setIfChanged(this._title, session.label, tx) || changed;
+            changed = setIfChanged(this._workspace, this._buildWorkspace(session), tx, sessionWorkspaceEqual) || changed;
+            const updatedTime = session.timing.lastRequestEnded ?? session.timing.lastRequestStarted ?? session.timing.created;
+            changed = setIfChanged(this._updatedAt, ( new Date(updatedTime)), tx, dateEquals) || changed;
+            changed = setIfChanged(this._status, toSessionStatus(session.status), tx) || changed;
+            changed = setIfChanged(this._changes, this._extractChanges(session), tx, sessionFileChangesEqual) || changed;
+            changed = setIfChanged(
+                this._changesSummary,
+                this._extractChangesSummary(session),
+                tx,
+                structuralEquals
+            ) || changed;
+            changed = setIfChanged(this._checkpoints, this._extractCheckpoints(session), tx, structuralEquals) || changed;
+            changed = setIfChanged(this._isArchived, session.isArchived(), tx) || changed;
+            changed = setIfChanged(this._isRead, session.isRead(), tx) || changed;
+            changed = setIfChanged(
+                this._description,
+                this._extractDescription(session),
+                tx,
+                markdownStringEquals
+            ) || changed;
+            changed = setIfChanged(this._lastTurnEnd, session.timing.lastRequestEnded ? ( new Date(session.timing.lastRequestEnded)) : undefined, tx, dateEquals) || changed;
+            changed = setIfChanged(this._baseGitHubInfo, gitHubInfo, tx, gitHubInfoEqual) || changed;
+            changed = setIfChanged(this._pullRequestBranch, pullRequestBranch, tx) || changed;
+        });
+        return changed;
+    }
+    _pullRequestNumberForBranch(owner, repo, branch) {
+        const key = `${owner}/${repo}@${branch}`;
+        const cached = this._pullRequestNumberCache.get(key);
+        if (cached) {
+            return cached;
+        }
+        const lookup = this._gitHubService.findPullRequestNumberByHeadBranch(owner, repo, branch);
+        const observable = observableFromPromise(lookup);
+        this._pullRequestNumberCache.set(key, observable);
+        lookup.then(pullRequestNumber => {
+            if (pullRequestNumber === undefined && this._pullRequestNumberCache.get(key) === observable) {
+                this._pullRequestNumberCache.delete(key);
+            }
+        });
+        return observable;
+    }
+    _getSessionTypeIcon(session) {
+        switch (session.providerType) {
+        case AgentSessionProviders.Background:
+            return CopilotCLISessionType.icon;
+        case AgentSessionProviders.Cloud:
+            return CopilotCloudSessionType.icon;
+        default:
+            return session.icon;
+        }
+    }
+    _extractDescription(session) {
+        if (!session.description) {
+            return undefined;
+        }
+        return typeof session.description === "string" ? ( new MarkdownString(session.description)) : session.description;
+    }
+    _extractGitHubInfo(session) {
+        const metadata = session.metadata;
+        if (!metadata) {
+            return undefined;
+        }
+        const pullRequestUri = this._extractPullRequestUri(session);
+        const pullRequestIdentity = pullRequestUri ? this._extractPullRequestIdentity(pullRequestUri) : undefined;
+        const {
+            owner,
+            repo
+        } = pullRequestIdentity ?? this._extractOwnerRepo(session);
+        if (!owner || !repo) {
+            return undefined;
+        }
+        if (!pullRequestUri || !pullRequestIdentity) {
+            return {
+                owner,
+                repo
+            };
+        }
+        const icon = this._extractPullRequestStateIcon(session);
+        const baseRefOid = typeof metadata.baseRefOid === "string" ? metadata.baseRefOid : undefined;
+        const headRefOid = typeof metadata.headRefOid === "string" ? metadata.headRefOid : undefined;
+        return {
+            owner,
+            repo,
+            pullRequest: {
+                number: pullRequestIdentity.number,
+                uri: pullRequestUri,
+                icon,
+                baseRefOid,
+                headRefOid
+            }
+        };
+    }
+    _extractPullRequestBranch(session) {
+        if (session.providerType !== AgentSessionProviders.Cloud) {
+            return undefined;
+        }
+        if (typeof session.metadata?.host === "string" && session.metadata.host.toLowerCase() !== "github.com") {
+            return undefined;
+        }
+        return typeof session.metadata?.branch === "string" ? session.metadata.branch : undefined;
+    }
+    _extractPullRequestIdentity(pullRequestUri) {
+        const match = /^\/(?<owner>[^/]+)\/(?<repo>[^/]+)\/pull\/(?<number>\d+)\/?$/.exec(pullRequestUri.path);
+        if (!match?.groups) {
+            return undefined;
+        }
+        return {
+            owner: decodeURIComponent(match.groups.owner),
+            repo: decodeURIComponent(match.groups.repo),
+            number: parseInt(match.groups.number, 10)
+        };
+    }
+    _extractOwnerRepo(session) {
+        const metadata = session.metadata;
+        if (!metadata) {
+            return {
+                owner: undefined,
+                repo: undefined
+            };
+        }
+        if (typeof metadata.owner === "string" && typeof metadata.name === "string") {
+            return {
+                owner: metadata.owner,
+                repo: metadata.name
+            };
+        }
+        if (typeof metadata.repositoryNwo === "string") {
+            const parts = metadata.repositoryNwo.split("/");
+            if (parts.length === 2) {
+                return {
+                    owner: parts[0],
+                    repo: parts[1]
+                };
+            }
+        }
+        const repoUri = this._buildWorkspace(session)?.folders[0]?.root;
+        if (repoUri && repoUri.scheme === GITHUB_REMOTE_FILE_SCHEME) {
+            const parts = repoUri.path.split("/").filter(Boolean);
+            if (parts.length >= 2) {
+                return {
+                    owner: decodeURIComponent(parts[0]),
+                    repo: decodeURIComponent(parts[1])
+                };
+            }
+        }
+        return {
+            owner: undefined,
+            repo: undefined
+        };
+    }
+    _extractPullRequestStateIcon(session) {
+        const metadata = session.metadata;
+        const state = metadata?.pullRequestState;
+        if (typeof state === "string") {
+            return computePullRequestIcon(state);
+        }
+        return undefined;
+    }
+    _extractPullRequestUri(session) {
+        return getAgentSessionPullRequestUri(session);
+    }
+    _extractChanges(session) {
+        return session.changes && !isChangesSummary(session.changes) ? session.changes : [];
+    }
+    _extractChangesSummary(session) {
+        if (!isChangesSummary(session.changes)) {
+            return undefined;
+        }
+        return {
+            files: session.changes.files,
+            additions: session.changes.insertions,
+            deletions: session.changes.deletions
+        };
+    }
+    _extractCheckpoints(session) {
+        const metadata = session.metadata;
+        if (typeof metadata?.firstCheckpointRef !== "string" || typeof metadata?.lastCheckpointRef !== "string") {
+            return undefined;
+        }
+        return {
+            firstCheckpointRef: metadata.firstCheckpointRef,
+            lastCheckpointRef: metadata.lastCheckpointRef
+        };
+    }
+    _buildWorkspace(session) {
+        const {
+            repoUri,
+            worktreeUri,
+            branchName,
+            baseBranchName,
+            baseBranchProtected,
+            hasGitHubRemote,
+            upstreamBranchName,
+            incomingChanges,
+            outgoingChanges,
+            uncommittedChanges,
+            hasGitOperationInProgress
+        } = this._extractRepositoryFromMetadata(session);
+        const repoUriResolved = repoUri ?? ( URI.parse("unknown:///"));
+        const gitRepository = {
+            uri: repoUriResolved,
+            workTreeUri: worktreeUri,
+            isRepository: constObservable(repoUri !== undefined),
+            branchName,
+            baseBranchName,
+            baseBranchProtected,
+            hasGitHubRemote,
+            upstreamBranchName,
+            incomingChanges,
+            outgoingChanges,
+            uncommittedChanges,
+            hasGitOperationInProgress,
+            gitHubInfo: this.gitHubInfo
+        };
+        const folder = {
+            root: repoUriResolved,
+            workingDirectory: worktreeUri ?? repoUriResolved,
+            name: basename(repoUriResolved),
+            description: branchName,
+            gitRepository
+        };
+        return {
+            uri: repoUriResolved,
+            label: githubRemoteRepoLabel(repoUriResolved) ?? getRepositoryName(session) ?? basename(repoUriResolved),
+            icon: repoUri?.scheme === GITHUB_REMOTE_FILE_SCHEME ? Codicon.repo : Codicon.folder,
+            group: repoUri?.scheme === GITHUB_REMOTE_FILE_SCHEME ? SESSION_WORKSPACE_GROUP_GITHUB : SESSION_WORKSPACE_GROUP_LOCAL,
+            folders: [folder],
+            requiresWorkspaceTrust: session.providerType !== AgentSessionProviders.Cloud,
+            isVirtualWorkspace: session.providerType === AgentSessionProviders.Cloud
+        };
+    }
+    _extractRepositoryFromMetadata(session) {
+        const metadata = session.metadata;
+        if (!metadata) {
+            return {};
+        }
+        if (session.providerType === AgentSessionProviders.Cloud) {
+            if (typeof metadata.owner !== "string" || typeof metadata.name !== "string") {
+                return {};
+            }
+            const branch = typeof metadata.branch === "string" ? metadata.branch : "HEAD";
+            const repositoryUri = ( URI.from({
+                scheme: GITHUB_REMOTE_FILE_SCHEME,
+                authority: "github",
+                path: `/${metadata.owner}/${metadata.name}/${encodeURIComponent(branch)}`
+            }));
+            return {
+                repoUri: repositoryUri
+            };
+        }
+        const repoUri = typeof metadata?.repositoryPath === "string" ? URI.file(metadata.repositoryPath) : undefined;
+        const worktreeUri = typeof metadata?.worktreePath === "string" ? URI.file(metadata.worktreePath) : undefined;
+        return {
+            repoUri,
+            worktreeUri,
+            branchName: metadata?.branchName,
+            baseBranchName: metadata?.baseBranchName,
+            baseBranchProtected: metadata?.baseBranchProtected,
+            hasGitHubRemote: metadata?.hasGitHubRemote,
+            upstreamBranchName: metadata?.upstreamBranchName,
+            incomingChanges: metadata?.incomingChanges,
+            outgoingChanges: metadata?.outgoingChanges,
+            uncommittedChanges: metadata?.uncommittedChanges,
+            hasGitOperationInProgress: metadata?.hasGitOperationInProgress
+        };
+    }
+}
+let CopilotChatSessionsProvider = class CopilotChatSessionsProvider extends Disposable {
+    static {
+        CopilotChatSessionsProvider_1 = this;
+    }
+    static {
+        this.SANDBOX_MODEL_WAIT_MS = 5_000;
+    }
+    static {
+        this.AUTOMATION_AGENT_RESOLUTION_TIMEOUT_MS = 30_000;
+    }
+    get sessionTypes() {
+        const types = [];
+        if (this._isCopilotCliAvailable()) {
+            types.push(CopilotCLISessionType);
+        }
+        types.push(CopilotCloudSessionType);
+        return types;
+    }
+    _registerGroupMembershipFanOut() {
+        this._register(this._onDidGroupMembershipChange.event(e => {
+            this._groupMembershipSignals.get(e.sessionId)?.trigger(undefined, undefined);
+        }));
+    }
+    _isCopilotCliAvailable() {
+        return !this.agentHostEnablementService.enabled.get();
+    }
+    constructor(
+        agentSessionsService,
+        chatService,
+        chatSessionsService,
+        dialogService,
+        commandService,
+        instantiationService,
+        languageModelsService,
+        toolsService,
+        configurationService,
+        agentHostEnablementService,
+        logService,
+        notificationService,
+        gitHubService,
+        pullRequestIconCache,
+        labelService,
+        chatModeService,
+        uriIdentityService,
+        fileService,
+        pathService
+    ) {
+        super();
+        this.agentSessionsService = agentSessionsService;
+        this.chatService = chatService;
+        this.chatSessionsService = chatSessionsService;
+        this.dialogService = dialogService;
+        this.commandService = commandService;
+        this.instantiationService = instantiationService;
+        this.languageModelsService = languageModelsService;
+        this.toolsService = toolsService;
+        this.configurationService = configurationService;
+        this.agentHostEnablementService = agentHostEnablementService;
+        this.logService = logService;
+        this.notificationService = notificationService;
+        this.gitHubService = gitHubService;
+        this.pullRequestIconCache = pullRequestIconCache;
+        this.labelService = labelService;
+        this.chatModeService = chatModeService;
+        this.uriIdentityService = uriIdentityService;
+        this.fileService = fileService;
+        this.pathService = pathService;
+        this.id = COPILOT_PROVIDER_ID;
+        this.label = ( localize(4215, "Copilot Chat"));
+        this.icon = Codicon.copilot;
+        this.order = 0;
+        this.supportsAutomationSessionConfiguration = true;
+        this._onDidChangeSessionTypes = this._register(( new Emitter()));
+        this.onDidChangeSessionTypes = this._onDidChangeSessionTypes.event;
+        this._onDidChangeSessions = this._register(( new Emitter()));
+        this.onDidChangeSessions = this._onDidChangeSessions.event;
+        this._onDidReplaceSession = this._register(( new Emitter()));
+        this.onDidReplaceSession = this._onDidReplaceSession.event;
+        this._sessionCache = ( new Map());
+        this._inFlightCommits = ( new Set());
+        this._sessionGroupCache = ( new Map());
+        this._onDidGroupMembershipChange = this._register(( new Emitter()));
+        this._groupMembershipSignals = ( new Map());
+        this._localGitRepositoryState = ( new Map());
+        this._localGitRepositoryResolutionStarted = ( new Set());
+        this.supportsLocalWorkspaces = true;
+        this._newSessions = this._register(( new DisposableMap()));
+        this._multiChatEnabled = this.configurationService.getValue(COPILOT_MULTI_CHAT_SETTING) ?? true;
+        this._register(runOnChange(this.agentHostEnablementService.enabled, () => {
+            this._onDidChangeSessionTypes.fire();
+            this._refreshSessionCache();
+        }));
+        this._register(Event.filter(
+            this.configurationService.onDidChangeConfiguration,
+            event => event.affectsConfiguration(UNIFIED_WORKSPACE_PICKER_SETTING)
+        )(() => this._onDidChangeSessionTypes.fire()));
+        this._register(this.agentSessionsService.model.onDidChangeSessions(() => {
+            this._refreshSessionCache();
+        }));
+        this._registerGroupMembershipFanOut();
+        this._ensureSessionCache();
+    }
+    get browseActions() {
+        const useConsolidatedRemoteWorkspaces = this.configurationService.getValue(UNIFIED_WORKSPACE_PICKER_SETTING);
+        const repositoryActions = useConsolidatedRemoteWorkspaces ? [{
+            label: ( localize(4216, "Work in Repository...")),
+            group: SESSION_WORKSPACE_GROUP_GITHUB,
+            icon: Codicon.github,
+            providerId: this.id,
+            attachesContext: false,
+            supportsContextAttachment: true,
+            run: () => this._browseForRepository()
+        }] : [{
+            label: ( localize(4217, "Repository...")),
+            group: SESSION_WORKSPACE_GROUP_GITHUB,
+            icon: Codicon.library,
+            providerId: this.id,
+            attachesContext: false,
+            supportsContextAttachment: true,
+            run: () => this._browseForRepository()
+        }];
+        return [...repositoryActions, {
+            label: ( localize(4218, "Issue...")),
+            group: SESSION_WORKSPACE_GROUP_GITHUB,
+            icon: Codicon.issues,
+            providerId: this.id,
+            attachesContext: true,
+            run: workspace => this._browseForGitHubContext(OPEN_ISSUE_COMMAND, Codicon.issues, workspace)
+        }, {
+            label: ( localize(4219, "Pull Request...")),
+            group: SESSION_WORKSPACE_GROUP_GITHUB,
+            icon: useConsolidatedRemoteWorkspaces ? Codicon.github : Codicon.gitPullRequest,
+            providerId: this.id,
+            attachesContext: true,
+            run: workspace => this._browseForGitHubContext(
+                OPEN_PULL_REQUEST_COMMAND,
+                useConsolidatedRemoteWorkspaces ? Codicon.github : Codicon.gitPullRequest,
+                workspace
+            )
+        }];
+    }
+    getSessionTypes(workspaceUri) {
+        if (workspaceUri.scheme === GITHUB_REMOTE_FILE_SCHEME || workspaceUri.scheme === SessionType.CopilotCloud) {
+            return [CopilotCloudSessionType];
+        }
+        const types = [];
+        if (this._isCopilotCliAvailable()) {
+            types.push(CopilotCLISessionType);
+        }
+        if (this.configurationService.getValue(UNIFIED_WORKSPACE_PICKER_SETTING) && workspaceUri.scheme === Schemas.file) {
+            const gitRepository = this._getLocalGitRepository(workspaceUri);
+            gitRepository.resolveGitHubInfo?.();
+            if (gitRepository.gitHubInfo.get()) {
+                types.push(CopilotCloudSessionType);
+            }
+        }
+        return types;
+    }
+    getSessions() {
+        this._ensureSessionCache();
+        if (!this._isMultiChatEnabled()) {
+            return Array.from(( this._sessionCache.values())).map(chat => this._chatToSession(chat));
+        }
+        const allChats = Array.from(( this._sessionCache.values())).sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+        const seen = ( new Set());
+        const sessions = [];
+        for (const chat of allChats) {
+            const groupId = this._getGroupIdForChat(chat);
+            if (!( seen.has(groupId))) {
+                seen.add(groupId);
+                sessions.push(this._chatToSession(chat));
+            }
+        }
+        return sessions;
+    }
+    _clearCurrentNewSessionIfMatch(session, leak) {
+        if (this._newSessions.get(session.sessionId) === session) {
+            if (leak) {
+                this._newSessions.deleteAndLeak(session.sessionId);
+            } else {
+                this._newSessions.deleteAndDispose(session.sessionId);
+            }
+        }
+    }
+    deleteNewSession(sessionId) {
+        if (( this._newSessions.has(sessionId))) {
+            this._newSessions.deleteAndDispose(sessionId);
+        }
+    }
+    getSession(sessionId) {
+        const newSession = this._newSessions.get(sessionId);
+        if (newSession) {
+            return newSession;
+        }
+        return this._findChatSession(sessionId);
+    }
+    createNewSession(workspaceUri, sessionTypeId, options) {
+        const workspace = this.resolveWorkspace(workspaceUri);
+        if (!workspace) {
+            throw ( new Error(`Cannot resolve workspace for URI: ${( workspaceUri.toString())}`));
+        }
+        const automationConfiguration = options?.automationConfiguration;
+        assertAutomationSessionTemplate(automationConfiguration?.sessionTemplate);
+        let session;
+        if (workspaceUri.scheme === GITHUB_REMOTE_FILE_SCHEME && sessionTypeId !== CopilotCloudSessionType.id) {
+            throw ( new Error("Only Copilot Cloud sessions can be created for GitHub repositories"));
+        }
+        if (sessionTypeId === CopilotCloudSessionType.id) {
+            const cloudWorkspace = workspaceUri.scheme === GITHUB_REMOTE_FILE_SCHEME ? workspace : this._getCloudWorkspaceForLocalRepository(workspace);
+            if (!cloudWorkspace) {
+                throw ( new Error("Copilot Cloud sessions require a local workspace with a GitHub remote"));
+            }
+            const resource = ( URI.from({
+                scheme: AgentSessionProviders.Cloud,
+                path: `/untitled-${generateUuid()}`
+            }));
+            session = this.instantiationService.createInstance(
+                RemoteNewSession,
+                resource,
+                cloudWorkspace,
+                AgentSessionProviders.Cloud,
+                this.id,
+                automationConfiguration
+            );
+        } else {
+            if (sessionTypeId !== CopilotCLISessionType.id) {
+                throw ( new Error(`Unsupported session type '${sessionTypeId}' for local workspaces`));
+            }
+            const resource = ( URI.from({
+                scheme: AgentSessionProviders.Background,
+                path: `/untitled-${generateUuid()}`
+            }));
+            session = this.instantiationService.createInstance(CopilotCLISession, resource, workspace, this.id, automationConfiguration);
+            session.setPermissionLevel(this._defaultPermissionLevel());
+        }
+        this._newSessions.set(session.sessionId, session);
+        try {
+            this._applyAutomationSessionConfiguration(session, automationConfiguration);
+            return this._chatToSession(session);
+        } catch (error) {
+            this._newSessions.deleteAndDispose(session.sessionId);
+            throw error;
+        }
+    }
+    _getCloudWorkspaceForLocalRepository(workspace) {
+        const gitHubInfo = workspace.folders.map(folder => folder.gitRepository?.gitHubInfo.get()).find(info => info !== undefined);
+        if (!gitHubInfo) {
+            return undefined;
+        }
+        const root = ( URI.from({
+            scheme: GITHUB_REMOTE_FILE_SCHEME,
+            authority: "github",
+            path: `/${gitHubInfo.owner}/${gitHubInfo.repo}/HEAD`
+        }));
+        return this.resolveWorkspace(root);
+    }
+    getAutomationModelConfiguration(sessionId) {
+        return this._newSessions.get(sessionId)?.modelConfiguration;
+    }
+    async getAutomationSessionConfiguration(sessionId) {
+        const session = this._newSessions.get(sessionId);
+        if (!session) {
+            return undefined;
+        }
+        const modelId = session.modelId.get();
+        const modelConfiguration = session.modelConfiguration.captureModelConfiguration(modelId);
+        const initialConfiguration = session.initialAutomationSessionConfiguration;
+        const initialTemplate = initialConfiguration?.sessionTemplate;
+        const initialMode = initialConfiguration?.mode ?? initialTemplate?.config?.[SessionConfigKey.Mode];
+        const mode = session instanceof CopilotCLISession ? session.mode.get()?.id : typeof initialMode === "string" ? initialMode : undefined;
+        const initialPermissionLevel = initialConfiguration?.permissionLevel ?? initialTemplate?.config?.[SessionConfigKey.AutoApprove];
+        const permissionLevel = session instanceof RemoteNewSession && isChatPermissionLevel(initialPermissionLevel) ? initialPermissionLevel : session.permissionLevel.get();
+        const config = {
+            ...initialTemplate?.config
+        };
+        if (mode) {
+            config[SessionConfigKey.Mode] = mode;
+        } else {
+            delete config[SessionConfigKey.Mode];
+        }
+        config[SessionConfigKey.AutoApprove] = permissionLevel;
+        const agentUri = session.chatMode?.uri?.get();
+        const agent = agentUri ? {
+            uri: ( agentUri.toString())
+        } : initialTemplate?.agent && mode === initialTemplate.agent.uri ? initialTemplate.agent : undefined;
+        const sessionTemplate = {
+            ...(modelId ? {
+                modelId
+            } : {}),
+            ...(modelConfiguration !== undefined ? {
+                modelConfiguration
+            } : {}),
+            ...(agent ? {
+                agent
+            } : {}),
+            ...(( Object.keys(config)).length > 0 ? {
+                config
+            } : {})
+        };
+        return {
+            sessionTemplate,
+            modelId,
+            mode,
+            permissionLevel
+        };
+    }
+    createQuickChat(_sessionTypeId, _options) {
+        throw ( new Error("CopilotChatSessionsProvider does not support quick chats"));
+    }
+    _defaultPermissionLevel() {
+        const policyRestricted = this.configurationService.inspect(ChatConfiguration.GlobalAutoApprove).policyValue === false;
+        if (policyRestricted) {
+            return ChatPermissionLevel.Default;
+        }
+        const level = this.configurationService.getValue(ChatConfiguration.DefaultPermissionLevel);
+        return isChatPermissionLevel(level) ? level : ChatPermissionLevel.Default;
+    }
+    _applyAutomationSessionConfiguration(session, configuration) {
+        if (!configuration) {
+            return;
+        }
+        const template = configuration.sessionTemplate;
+        if (template?.agent && session instanceof RemoteNewSession) {
+            throw ( new Error(( localize(
+                4220,
+                "This provider does not support custom agents in Automation session templates."
+            ))));
+        }
+        if (template?.agent) {
+            try {
+                ( URI.parse(template.agent.uri, true));
+            } catch (error) {
+                throw ( new Error(( localize(4221, "The Automation's selected agent must have an absolute URI.")), {
+                    cause: error
+                }));
+            }
+        }
+        const modelId = template?.modelId ?? configuration.modelId;
+        if (modelId) {
+            session.setModelId(modelId, ChatModelSource.Chosen);
+        }
+        const mode = template?.agent?.uri ?? template?.config?.[SessionConfigKey.Mode] ?? configuration.mode;
+        if (typeof mode === "string") {
+            const restored = this._setSessionMode(session, mode);
+            if (!restored && session instanceof CopilotCLISession) {
+                session.setModeById(mode, ChatModeKind.Agent);
+            }
+        }
+        const permissionLevel = template?.config?.[SessionConfigKey.AutoApprove] ?? configuration.permissionLevel;
+        if (!(session instanceof RemoteNewSession) && isChatPermissionLevel(permissionLevel)) {
+            session.setPermissionLevel(permissionLevel);
+        }
+    }
+    get onDidChangeModels() {
+        return Event.signal(Event.any(
+            this.languageModelsService.onDidChangeLanguageModels,
+            this.chatSessionsService.onDidChangeOptionGroups
+        ));
+    }
+    getModelsSnapshot(sessionId, desiredModelId) {
+        const session = this.getSession(sessionId);
+        if (session instanceof RemoteNewSession) {
+            const {
+                modelOption,
+                isResolved
+            } = session.getModelOptionsSnapshot();
+            const models = modelOption?.group.items.map(item => this._toSyntheticModel(item)) ?? [];
+            return {
+                models,
+                desiredModelResolution: resolveModelIdentifier(models, desiredModelId, isResolved),
+                modelTarget: session.sessionType
+            };
+        }
+        const sessionType = session?.sessionType;
+        if (!sessionType) {
+            return {
+                models: [],
+                desiredModelResolution: resolveModelIdentifier([], desiredModelId, false),
+                modelTarget: undefined
+            };
+        }
+        const allModels = getRegisteredLanguageModels(this.languageModelsService);
+        const models = allModels.filter(model => model.metadata.targetChatSessionType === sessionType);
+        return {
+            models,
+            desiredModelResolution: resolveModelIdentifierFromLanguageModels(models, desiredModelId, this.languageModelsService, allModels),
+            modelTarget: sessionType
+        };
+    }
+    getModelPickerOptions(sessionId) {
+        const sessionType = this.getSession(sessionId)?.sessionType;
+        const showAutoModel = !sessionType || this.chatSessionsService.supportsAutoModelForSessionType(sessionType);
+        return {
+            useGroupedModelPicker: true,
+            showFeatured: true,
+            showUnavailableFeatured: false,
+            showManageModelsAction: false,
+            showAutoModel
+        };
+    }
+    _toSyntheticModel(item) {
+        const modelMetadata = item.modelMetadata;
+        return {
+            identifier: item.id,
+            metadata: {
+                extension: ( new ExtensionIdentifier("")),
+                name: modelMetadata?.name ?? item.name,
+                id: modelMetadata?.id ?? item.id,
+                vendor: modelMetadata?.vendor ?? "",
+                version: modelMetadata?.version ?? "",
+                family: modelMetadata?.family ?? "",
+                tooltip: modelMetadata?.tooltip ?? item.tooltip,
+                pricing: modelMetadata?.pricing,
+                multiplierNumeric: modelMetadata?.multiplierNumeric,
+                inputCost: modelMetadata?.inputCost,
+                outputCost: modelMetadata?.outputCost,
+                cacheCost: modelMetadata?.cacheCost,
+                cacheWriteCost: modelMetadata?.cacheWriteCost,
+                longContextInputCost: modelMetadata?.longContextInputCost,
+                longContextOutputCost: modelMetadata?.longContextOutputCost,
+                longContextCacheCost: modelMetadata?.longContextCacheCost,
+                longContextCacheWriteCost: modelMetadata?.longContextCacheWriteCost,
+                priceCategory: modelMetadata?.priceCategory,
+                promo: modelMetadata?.promo,
+                maxInputTokens: modelMetadata?.maxInputTokens ?? 0,
+                maxOutputTokens: modelMetadata?.maxOutputTokens ?? 0,
+                capabilities: modelMetadata?.capabilities ? {
+                    vision: modelMetadata.capabilities.vision,
+                    toolCalling: modelMetadata.capabilities.toolCalling
+                } : undefined,
+                isUserSelectable: true,
+                isDefaultForLocation: {}
+            }
+        };
+    }
+    setModel(sessionId, chatResource, modelId, source) {
+        const newSession = this._newSessions.get(sessionId);
+        if (newSession) {
+            const previousModelId = newSession.modelId.get();
+            if (previousModelId && previousModelId !== modelId) {
+                const resolution = this.getModelsSnapshot(sessionId, previousModelId).desiredModelResolution;
+                if (resolution.kind === "available" && resolution.model.identifier === modelId) {
+                    newSession.modelConfiguration.rebindModelConfiguration(previousModelId, modelId);
+                }
+            }
+            newSession.setModelId(modelId, source);
+            if (newSession instanceof RemoteNewSession) {
+                const {
+                    modelOption
+                } = newSession.getModelOptionsSnapshot();
+                const item = modelOption?.group.items.find(i => i.id === modelId);
+                if (item) {
+                    newSession.setOptionValue(modelOption.group.id, item);
+                }
+            }
+            return;
+        }
+        this._ensureSessionCache();
+        const chatSession = this._sessionCache.get(( chatResource.toString())) ?? this._findChatSession(sessionId);
+        chatSession?.setModelId(modelId, source);
+    }
+    setMode(sessionId, modeId) {
+        const newSession = this._newSessions.get(sessionId);
+        if (newSession) {
+            this._setSessionMode(newSession, modeId);
+            return;
+        }
+        this._ensureSessionCache();
+        const session = this._findChatSession(sessionId);
+        if (session) {
+            this._setSessionMode(session, modeId);
+        }
+    }
+    _setSessionMode(session, modeId) {
+        let mode;
+        switch (modeId) {
+        case ChatModeKind.Agent:
+            mode = ChatMode.Agent;
+            break;
+        case ChatModeKind.Edit:
+            mode = ChatMode.Edit;
+            break;
+        case ChatModeKind.Ask:
+            mode = ChatMode.Ask;
+            break;
+        default:
+            {
+                const modes = this.chatModeService.createModes(session.resource);
+                try {
+                    mode = this._findSessionMode(session, modes, modeId);
+                } finally {
+                    modes.dispose();
+                }
+                break;
+            }
+        }
+        if (mode) {
+            session.setMode(mode);
+            return true;
+        }
+        return false;
+    }
+    _findSessionMode(session, modes, modeId) {
+        const initialAgent = session.initialAutomationSessionConfiguration?.sessionTemplate?.agent;
+        return initialAgent?.uri === modeId ? modes.custom.find(mode => isEqual(mode.uri?.get(), ( URI.parse(initialAgent.uri)))) : modes.findModeById(modeId) ?? modes.findModeByName(modeId);
+    }
+    async _resolveAutomationSessionMode(session) {
+        const deadline = Date.now() + CopilotChatSessionsProvider_1.AUTOMATION_AGENT_RESOLUTION_TIMEOUT_MS;
+        while (true) {
+            const modeId = session.mode.get()?.id;
+            if (!modeId || modeId === ChatModeKind.Agent || modeId === ChatModeKind.Ask || modeId === ChatModeKind.Edit) {
+                return;
+            }
+            const selectedMode = session.chatMode;
+            const store = ( new DisposableStore());
+            const cancellation = store.add(( new CancellationTokenSource(session.cancellationToken)));
+            try {
+                const modes = store.add(this.chatModeService.createModes(session.resource));
+                const remaining = deadline - Date.now();
+                const resolved = remaining > 0 && (await raceTimeout(
+                    raceCancellationError(modes.waitForPendingUpdates().then(() => true), cancellation.token),
+                    remaining
+                ));
+                if (!resolved) {
+                    throw ( new Error(( localize(
+                        4222,
+                        "Timed out resolving the Automation's custom agent. Check the provider connection and try again."
+                    ))));
+                }
+                if (this._newSessions.get(session.sessionId) !== session) {
+                    throw ( new CancellationError());
+                }
+                if (session.mode.get()?.id !== modeId || session.chatMode !== selectedMode) {
+                    continue;
+                }
+                const mode = this._findSessionMode(session, modes, modeId);
+                if (!mode) {
+                    throw ( new Error(( localize(
+                        4223,
+                        "The Automation's selected agent '{0}' is unavailable. Choose another agent or restore it before running the Automation.",
+                        modeId
+                    ))));
+                }
+                session.setMode(mode);
+                return;
+            } finally {
+                cancellation.cancel();
+                store.dispose();
+            }
+        }
+    }
+    setPermissionLevel(sessionId, level) {
+        const newSession = this._newSessions.get(sessionId);
+        if (newSession) {
+            if (isChatPermissionLevel(level)) {
+                newSession.setPermissionLevel(level);
+            }
+            return;
+        }
+        this._ensureSessionCache();
+        const session = this._findChatSession(sessionId);
+        if (session && isChatPermissionLevel(level)) {
+            session.setPermissionLevel(level);
+        }
+    }
+    async setIsolationMode(sessionId, mode) {
+        if (mode !== "worktree" && mode !== "workspace") {
+            return;
+        }
+        const newSession = this._newSessions.get(sessionId);
+        if (newSession) {
+            newSession.setIsolationMode(mode);
+            return;
+        }
+        this._ensureSessionCache();
+        this._findChatSession(sessionId)?.setIsolationMode(mode);
+    }
+    async setBranch(sessionId, branch) {
+        const newSession = this._newSessions.get(sessionId);
+        if (newSession) {
+            newSession.setBranch(branch);
+            return;
+        }
+        this._ensureSessionCache();
+        this._findChatSession(sessionId)?.setBranch(branch);
+    }
+    async archiveSession(sessionId) {
+        const chatSession = this._findChatSession(sessionId);
+        if (chatSession && isNewSession(chatSession)) {
+            chatSession.setArchived(true);
+            this._onDidChangeSessions.fire({
+                added: [],
+                removed: [],
+                changed: [this._chatToSession(chatSession)]
+            });
+            return;
+        }
+        const agentSession = this._findAgentSession(sessionId);
+        if (agentSession) {
+            agentSession.setArchived(true);
+        }
+    }
+    async unarchiveSession(sessionId) {
+        const chatSession = this._findChatSession(sessionId);
+        if (chatSession && isNewSession(chatSession)) {
+            chatSession.setArchived(false);
+            this._onDidChangeSessions.fire({
+                added: [],
+                removed: [],
+                changed: [this._chatToSession(chatSession)]
+            });
+            return;
+        }
+        const agentSession = this._findAgentSession(sessionId);
+        if (agentSession) {
+            agentSession.setArchived(false);
+        }
+    }
+    async setSessionReadState(sessionId, isRead) {
+        const chatIds = this._getChatIdsInGroup(sessionId);
+        const targetIds = chatIds.length > 0 ? chatIds : [sessionId];
+        for (const chatId of targetIds) {
+            const agentSession = this._findAgentSession(chatId);
+            if (agentSession && agentSession.isRead() !== isRead) {
+                agentSession.setRead(isRead);
+            }
+        }
+    }
+    async deleteSession(sessionId) {
+        const chatIds = this._getChatIdsInGroup(sessionId);
+        const allChatIds = ( new Set([sessionId, ...chatIds]));
+        const agentSessions = [];
+        for (const chatId of allChatIds) {
+            const agentSession = this._findAgentSession(chatId);
+            if (agentSession) {
+                agentSessions.push(agentSession);
+            }
+        }
+        if (agentSessions.length === 0) {
+            this._cleanupTempSession(sessionId);
+            return;
+        }
+        await this._deleteAgentSessions(agentSessions);
+        this._sessionGroupCache.delete(sessionId);
+        this._refreshSessionCache();
+    }
+    async deleteSessions(sessionIds) {
+        for (const sessionId of sessionIds) {
+            await this.deleteSession(sessionId);
+        }
+    }
+    async renameChat(sessionId, chatUri, title) {
+        const agentSession = this.agentSessionsService.getSession(chatUri);
+        if (agentSession?.providerType === CopilotCLISessionType.id) {
+            await this.commandService.executeCommand("github.copilot.cli.sessions.setTitle", {
+                resource: chatUri
+            }, title);
+            return;
+        }
+        throw ( new Error("Renaming is not supported for this session type"));
+    }
+    async renameSession(sessionId, title) {
+        const session = this._findSession(sessionId);
+        if (session) {
+            await this.renameChat(sessionId, session.mainChat.get().resource, title);
+        }
+    }
+    async deleteChat(sessionId, chatUri, options) {
+        const session = this._findSession(sessionId);
+        if (!session?.capabilities.get().supportsMultipleChats) {
+            throw ( new Error("Deleting individual chats is not supported when multi-chat is disabled"));
+        }
+        const chatIds = this._getChatIdsInGroup(sessionId);
+        const chatId = chatIds.find(id => {
+            const chat = this._sessionCache.get(this._localIdFromchatId(id));
+            return chat && ( chat.resource.toString()) === ( chatUri.toString());
+        });
+        if (!chatId) {
+            return false;
+        }
+        if (chatIds.length <= 1) {
+            await this.deleteSession(sessionId);
+            return true;
+        }
+        const agentSession = this._findAgentSession(chatId);
+        if (agentSession) {
+            if (!options?.skipConfirmation) {
+                const confirmed = await this.dialogService.confirm({
+                    message: ( localize(4224, "Are you sure you want to delete this chat?")),
+                    detail: ( localize(4225, "This action cannot be undone.")),
+                    primaryButton: ( localize(4226, "Delete"))
+                });
+                if (!confirmed.confirmed) {
+                    return false;
+                }
+            }
+            await this._deleteAgentSessions([agentSession]);
+        } else {
+            const chat = this._findChatSession(chatId);
+            if (chat) {
+                const key = ( chat.resource.toString());
+                this._sessionCache.delete(key);
+                this._invalidateGroupingCaches();
+                if (( this._newSessions.has(chatId))) {
+                    this._newSessions.deleteAndDispose(chatId);
+                }
+            }
+            this._sessionGroupCache.delete(sessionId);
+            this._onDidGroupMembershipChange.fire({
+                sessionId
+            });
+            const remainingChatIds = this._getChatIdsInGroup(sessionId);
+            const primaryChatId = remainingChatIds[0];
+            const primaryChat = primaryChatId ? this._sessionCache.get(this._localIdFromchatId(primaryChatId)) : undefined;
+            if (primaryChat) {
+                this._onDidChangeSessions.fire({
+                    added: [],
+                    removed: [],
+                    changed: [this._chatToSession(primaryChat)]
+                });
+            }
+        }
+        return true;
+    }
+    async _deleteAgentSessions(agentSessions) {
+        const cliSessionItems = [];
+        for (const agentSession of agentSessions) {
+            if (agentSession.providerType === CopilotCLISessionType.id) {
+                cliSessionItems.push({
+                    resource: agentSession.resource,
+                    label: agentSession.label
+                });
+            } else {
+                await this.chatService.removeHistoryEntry(agentSession.resource);
+            }
+        }
+        if (cliSessionItems.length > 0) {
+            await this.commandService.executeCommand("agents.github.copilot.cli.deleteSessions", cliSessionItems, {
+                skipConfirmation: true
+            });
+        }
+    }
+    async forkChat(sessionId, _sourceChat, _turnId) {
+        throw ( new Error(`Session '${sessionId}' does not support forking into a chat`));
+    }
+    async createSideChat(sessionId, _sourceChat, _turnId, _selection) {
+        throw ( new Error(`Session '${sessionId}' does not support side chats`));
+    }
+    async createNewChat(sessionId, _prompt) {
+        const currentNewSession = this._newSessions.get(sessionId);
+        if (currentNewSession) {
+            const session = currentNewSession;
+            (await this._createChatSession(session.resource, session)).dispose();
+            const newChat = this._toChat(session);
+            session.mainChat.set(newChat, undefined);
+            return newChat;
+        }
+        if (!this._isMultiChatEnabled()) {
+            throw ( new Error(
+                `[CopilotChatSessionsProvider] Session '${sessionId}' does not support multiple chats`
+            ));
+        }
+        return this._createNewSubsequentChat(sessionId);
+    }
+    async _createNewSubsequentChat(sessionId) {
+        const chatIds = this._getChatIdsInGroup(sessionId);
+        const firstChatId = chatIds[0] ?? sessionId;
+        const chat = this._sessionCache.get(this._localIdFromchatId(firstChatId));
+        if (!chat) {
+            throw ( new Error(`Session '${sessionId}' not found`));
+        }
+        if (chat.sessionType !== CopilotCLISessionType.id) {
+            throw ( new Error("Multiple chats per session is only supported for Copilot CLI sessions"));
+        }
+        const workspace = chat.workspace.get();
+        if (!workspace) {
+            throw ( new Error("Chat session has no associated workspace"));
+        }
+        const folder = workspace.folders[0];
+        if (!folder) {
+            throw ( new Error("Workspace has no folder"));
+        }
+        const newWorkspace = this.resolveWorkspace(folder.workingDirectory);
+        if (!newWorkspace) {
+            throw ( new Error(`Cannot resolve workspace for working directory URI: ${( folder.workingDirectory.toString())}`));
+        }
+        const resource = ( URI.from({
+            scheme: AgentSessionProviders.Background,
+            path: `/untitled-${generateUuid()}`
+        }));
+        const session = this.instantiationService.createInstance(CopilotCLISession, resource, newWorkspace, this.id, undefined);
+        session.setModelId(chat.modelId.get(), ChatModelSource.CarriedOver);
+        session.setIsolationMode("workspace");
+        session.setOption(PARENT_SESSION_OPTION_ID, chat.resource.path.slice(1));
+        session.setPermissionLevel(this._defaultPermissionLevel());
+        session.setTitle(( localize(4227, "New Chat")));
+        this._newSessions.set(session.sessionId, session);
+        (await this._createChatSession(session.resource, session)).dispose();
+        this._sessionCache.set(( session.resource.toString()), session);
+        this._invalidateGroupingCaches();
+        this._sessionGroupCache.delete(sessionId);
+        this._onDidGroupMembershipChange.fire({
+            sessionId
+        });
+        this._onDidChangeSessions.fire({
+            added: [],
+            removed: [],
+            changed: [this._chatToSession(session)]
+        });
+        return this._toChat(session);
+    }
+    _getCloudSandboxContribution() {
+        return getWorkbenchContribution(CloudSandboxAgentHostContribution.ID);
+    }
+    get _sandboxModelWaitMs() {
+        return CopilotChatSessionsProvider_1.SANDBOX_MODEL_WAIT_MS;
+    }
+    async _sendFirstChatToSandbox(session, repoNwo, options) {
+        session.setTitle(
+            (options.title || options.query.split("\n")[0]).substring(0, 100) || ( localize(4228, "New Session"))
+        );
+        session.setStatus(SessionStatus.InProgress);
+        this._sessionCache.set(( session.resource.toString()), session);
+        this._invalidateGroupingCaches();
+        const placeholder = this._chatToSession(session);
+        this._onDidChangeSessions.fire({
+            added: [placeholder],
+            removed: [],
+            changed: []
+        });
+        let provisioned;
+        const selectedModel = this._selectedCloudModel(session);
+        try {
+            provisioned = await this._getCloudSandboxContribution().provisionSession({
+                repoNwo,
+                prompt: options.query
+            }, CancellationToken.None);
+            const chat = provisioned.session.mainChat.get();
+            await this._carryModelToSandbox(provisioned, chat.resource, selectedModel);
+            const committed = await provisioned.provider.sendRequest(provisioned.session.sessionId, chat.resource, options);
+            this._publishSandboxSession(provisioned, {
+                announce: false
+            });
+            this._retirePlaceholder(session, placeholder, committed);
+            return committed;
+        } catch (error) {
+            this.logService.error(
+                `[CopilotChatSessionsProvider] Failed to start cloud sandbox session for ${repoNwo}:`,
+                error
+            );
+            if (provisioned) {
+                this._publishSandboxSession(provisioned);
+            }
+            this._sessionCache.delete(( session.resource.toString()));
+            this._invalidateGroupingCaches();
+            this._sessionGroupCache.delete(session.sessionId);
+            this._clearCurrentNewSessionIfMatch(session,  true);
+            this._onDidChangeSessions.fire({
+                added: [],
+                removed: [placeholder],
+                changed: []
+            });
+            session.dispose();
+            throw error;
+        }
+    }
+    _publishSandboxSession(provisioned, options) {
+        provisioned.provider.publishWithheldSession(AgentSession.id(provisioned.session.resource), options);
+    }
+    _selectedCloudModel(session) {
+        const selectedModelId = session.selectedModelId;
+        if (!selectedModelId) {
+            return undefined;
+        }
+        const {
+            modelOption
+        } = session.getModelOptionsSnapshot();
+        const item = modelOption?.group.items.find(i => i.id === selectedModelId);
+        const rawModelId = item?.modelMetadata?.id ?? item?.id ?? selectedModelId;
+        return {
+            rawModelId,
+            label: item?.modelMetadata?.name ?? item?.name ?? rawModelId
+        };
+    }
+    async _carryModelToSandbox(provisioned, chatResource, selected) {
+        if (!selected) {
+            return;
+        }
+        const {
+            rawModelId,
+            label
+        } = selected;
+        const sessionId = provisioned.session.sessionId;
+        const provider = provisioned.provider;
+        const modelTarget = provider.getModelsSnapshot(sessionId).modelTarget;
+        if (!modelTarget) {
+            this.logService.info(
+                `[CopilotChatSessionsProvider] Sandbox session ${sessionId} reported no model target; letting the agent host choose.`
+            );
+            this._notifySandboxModelNotApplied(label);
+            return;
+        }
+        const desiredModelId = `${modelTarget}:${rawModelId}`;
+        const store = ( new DisposableStore());
+        try {
+            const deadline = Date.now() + this._sandboxModelWaitMs;
+            for (; ; ) {
+                const resolution = provider.getModelsSnapshot(sessionId, desiredModelId).desiredModelResolution;
+                if (resolution.kind === "available") {
+                    provider.setModel(
+                        sessionId,
+                        chatResource,
+                        resolution.model.identifier,
+                        ChatModelSource.CarriedOver
+                    );
+                    return;
+                }
+                if (resolution.kind !== "pending") {
+                    this.logService.info(
+                        `[CopilotChatSessionsProvider] Sandbox session ${sessionId} does not advertise model '${rawModelId}'; letting the agent host choose.`
+                    );
+                    this._notifySandboxModelNotApplied(label);
+                    return;
+                }
+                const remaining = deadline - Date.now();
+                const published = remaining > 0 ? await raceTimeout(
+                    Event.toPromise(provider.onDidChangeModels, store).then(() => true),
+                    remaining
+                ) : undefined;
+                if (!published) {
+                    this.logService.warn(
+                        `[CopilotChatSessionsProvider] Sandbox session ${sessionId} had not published model '${rawModelId}' in time; letting the agent host choose.`
+                    );
+                    this._notifySandboxModelNotApplied(label);
+                    return;
+                }
+            }
+        } finally {
+            store.dispose();
+        }
+    }
+    _notifySandboxModelNotApplied(label) {
+        this.notificationService.warn(( localize(
+            4229,
+            "Couldn't use {0} for this session. The agent's default model will be used instead.",
+            label
+        )));
+    }
+    _retirePlaceholder(session, placeholder, committed) {
+        this._sessionCache.delete(( session.resource.toString()));
+        this._invalidateGroupingCaches();
+        this._sessionGroupCache.delete(session.sessionId);
+        this._clearCurrentNewSessionIfMatch(session);
+        this._onDidReplaceSession.fire({
+            from: placeholder,
+            to: committed
+        });
+    }
+    async sendRequest(sessionId, chatResource, options) {
+        const newSession = this._newSessions.get(sessionId);
+        if (newSession) {
+            if (!this.uriIdentityService.extUri.isEqual(newSession.mainChat.get().resource, chatResource)) {
+                throw ( new Error("Chat resource does not match the main chat of the current new session"));
+            }
+            if (newSession instanceof RemoteNewSession && newSession.useSandbox.get() && newSession.repoNwo && isCloudSandboxEnabled(this.configurationService)) {
+                return this._sendFirstChatToSandbox(newSession, newSession.repoNwo, options);
+            }
+            return this._sendFirstChat(newSession, chatResource, options);
+        }
+        const session = this._findSession(sessionId);
+        if (!session) {
+            throw ( new Error(`Session '${sessionId}' not found`));
+        }
+        if (!session.capabilities.get().supportsMultipleChats) {
+            throw ( new Error("Multiple chats per session is not supported"));
+        }
+        if (!( session.chats.get().some(
+            chat => this.uriIdentityService.extUri.isEqual(chat.resource, chatResource)
+        ))) {
+            throw ( new Error(`Chat '${( chatResource.toString())}' does not belong to session '${sessionId}'`));
+        }
+        const key = ( chatResource.toString());
+        const chatSession = this._sessionCache.get(key);
+        if (!chatSession || !(chatSession instanceof CopilotCLISession)) {
+            throw ( new Error(`Chat '${( chatResource.toString())}' not found in session '${sessionId}'`));
+        }
+        return this._sendExistingChat(sessionId, chatSession, options);
+    }
+    async _sendFirstChat(session, chatResource, options) {
+        if (session instanceof CopilotCLISession && session.initialAutomationSessionConfiguration) {
+            await this._resolveAutomationSessionMode(session);
+        }
+        const {
+            query,
+            attachedContext
+        } = options;
+        session.setTitle(
+            (options.title || query.split("\n")[0]).substring(0, 100) || ( localize(4228, "New Session"))
+        );
+        session.setStatus(SessionStatus.InProgress);
+        this._sessionCache.set(( session.resource.toString()), session);
+        this._invalidateGroupingCaches();
+        const newSession = this._chatToSession(session);
+        this._onDidChangeSessions.fire({
+            added: [newSession],
+            removed: [],
+            changed: []
+        });
+        const contribution = this.chatSessionsService.getChatSessionContribution(session.target);
+        const modeKind = session.chatMode?.kind ?? ChatModeKind.Agent;
+        const modeIsBuiltin = session.chatMode ? isBuiltinChatMode(session.chatMode) : true;
+        const modeId = modeIsBuiltin ? modeKind : "custom";
+        const rawModeInstructions = session.chatMode?.modeInstructions?.get();
+        const modeInstructions = rawModeInstructions ? {
+            name: session.chatMode.name.get(),
+            content: rawModeInstructions.content,
+            toolReferences: this.toolsService.toToolReferences(rawModeInstructions.toolReferences),
+            metadata: rawModeInstructions.metadata
+        } : undefined;
+        const permissionLevel = session.permissionLevel.get();
+        const sendOptions = {
+            location: ChatAgentLocation.Chat,
+            userSelectedModelId: session.selectedModelId,
+            userSelectedModelConfiguration: session.modelConfiguration.getModelConfigurationForRequest(session.selectedModelId),
+            modeInfo: {
+                kind: modeKind,
+                isBuiltin: modeIsBuiltin,
+                modeInstructions,
+                telemetryModeId: modeId,
+                applyCodeBlockSuggestionId: undefined,
+                permissionLevel
+            },
+            agentIdSilent: contribution?.type,
+            attachedContext,
+            hideFromTranscript: options.hideFromTranscript,
+            agentHostSessionConfig: session instanceof CopilotCLISession ? session.getAgentHostSessionConfig() : undefined
+        };
+        const ref = await this._updateChatSessionState(chatResource, session, sendOptions.modeInfo?.permissionLevel);
+        this.logService.debug(
+            `[CopilotChatSessionsProvider] Sending first chat for session ${session.sessionId} with options:`,
+            {
+                userSelectedModelId: sendOptions.userSelectedModelId
+            }
+        );
+        try {
+            const result = await this.chatService.sendRequest(chatResource, query, sendOptions);
+            if (result.kind === "rejected") {
+                this._sessionCache.delete(( session.resource.toString()));
+                this._invalidateGroupingCaches();
+                this._sessionGroupCache.delete(session.sessionId);
+                this._clearCurrentNewSessionIfMatch(session,  true);
+                this._onDidChangeSessions.fire({
+                    added: [],
+                    removed: [newSession],
+                    changed: []
+                });
+                session.dispose();
+                throw ( new Error(`[DefaultCopilotProvider] sendRequest rejected: ${result.reason}`));
+            }
+            const cts = ( new CancellationTokenSource());
+            const responseCompletePromise = result.kind === "sent" ? result.data.responseCompletePromise : undefined;
+            const responseCreatedPromise = result.kind === "sent" ? result.data.responseCreatedPromise : undefined;
+            responseCreatedPromise?.then(r => {
+                if (r?.isCanceled) {
+                    cts.cancel();
+                }
+            });
+            try {
+                const committedResource = await this._waitForCommittedSession(session.resource, responseCompletePromise, responseCreatedPromise, {
+                    deferred: session instanceof RemoteNewSession
+                });
+                this._inFlightCommits.add(( committedResource.toString()));
+                try {
+                    const committedChat = await this._waitForSessionInCache(committedResource, cts.token);
+                    this._sessionCache.delete(( session.resource.toString()));
+                    this._clearCurrentNewSessionIfMatch(session);
+                    const committedSession = this._chatToSession(committedChat);
+                    this._sessionGroupCache.delete(session.sessionId);
+                    this._onDidReplaceSession.fire({
+                        from: newSession,
+                        to: committedSession
+                    });
+                    return committedSession;
+                } finally {
+                    this._inFlightCommits.delete(( committedResource.toString()));
+                }
+            } catch (error) {
+                this._clearCurrentNewSessionIfMatch(session,  true);
+                if (error instanceof CancellationError) {
+                    session.setStatus(SessionStatus.Completed);
+                    this._onDidChangeSessions.fire({
+                        added: [],
+                        removed: [],
+                        changed: [newSession]
+                    });
+                    return newSession;
+                }
+                this._sessionCache.delete(( session.resource.toString()));
+                this._invalidateGroupingCaches();
+                this._sessionGroupCache.delete(session.sessionId);
+                this._onDidChangeSessions.fire({
+                    added: [],
+                    removed: [this._chatToSession(session)],
+                    changed: []
+                });
+                session.dispose();
+                throw error;
+            } finally {
+                cts.dispose();
+            }
+        } catch (error) {
+            this.logService.error(
+                `[CopilotChatSessionsProvider] Failed to send first chat for session ${session.sessionId}:`,
+                error
+            );
+            throw error;
+        } finally {
+            ref?.dispose();
+        }
+    }
+    async _createChatSession(resource, session, permissionLevel) {
+        await this.chatSessionsService.getOrCreateChatSession(resource, CancellationToken.None);
+        return this._updateChatSessionState(resource, session, permissionLevel);
+    }
+    async _updateChatSessionState(resource, session, permissionLevel) {
+        const modelRef = await this.chatService.acquireOrLoadSession(resource, ChatAgentLocation.Chat, CancellationToken.None);
+        if (!modelRef) {
+            return Disposable.None;
+        }
+        const model = modelRef.object;
+        if (session.selectedModelId) {
+            const languageModel = this.languageModelsService.lookupLanguageModel(session.selectedModelId);
+            if (languageModel) {
+                model.inputModel.setState({
+                    selectedModel: {
+                        identifier: session.selectedModelId,
+                        metadata: languageModel
+                    }
+                });
+            }
+        }
+        if (session.chatMode) {
+            model.inputModel.setState({
+                mode: {
+                    id: session.chatMode.id,
+                    kind: session.chatMode.kind
+                }
+            });
+        }
+        if (session.selectedOptions.size > 0) {
+            this.chatSessionsService.updateSessionOptions(resource, session.selectedOptions);
+        }
+        if (permissionLevel) {
+            model.inputModel.setState({
+                permissionLevel
+            });
+        }
+        return modelRef;
+    }
+    async _sendExistingChat(sessionId, newChatSession, options) {
+        newChatSession.setStatus(SessionStatus.InProgress);
+        const key = ( newChatSession.resource.toString());
+        this._sessionGroupCache.delete(sessionId);
+        this._onDidChangeSessions.fire({
+            added: [],
+            removed: [],
+            changed: [this._chatToSession(newChatSession)]
+        });
+        const {
+            query,
+            attachedContext
+        } = options;
+        const contribution = this.chatSessionsService.getChatSessionContribution(newChatSession.target);
+        const sendOptions = {
+            location: ChatAgentLocation.Chat,
+            userSelectedModelId: newChatSession.selectedModelId,
+            modeInfo: {
+                kind: ChatModeKind.Agent,
+                isBuiltin: true,
+                modeInstructions: undefined,
+                telemetryModeId: "agent",
+                applyCodeBlockSuggestionId: undefined,
+                permissionLevel: newChatSession.permissionLevel.get()
+            },
+            agentIdSilent: contribution?.type,
+            attachedContext,
+            hideFromTranscript: options.hideFromTranscript,
+            agentHostSessionConfig: newChatSession.getAgentHostSessionConfig()
+        };
+        const ref = await this._updateChatSessionState(newChatSession.resource, newChatSession);
+        try {
+            const result = await this.chatService.sendRequest(newChatSession.resource, query, sendOptions);
+            if (result.kind === "rejected") {
+                this._sessionCache.delete(key);
+                this._invalidateGroupingCaches();
+                throw ( new Error(`[DefaultCopilotProvider] sendRequest rejected: ${result.reason}`));
+            }
+            const responseCompletePromise = result.kind === "sent" ? result.data.responseCompletePromise : undefined;
+            const responseCreatedPromise = result.kind === "sent" ? result.data.responseCreatedPromise : undefined;
+            try {
+                const committedResource = await this._waitForCommittedSession(newChatSession.resource, responseCompletePromise, responseCreatedPromise);
+                const committedChat = await this._waitForSessionInCache(committedResource);
+                this._sessionCache.delete(key);
+                this._invalidateGroupingCaches();
+                this._clearCurrentNewSessionIfMatch(newChatSession);
+                this._sessionGroupCache.delete(sessionId);
+                this._onDidGroupMembershipChange.fire({
+                    sessionId
+                });
+                const updatedSession = this._chatToSession(committedChat);
+                this._onDidChangeSessions.fire({
+                    added: [],
+                    removed: [],
+                    changed: [updatedSession]
+                });
+                return updatedSession;
+            } catch (error) {
+                this._clearCurrentNewSessionIfMatch(newChatSession,  true);
+                if (error instanceof CancellationError) {
+                    newChatSession.setStatus(SessionStatus.Completed);
+                    this._sessionGroupCache.delete(sessionId);
+                    const updatedSession = this._chatToSession(newChatSession);
+                    this._onDidChangeSessions.fire({
+                        added: [],
+                        removed: [],
+                        changed: [updatedSession]
+                    });
+                    return updatedSession;
+                }
+                this._sessionCache.delete(key);
+                this._invalidateGroupingCaches();
+                this._sessionGroupCache.delete(sessionId);
+                newChatSession.dispose();
+                const parentChatIds = this._getChatIdsInGroup(sessionId);
+                const parentChatId = parentChatIds[0];
+                const parentChat = parentChatId ? this._sessionCache.get(this._localIdFromchatId(parentChatId)) : undefined;
+                if (parentChat) {
+                    this._onDidChangeSessions.fire({
+                        added: [],
+                        removed: [],
+                        changed: [this._chatToSession(parentChat)]
+                    });
+                }
+                throw error;
+            }
+        } finally {
+            ref.dispose();
+        }
+    }
+    async _waitForCommittedSession(untitledResource, responseCompletePromise, responseCreatedPromise, options) {
+        const timeoutMs = options?.deferred ? 5 * 60_000 : 5_000;
+        const disposables = ( new DisposableStore());
+        try {
+            const commitPromise = ( new Promise(resolve => {
+                disposables.add(this.chatSessionsService.onDidCommitSession(e => {
+                    if (isEqual(e.original, untitledResource)) {
+                        resolve(e.committed);
+                    }
+                }));
+            }));
+            if (!options?.deferred && responseCompletePromise) {
+                const committed = await Promise.race([commitPromise.then(uri => ({
+                    committed: true,
+                    uri
+                })), responseCompletePromise.then(() => ({
+                    committed: false
+                }))]);
+                if (committed.committed) {
+                    return committed.uri;
+                }
+            }
+            const candidates = [raceTimeout(commitPromise, timeoutMs).then(uri => uri ? {
+                kind: "commit",
+                uri
+            } : {
+                kind: "timeout"
+            })];
+            if (responseCreatedPromise) {
+                candidates.push(responseCreatedPromise.then(r => r?.isCanceled ? {
+                    kind: "cancelled"
+                } : ( new Promise(() => {}))));
+            }
+            const outcome = await Promise.race(candidates);
+            if (outcome.kind === "commit") {
+                return outcome.uri;
+            }
+            if (outcome.kind === "cancelled") {
+                throw ( new CancellationError());
+            }
+            const response = responseCreatedPromise ? await responseCreatedPromise : undefined;
+            if (response?.isCanceled) {
+                throw ( new CancellationError());
+            }
+            throw ( new Error("Timed out waiting for session commit"));
+        } finally {
+            disposables.dispose();
+        }
+    }
+    async _waitForSessionInCache(resource, token) {
+        const key = ( resource.toString());
+        const existing = this._sessionCache.get(key);
+        if (existing instanceof AgentSessionAdapter) {
+            return existing;
+        }
+        const disposables = ( new DisposableStore());
+        try {
+            const sessionPromise = ( new Promise(resolve => {
+                disposables.add(this.onDidChangeSessions(e => {
+                    const cached = this._sessionCache.get(key);
+                    if (cached instanceof AgentSessionAdapter) {
+                        resolve(cached);
+                    }
+                }));
+            }));
+            const result = await raceTimeout(
+                token ? raceCancellationError(sessionPromise, token) : sessionPromise,
+                30_000
+            );
+            if (!result) {
+                throw ( new Error("Timed out waiting for committed session in cache"));
+            }
+            return result;
+        } finally {
+            disposables.dispose();
+        }
+    }
+    async _browseForRepository() {
+        const allowRepositoryUrl = this._supportsLocalRepositoryActions();
+        const repository = await this.commandService.executeCommand(OPEN_REPO_COMMAND, undefined, {
+            allowRepositoryUrl
+        });
+        if (!repository) {
+            return undefined;
+        }
+        const repoId = getGitHubRepositoryId(repository);
+        if (!repoId) {
+            return allowRepositoryUrl ? this._cloneRepository(repository) : undefined;
+        }
+        const uri = ( URI.from({
+            scheme: GITHUB_REMOTE_FILE_SCHEME,
+            authority: "github",
+            path: `/${repoId}/HEAD`
+        }));
+        const folder = {
+            root: uri,
+            workingDirectory: uri,
+            name: basename(uri),
+            description: undefined,
+            gitRepository: undefined
+        };
+        return {
+            uri: ( URI.parse(`https://github.com/${repoId}`)),
+            label: this._labelFromUri(uri),
+            icon: this._iconFromUri(uri),
+            group: SESSION_WORKSPACE_GROUP_GITHUB,
+            folders: [folder],
+            requiresWorkspaceTrust: false,
+            isVirtualWorkspace: true
+        };
+    }
+    _supportsLocalRepositoryActions() {
+        return !isWeb && (this.pathService.defaultUriScheme === Schemas.file || this.pathService.defaultUriScheme === GITHUB_REMOTE_FILE_SCHEME || this.pathService.defaultUriScheme === SessionType.CopilotCloud);
+    }
+    async _cloneRepository(url) {
+        try {
+            const repositoryPath = await this.commandService.executeCommand("git.clone", url, undefined, {
+                postCloneAction: "none",
+                returnRepositoryPath: true
+            });
+            if (repositoryPath?.endsWith(".code-workspace")) {
+                this.notificationService.error(( localize(
+                    4230,
+                    "The selected clone is a workspace file. Choose the repository again to select a repository folder."
+                )));
+                return undefined;
+            }
+            return repositoryPath ? this.resolveWorkspace(URI.file(repositoryPath)) : undefined;
+        } catch (error) {
+            if (!isCancellationError(error)) {
+                this.notificationService.error(error);
+            }
+            return undefined;
+        }
+    }
+    async _browseForGitHubContext(commandId, icon, currentWorkspace) {
+        const repositoryIds = ( new Set());
+        for (const folder of currentWorkspace?.folders ?? []) {
+            const repositoryId = resolveGitHubRepositoryId(folder);
+            if (repositoryId) {
+                repositoryIds.add(repositoryId);
+            }
+        }
+        const repository = repositoryIds.size === 1 ? ( repositoryIds.values()).next().value : currentWorkspace?.folders.length === 1 && currentWorkspace.folders[0].root.scheme === Schemas.file ? currentWorkspace.folders[0].root : await this.commandService.executeCommand(OPEN_REPO_COMMAND);
+        if (!repository) {
+            return undefined;
+        }
+        const selection = await this.commandService.executeCommand(commandId, repository);
+        if (!selection) {
+            return undefined;
+        }
+        const root = ( URI.from({
+            scheme: GITHUB_REMOTE_FILE_SCHEME,
+            authority: "github",
+            path: `/${selection.repoId}/HEAD`
+        }));
+        return {
+            uri: ( URI.parse(selection.url)),
+            label: selection.label,
+            icon,
+            group: SESSION_WORKSPACE_GROUP_GITHUB,
+            folders: [{
+                root,
+                workingDirectory: root,
+                name: basename(root),
+                description: undefined,
+                gitRepository: undefined
+            }],
+            requiresWorkspaceTrust: false,
+            isVirtualWorkspace: true
+        };
+    }
+    resolveWorkspace(uri) {
+        if (uri.scheme !== Schemas.file && uri.scheme !== GITHUB_REMOTE_FILE_SCHEME) {
+            return undefined;
+        }
+        const folder = {
+            root: uri,
+            workingDirectory: uri,
+            name: basename(uri),
+            description: undefined,
+            gitRepository: uri.scheme === Schemas.file ? this._getLocalGitRepository(uri) : undefined
+        };
+        return {
+            uri: uri,
+            label: this._labelFromUri(uri),
+            description: this._descriptionFromUri(uri),
+            group: uri.scheme === GITHUB_REMOTE_FILE_SCHEME ? SESSION_WORKSPACE_GROUP_GITHUB : SESSION_WORKSPACE_GROUP_LOCAL,
+            icon: this._iconFromUri(uri),
+            folders: [folder],
+            requiresWorkspaceTrust: uri.scheme !== GITHUB_REMOTE_FILE_SCHEME,
+            isVirtualWorkspace: uri.scheme === GITHUB_REMOTE_FILE_SCHEME
+        };
+    }
+    _getLocalGitRepository(uri) {
+        const state = this._getLocalGitRepositoryState(uri);
+        const resolveRepository = () => this._resolveLocalGitRepository(uri, state);
+        return {
+            uri,
+            workTreeUri: uri,
+            baseBranchName: undefined,
+            isRepository: state.isRepository,
+            gitHubInfo: state.gitHubInfo,
+            resolveRepository,
+            resolveGitHubInfo: resolveRepository
+        };
+    }
+    _getLocalGitRepositoryState(uri) {
+        const key = this.uriIdentityService.extUri.getComparisonKey(uri);
+        let state = this._localGitRepositoryState.get(key);
+        if (state) {
+            return state;
+        }
+        if (this._localGitRepositoryState.size >= 50) {
+            const oldestKey = ( this._localGitRepositoryState.keys()).next().value;
+            if (oldestKey !== undefined) {
+                this._localGitRepositoryState.delete(oldestKey);
+                this._localGitRepositoryResolutionStarted.delete(oldestKey);
+            }
+        }
+        state = {
+            isRepository: observableValue(this, false),
+            gitHubInfo: observableValue(this, undefined)
+        };
+        this._localGitRepositoryState.set(key, state);
+        return state;
+    }
+    _resolveLocalGitRepository(uri, state) {
+        const key = this.uriIdentityService.extUri.getComparisonKey(uri);
+        if (( this._localGitRepositoryResolutionStarted.has(key))) {
+            return;
+        }
+        this._localGitRepositoryResolutionStarted.add(key);
+        void resolveGitRepositoryFromGitConfig(this.fileService, uri).then(repositoryInfo => {
+            if (this._localGitRepositoryState.get(key) !== state) {
+                this._localGitRepositoryResolutionStarted.delete(key);
+                return;
+            }
+            if (!repositoryInfo) {
+                this._localGitRepositoryResolutionStarted.delete(key);
+                return;
+            }
+            const nextGitHubInfo = repositoryInfo.gitHub ? {
+                owner: repositoryInfo.gitHub.owner,
+                repo: repositoryInfo.gitHub.repo
+            } : undefined;
+            if (!state.isRepository.get() || !gitHubInfoEqual(state.gitHubInfo.get(), nextGitHubInfo)) {
+                transaction(tx => {
+                    state.isRepository.set(true, tx);
+                    state.gitHubInfo.set(nextGitHubInfo, tx);
+                });
+                this._onDidChangeSessionTypes.fire();
+            }
+            if (!repositoryInfo.gitHub) {
+                this._localGitRepositoryResolutionStarted.delete(key);
+            }
+        }, error => {
+            this._localGitRepositoryResolutionStarted.delete(key);
+            this.logService.warn(`Failed to resolve Git repository metadata for '${( uri.toString())}'.`, error);
+        });
+    }
+    _labelFromUri(uri) {
+        return githubRemoteRepoLabel(uri) ?? basename(uri);
+    }
+    _descriptionFromUri(uri) {
+        if (uri.scheme === GITHUB_REMOTE_FILE_SCHEME) {
+            const parts = uri.path.substring(1).split("/");
+            return parts.length >= 2 ? parts[0] : undefined;
+        }
+        return this.labelService.getUriLabel(dirname(uri), {
+            relative: false
+        });
+    }
+    _iconFromUri(uri) {
+        if (uri.scheme === GITHUB_REMOTE_FILE_SCHEME) {
+            return Codicon.repo;
+        }
+        return Codicon.folder;
+    }
+    _ensureSessionCache() {
+        if (this._sessionCache.size > 0) {
+            return;
+        }
+        this._refreshSessionCache();
+    }
+    _invalidateGroupingCaches() {
+        this._chatByRawSessionIdCache = undefined;
+        this._groupIdByChatIdCache = undefined;
+        this._chatIdsByGroupIdCache = undefined;
+    }
+    _ensureGroupingCaches() {
+        if (this._chatByRawSessionIdCache && this._groupIdByChatIdCache && this._chatIdsByGroupIdCache) {
+            return;
+        }
+        const chats = Array.from(( this._sessionCache.values()));
+        const chatByRawSessionId = ( new Map());
+        for (const chat of chats) {
+            chatByRawSessionId.set(chat.resource.path.slice(1), chat);
+        }
+        const groupIdByChatId = ( new Map());
+        const chatsByGroupId = ( new Map());
+        const resolveGroupId = chat => {
+            const cachedGroupId = groupIdByChatId.get(chat.sessionId);
+            if (cachedGroupId) {
+                return cachedGroupId;
+            }
+            const trail = [];
+            const seen = ( new Set());
+            let current = chat;
+            for (let depth = 0; depth < 100; depth++) {
+                const currentCachedGroupId = groupIdByChatId.get(current.sessionId);
+                if (currentCachedGroupId) {
+                    for (const trailChat of trail) {
+                        groupIdByChatId.set(trailChat.sessionId, currentCachedGroupId);
+                    }
+                    return currentCachedGroupId;
+                }
+                if (( seen.has(current.sessionId))) {
+                    for (const trailChat of trail) {
+                        groupIdByChatId.set(trailChat.sessionId, current.sessionId);
+                    }
+                    return current.sessionId;
+                }
+                trail.push(current);
+                seen.add(current.sessionId);
+                const parentRawSessionId = this._getDirectParentRawSessionId(current);
+                if (!parentRawSessionId) {
+                    for (const trailChat of trail) {
+                        groupIdByChatId.set(trailChat.sessionId, current.sessionId);
+                    }
+                    return current.sessionId;
+                }
+                const parentChat = chatByRawSessionId.get(parentRawSessionId);
+                if (!parentChat) {
+                    const syntheticGroupId = this._getSyntheticGroupId(parentRawSessionId);
+                    for (const trailChat of trail) {
+                        groupIdByChatId.set(trailChat.sessionId, syntheticGroupId);
+                    }
+                    return syntheticGroupId;
+                }
+                current = parentChat;
+            }
+            groupIdByChatId.set(chat.sessionId, chat.sessionId);
+            return chat.sessionId;
+        };
+        for (const chat of chats) {
+            const groupId = resolveGroupId(chat);
+            const groupChats = chatsByGroupId.get(groupId) ?? [];
+            groupChats.push(chat);
+            chatsByGroupId.set(groupId, groupChats);
+        }
+        const chatIdsByGroupId = ( new Map());
+        for (const [groupId, groupChats] of chatsByGroupId) {
+            groupChats.sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+            chatIdsByGroupId.set(groupId, groupChats.map(chat => chat.sessionId));
+        }
+        this._chatByRawSessionIdCache = chatByRawSessionId;
+        this._groupIdByChatIdCache = groupIdByChatId;
+        this._chatIdsByGroupIdCache = chatIdsByGroupId;
+    }
+    _cleanupTempSession(sessionId) {
+        const chatSession = this._findChatSession(sessionId);
+        if (!chatSession) {
+            return;
+        }
+        const key = ( chatSession.resource.toString());
+        this._sessionCache.delete(key);
+        this._invalidateGroupingCaches();
+        this._sessionGroupCache.delete(chatSession.sessionId);
+        if (( this._newSessions.has(chatSession.sessionId))) {
+            this._newSessions.deleteAndLeak(chatSession.sessionId);
+        }
+        const removedSession = this._chatToSession(chatSession);
+        this._sessionGroupCache.delete(chatSession.sessionId);
+        this._onDidChangeSessions.fire({
+            added: [],
+            removed: [removedSession],
+            changed: []
+        });
+        if (isNewSession(chatSession)) {
+            chatSession.dispose();
+        }
+    }
+    _refreshSessionCache() {
+        const currentKeys = ( new Set());
+        const addedData = [];
+        const changedData = [];
+        const sessionsToMarkUnread = [];
+        let cacheChanged = false;
+        for (const session of this.agentSessionsService.model.sessions) {
+            if (session.providerType !== AgentSessionProviders.Background && session.providerType !== AgentSessionProviders.Cloud) {
+                continue;
+            }
+            const key = ( session.resource.toString());
+            currentKeys.add(key);
+            const existing = this._sessionCache.get(key);
+            if (existing) {
+                const previousStatus = existing.status.get();
+                if (existing.update(session)) {
+                    changedData.push(existing);
+                }
+                const currentStatus = existing.status.get();
+                if (previousStatus === SessionStatus.InProgress && currentStatus !== SessionStatus.InProgress && currentStatus !== SessionStatus.Untitled && existing.isRead.get()) {
+                    sessionsToMarkUnread.push(session);
+                }
+            } else {
+                const adapter = ( new AgentSessionAdapter(session, this.id, this.gitHubService, this.pullRequestIconCache));
+                this._sessionCache.set(key, adapter);
+                addedData.push(adapter);
+                cacheChanged = true;
+            }
+        }
+        const removedData = [];
+        for (const [key, adapter] of this._sessionCache) {
+            if (!( currentKeys.has(key)) && adapter instanceof AgentSessionAdapter && !( this._inFlightCommits.has(key))) {
+                removedData.push(adapter);
+                cacheChanged = true;
+            }
+        }
+        let removedGroupIds;
+        if (removedData.length > 0 && this._isMultiChatEnabled()) {
+            removedGroupIds = ( new Map());
+            for (const removed of removedData) {
+                removedGroupIds.set(removed, this._getGroupIdForChat(removed));
+            }
+        }
+        for (const removed of removedData) {
+            this._sessionCache.delete(( removed.resource.toString()));
+        }
+        if (cacheChanged) {
+            this._invalidateGroupingCaches();
+        }
+        if (addedData.length > 0 || removedData.length > 0 || changedData.length > 0) {
+            if (this._isMultiChatEnabled()) {
+                this._refreshSessionCacheMultiChat(addedData, removedData, changedData, removedGroupIds);
+            } else {
+                this._onDidChangeSessions.fire({
+                    added: addedData.map(d => this._chatToSession(d)),
+                    removed: removedData.map(d => this._chatToSession(d)),
+                    changed: changedData.map(d => this._chatToSession(d))
+                });
+            }
+        }
+        for (const session of sessionsToMarkUnread) {
+            session.setRead(false);
+        }
+    }
+    _refreshSessionCacheMultiChat(addedData, removedData, changedData, removedGroupIds) {
+        const trulyRemovedSessions = [];
+        const changedSessionIds = ( new Set());
+        for (const removed of removedData) {
+            const sessionId = removedGroupIds.get(removed);
+            const remainingChatIds = this._getChatIdsInGroup(sessionId);
+            if (remainingChatIds.length > 0) {
+                this._sessionGroupCache.delete(sessionId);
+                this._onDidGroupMembershipChange.fire({
+                    sessionId
+                });
+                if (!( changedSessionIds.has(sessionId))) {
+                    changedSessionIds.add(sessionId);
+                    const primaryChat = this._sessionCache.get(this._localIdFromchatId(remainingChatIds[0]));
+                    if (primaryChat) {
+                        changedData.push(primaryChat);
+                    }
+                }
+            } else {
+                this._sessionGroupCache.delete(sessionId);
+                trulyRemovedSessions.push({
+                    chat: removed,
+                    groupId: sessionId
+                });
+            }
+        }
+        const newSessions = [];
+        for (const added of addedData) {
+            const groupId = this._getGroupIdForChat(added);
+            const groupChatIds = this._getChatIdsInGroup(groupId);
+            if (groupChatIds.length > 1) {
+                this._sessionGroupCache.delete(groupId);
+                this._onDidGroupMembershipChange.fire({
+                    sessionId: groupId
+                });
+                if (!( changedSessionIds.has(groupId))) {
+                    changedSessionIds.add(groupId);
+                    changedData.push(added);
+                }
+            } else {
+                newSessions.push(added);
+            }
+        }
+        const seenChanged = ( new Set());
+        const deduplicatedChanged = [];
+        for (const d of changedData) {
+            const groupId = this._getGroupIdForChat(d);
+            if (!( seenChanged.has(groupId))) {
+                seenChanged.add(groupId);
+                deduplicatedChanged.push(d);
+            }
+        }
+        this._onDidChangeSessions.fire({
+            added: newSessions.map(d => this._chatToSession(d)),
+            removed: trulyRemovedSessions.map((
+                {
+                    chat,
+                    groupId
+                }
+            ) => {
+                const session = this._sessionGroupCache.get(groupId);
+                this._sessionGroupCache.delete(groupId);
+                return session ?? this._chatToSession(chat);
+            }),
+            changed: deduplicatedChanged.map(d => this._chatToSession(d))
+        });
+    }
+    _findChatSession(chatId) {
+        const directMatch = this._sessionCache.get(this._localIdFromchatId(chatId));
+        if (directMatch) {
+            return directMatch;
+        }
+        const groupChatIds = this._getChatIdsInGroup(chatId);
+        const firstChatId = groupChatIds[0];
+        return firstChatId ? this._sessionCache.get(this._localIdFromchatId(firstChatId)) : undefined;
+    }
+    _findAgentSession(chatId) {
+        const adapter = this._findChatSession(chatId);
+        if (!adapter) {
+            return undefined;
+        }
+        return this.agentSessionsService.getSession(adapter.resource);
+    }
+    _getGroupIdForChat(chat) {
+        this._ensureGroupingCaches();
+        return this._groupIdByChatIdCache?.get(chat.sessionId) ?? chat.sessionId;
+    }
+    _getChatIdsInGroup(groupId) {
+        this._ensureGroupingCaches();
+        return this._chatIdsByGroupIdCache?.get(groupId) ?? [];
+    }
+    _getDirectParentRawSessionId(chat) {
+        const agentSession = this.agentSessionsService.getSession(chat.resource);
+        const sessionParentId = agentSession?.metadata?.sessionParentId;
+        if (typeof sessionParentId === "string" && sessionParentId.length > 0) {
+            return sessionParentId;
+        }
+        if (isNewSession(chat)) {
+            const parentOption = chat.selectedOptions.get(PARENT_SESSION_OPTION_ID);
+            if (parentOption?.id) {
+                return parentOption.id;
+            }
+        }
+        return undefined;
+    }
+    _getSyntheticGroupId(rawSessionId) {
+        return `${this.id}:group:${rawSessionId}`;
+    }
+    _findSession(sessionId) {
+        return this._sessionGroupCache.get(sessionId);
+    }
+    _localIdFromchatId(chatId) {
+        const prefix = `${this.id}:`;
+        return chatId.startsWith(prefix) ? chatId.substring(prefix.length) : chatId;
+    }
+    _getGroupMembershipSignal(sessionId) {
+        let signal = this._groupMembershipSignals.get(sessionId);
+        if (!signal) {
+            signal = observableSignal(this);
+            this._groupMembershipSignals.set(sessionId, signal);
+        }
+        return signal;
+    }
+    _chatArraysEqual(a, b) {
+        if (a === b) {
+            return true;
+        }
+        if (!a || !b || a.length !== b.length) {
+            return false;
+        }
+        return a.every(
+            (chat, i) => this.uriIdentityService.extUri.isEqual(chat.resource, b[i].resource)
+        );
+    }
+    _chatToSession(chat) {
+        if (!this._isMultiChatEnabled()) {
+            return this._chatToSingleChatSession(chat);
+        }
+        const sessionId = this._getGroupIdForChat(chat);
+        const cached = this._sessionGroupCache.get(sessionId);
+        if (cached) {
+            return cached;
+        }
+        const mainChatIds = this._getChatIdsInGroup(sessionId);
+        const firstChatId = mainChatIds[0];
+        const primaryChat = firstChatId ? this._sessionCache.get(this._localIdFromchatId(firstChatId)) ?? chat : chat;
+        const mainChat = primaryChat.mainChat;
+        const membershipSignal = this._getGroupMembershipSignal(sessionId);
+        const groupChatsObs = derivedOpts({
+            owner: this,
+            equalsFn: (a, b) => this._chatArraysEqual(a, b)
+        }, reader => {
+            membershipSignal.read(reader);
+            const chatIds = this._getChatIdsInGroup(sessionId);
+            if (chatIds.length === 0) {
+                return undefined;
+            }
+            const resolved = [];
+            for (const id of chatIds) {
+                const c = this._sessionCache.get(this._localIdFromchatId(id));
+                if (c) {
+                    resolved.push(c);
+                }
+            }
+            if (resolved.length === 0) {
+                return undefined;
+            }
+            return resolved.map(c => this._toChat(c));
+        });
+        const chatsObs = derived(reader => {
+            const groupChats = groupChatsObs.read(reader);
+            return groupChats ?? [mainChat.read(reader)];
+        });
+        const session = {
+            sessionId,
+            resource: primaryChat.resource,
+            providerId: primaryChat.providerId,
+            sessionType: primaryChat.sessionType,
+            icon: primaryChat.icon,
+            createdAt: primaryChat.createdAt,
+            workspace: primaryChat.workspace,
+            hasGitRepository: primaryChat.hasGitRepository,
+            title: primaryChat.title,
+            updatedAt: chatsObs.map((chats, reader) => this._latestDate(chats, c => c.updatedAt.read(reader))),
+            status: chatsObs.map((chats, reader) => this._aggregateStatus(chats, reader)),
+            changesets: this._createChangesets(primaryChat.sessionType, primaryChat.workspace, chatsObs),
+            changesSummary: primaryChat.changesSummary,
+            changes: primaryChat.changes,
+            modelId: primaryChat.modelId,
+            mode: primaryChat.mode,
+            loading: primaryChat.loading,
+            isArchived: primaryChat.isArchived,
+            isRead: chatsObs.map((chats, reader) => chats.every(c => c.isRead.read(reader))),
+            description: primaryChat.description,
+            lastTurnEnd: chatsObs.map(
+                (chats, reader) => this._latestDate(chats, c => c.lastTurnEnd.read(reader))
+            ),
+            chats: chatsObs,
+            mainChat,
+            capabilities: constObservable({
+                supportsMultipleChats: primaryChat.sessionType === CopilotCLISessionType.id && this._isMultiChatEnabled(),
+                supportsRename: this._sessionTypeSupportsRename(primaryChat.sessionType),
+                supportsDelete: this._sessionTypeSupportsDelete(primaryChat.sessionType),
+                runsWorktreeCreatedTasks: primaryChat.sessionType === CopilotCloudSessionType.id
+            })
+        };
+        this._sessionGroupCache.set(sessionId, session);
+        return session;
+    }
+    _chatToSingleChatSession(chat) {
+        const mainChat = chat.mainChat;
+        const chatsObs = mainChat.map(c => [c]);
+        const changesets = this._createChangesets(chat.sessionType, chat.workspace, chatsObs);
+        return {
+            sessionId: chat.sessionId,
+            resource: chat.resource,
+            providerId: chat.providerId,
+            sessionType: chat.sessionType,
+            icon: chat.icon,
+            createdAt: chat.createdAt,
+            workspace: chat.workspace,
+            hasGitRepository: chat.hasGitRepository,
+            title: chat.title,
+            updatedAt: chat.updatedAt,
+            status: chat.status,
+            changesets,
+            changesSummary: chat.changesSummary,
+            changes: chat.changes,
+            modelId: chat.modelId,
+            mode: chat.mode,
+            loading: chat.loading,
+            isArchived: chat.isArchived,
+            isRead: chat.isRead,
+            description: chat.description,
+            lastTurnEnd: chat.lastTurnEnd,
+            chats: chatsObs,
+            mainChat,
+            capabilities: constObservable({
+                supportsMultipleChats: false,
+                supportsRename: this._sessionTypeSupportsRename(chat.sessionType),
+                supportsDelete: this._sessionTypeSupportsDelete(chat.sessionType),
+                runsWorktreeCreatedTasks: chat.sessionType === CopilotCloudSessionType.id
+            })
+        };
+    }
+    _sessionTypeSupportsRename(sessionType) {
+        return sessionType === CopilotCLISessionType.id;
+    }
+    _sessionTypeSupportsDelete(sessionType) {
+        return sessionType === CopilotCLISessionType.id;
+    }
+    _toChat(chat, resource, interactivity = ChatInteractivity.Full) {
+        return {
+            resource: resource ?? chat.resource,
+            createdAt: chat.createdAt,
+            title: chat.title,
+            updatedAt: chat.updatedAt,
+            status: chat.status,
+            changes: chat.changes,
+            checkpoints: chat.checkpoints,
+            modelId: chat.modelId,
+            modelSource: chat.modelSource,
+            mode: chat.mode,
+            isArchived: chat.isArchived,
+            isRead: chat.isRead,
+            interactivity: constObservable(interactivity),
+            description: chat.description,
+            lastTurnEnd: chat.lastTurnEnd
+        };
+    }
+    _createChangesets(sessionType, workspaceObs, chatsObs) {
+        return createChangesets(sessionType, workspaceObs, chatsObs, this.instantiationService);
+    }
+    _latestDate(chats, getter) {
+        let latest;
+        for (const chat of chats) {
+            const d = getter(chat);
+            if (d && (!latest || d > latest)) {
+                latest = d;
+            }
+        }
+        return latest;
+    }
+    _aggregateStatus(chats, reader) {
+        for (const c of chats) {
+            if (c.status.read(reader) === SessionStatus.NeedsInput) {
+                return SessionStatus.NeedsInput;
+            }
+        }
+        for (const c of chats) {
+            if (c.status.read(reader) === SessionStatus.InProgress) {
+                return SessionStatus.InProgress;
+            }
+        }
+        return chats[0].status.read(reader);
+    }
+    _isMultiChatEnabled() {
+        return this._multiChatEnabled;
+    }
+};
+CopilotChatSessionsProvider = CopilotChatSessionsProvider_1 = ( __decorate([( __param(0, IAgentSessionsService)), ( __param(1, IChatService)), ( __param(2, IChatSessionsService)), ( __param(3, IDialogService)), ( __param(4, ICommandService)), ( __param(5, IInstantiationService)), ( __param(6, ILanguageModelsService)), ( __param(7, ILanguageModelToolsService)), ( __param(8, IConfigurationService)), ( __param(9, IAgentHostEnablementService)), ( __param(10, ILogService)), ( __param(11, INotificationService)), ( __param(12, IGitHubService)), ( __param(13, IPullRequestIconCache)), ( __param(14, ILabelService)), ( __param(15, IChatModeService)), ( __param(16, IUriIdentityService)), ( __param(17, IFileService)), ( __param(18, IPathService))], CopilotChatSessionsProvider));
+
+export { COPILOT_MULTI_CHAT_SETTING, COPILOT_PROVIDER_ID, CopilotChatSessionsProvider, CopilotCloudSessionType, RemoteNewSession };