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

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

@@ -0,0 +1,2444 @@
+
+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 { raceCancellationError, raceTimeout } 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, toDisposable, 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 { deepClone } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
+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 { 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 { parseGitHubIssueUrl, getGitHubRepositoryId } from '@codingame/monaco-vscode-api/vscode/vs/platform/github/common/githubUrls';
+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, sessionFileChangesEqual, toSessionId, GITHUB_REMOTE_FILE_SCHEME, sessionWorkspaceEqual, gitHubInfoEqual, SessionArtifactKind, SESSION_WORKSPACE_GROUP_GITHUB, SESSION_WORKSPACE_GROUP_LOCAL, ChatModelSource } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
+import { linkKey } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/sessionLinks';
+import { getSessionApplication } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/sessionApplication';
+import { ChatConfiguration, isChatPermissionLevel, ChatPermissionLevel, ChatModeKind, ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { isEqual, basename, 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 { cancelOnDispose, 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 { COPILOT_VENDOR_ID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels';
+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 { 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 { SESSION_META_WORKSPACELESS_KEY } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
+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 { arrayEquals, structuralEquals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/equals';
+import { createChangesets } from './copilotChatSessionsChangesets.js';
+import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
+import { isCloudSandboxEnabled, CloudSandboxEnabledSettingId } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/cloudSandboxAgentHost';
+import { RemoteAgentHostsEnabledSettingId } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService';
+import { getWorkbenchContribution } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { CLOUD_SANDBOX_CREATION_PROVIDER_ID, 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 '@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService';
+import { RepositoryPicker } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/repositoryPicker';
+import { ChatAIDisabledSettingId } from '@codingame/monaco-vscode-api/vscode/vs/platform/chat/common/chatSettings';
+import { CloudSandboxModels } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/remoteAgentHost/cloudSandboxModels';
+import { validateSessionConfigWrite } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/sessionConfigProperties';
+import { createCloudSandboxSessionConfig } from './cloudSandboxSessionConfig.js';
+import { CloudAutomationStore } from './cloudAutomationStore.js';
+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 { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/transaction';
+import { IPathService } from '@codingame/monaco-vscode-api/vscode/vs/platform/path/common/pathService.service';
+import { observableValueOpts } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValueOpts';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+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';
+
+var CopilotChatSessionsProvider_1;
+const CopilotCloudSessionType = {
+    id: "copilot-cloud-agent",
+    label: ( localize(5066, "Cloud")),
+    icon: Codicon.cloud,
+    authRequirement: SessionTypeAuthRequirement.GitHub
+};
+const CopilotSandboxSessionType = {
+    id: "copilot-cloud-sandbox",
+    label: ( localize(5067, "Copilot")),
+    icon: Codicon.copilot,
+    authRequirement: SessionTypeAuthRequirement.GitHub
+};
+const STORAGE_KEY_CREATED_BY_SESSIONS = "sessions.copilotChat.createdBySessions";
+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";
+function isChangesSummary(changes) {
+    return !!changes && !Array.isArray(changes);
+}
+function buildChatFromSession(chat) {
+    return {
+        resource: chat.resource,
+        createdAt: chat.createdAt,
+        workspace: chat.workspace,
+        title: chat.title,
+        updatedAt: chat.updatedAt,
+        status: chat.status,
+        changes: chat.changes,
+        changesets: constObservable(undefined),
+        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);
+}
+function sessionArtifactsEqual(a, b) {
+    return arrayEquals(
+        a,
+        b,
+        (left, right) => left.id === right.id && left.kind === right.kind && left.label === right.label && left.isArtifact === right.isArtifact && isEqual(left.link, right.link) && isEqual(left.uri, right.uri) && left.commitHash === right.commitHash && left.isGitHub === right.isGitHub
+    );
+}
+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 query() {
+        return this._query;
+    }
+    get attachedContext() {
+        return this._attachedContext;
+    }
+    setCreatedBySession(reference) {
+        this.createdBySession.set(reference, undefined);
+    }
+    get disabled() {
+        return !this.isQuickChat.get() && !this._repoUri && !( this.selectedOptions.has("repositories"));
+    }
+    constructor(
+        resource,
+        sessionWorkspace,
+        target,
+        providerId,
+        initialAutomationSessionConfiguration,
+        isAutomationDraft,
+        chatSessionsService,
+        contextKeyService,
+        languageModelsService
+    ) {
+        super();
+        this.resource = resource;
+        this.sessionWorkspace = sessionWorkspace;
+        this.target = target;
+        this.initialAutomationSessionConfiguration = initialAutomationSessionConfiguration;
+        this.isAutomationDraft = isAutomationDraft;
+        this.chatSessionsService = chatSessionsService;
+        this.contextKeyService = contextKeyService;
+        this.application = constObservable(getSessionApplication("vscode"));
+        this.lifetimeToken = cancelOnDispose(this._store);
+        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._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.preparationProgress = observableValue(this, undefined);
+        this.isNewSessionRequestInProgress = this.preparationProgress.map(progress => !!progress);
+        this._preparationCts = this._register(( new MutableDisposable()));
+        this._preparationActivities = 0;
+        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._onDidChangeOptionGroups = this._register(( new Emitter()));
+        this.onDidChangeOptionGroups = this._onDidChangeOptionGroups.event;
+        this.selectedOptions = ( new Map());
+        this.createdBySession = observableValue(this, undefined);
+        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.isQuickChat = constObservable(sessionWorkspace === undefined);
+        this.icon = target === CopilotSandboxSessionType.id ? CopilotSandboxSessionType.icon : CopilotCloudSessionType.icon;
+        this.createdAt = ( new Date());
+        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));
+    }
+    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);
+    }
+    startPreparation() {
+        if (!this._preparationCts.value) {
+            this._preparationCts.value = ( new CancellationTokenSource(this.lifetimeToken));
+            this.reportPreparationProgress(( localize(5068, "Setting up cloud container")));
+        }
+        this._preparationActivities++;
+        const token = this._preparationCts.value.token;
+        const activity = toDisposable(() => {
+            if (--this._preparationActivities === 0) {
+                this.clearPreparation();
+            }
+        });
+        return {
+            object: token,
+            dispose: () => activity.dispose()
+        };
+    }
+    reportPreparationProgress(message) {
+        const source = this._preparationCts.value;
+        if (source && !source.token.isCancellationRequested && this.preparationProgress.get()?.message !== message) {
+            this.preparationProgress.set({
+                message,
+                cancel: () => source.cancel()
+            }, undefined);
+        }
+    }
+    clearPreparation() {
+        this.preparationProgress.set(undefined, undefined);
+        this._preparationCts.clear();
+    }
+    setArchived(archived) {
+        this._isArchived.set(archived, undefined);
+    }
+    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(6, IChatSessionsService)), ( __param(7, IContextKeyService)), ( __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, _logService) {
+        this._gitHubService = _gitHubService;
+        this._pullRequestIconCache = _pullRequestIconCache;
+        this._logService = _logService;
+        this._modelSource = observableValue("agentSessionModelSource", undefined);
+        this.modelSource = this._modelSource;
+        this._pullRequestNumberCache = ( new Map());
+        this.sessionId = toSessionId(providerId, session.resource);
+        this.resource = session.resource;
+        this.providerId = providerId;
+        this.sessionType = session.providerType;
+        this.application = observableValueOpts({
+            owner: this,
+            equalsFn: structuralEquals
+        }, getSessionApplication(
+            typeof session.metadata?.event_type === "string" && session.metadata.event_type ? session.metadata.event_type : this._extractIsExternal(session) ? "github/autopilot" : "vscode"
+        ));
+        this.icon = CopilotCloudSessionType.icon;
+        this.createdAt = ( new Date(session.timing.created));
+        const artifacts = this._extractIssueArtifacts(session);
+        this._artifacts = observableValueOpts({
+            owner: this,
+            equalsFn: sessionArtifactsEqual
+        }, artifacts);
+        this.artifacts = this._artifacts;
+        this._baseGitHubInfo = observableValue(this, this._extractGitHubInfo(session, artifacts));
+        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._isExternal = observableValue(this, this._extractIsExternal(session));
+        this.isExternal = this._isExternal;
+        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));
+    }
+    setModelId(modelId, source) {
+        transaction(tx => {
+            this._modelSource.set(modelId ? source : undefined, tx);
+            this._modelId.set(modelId, tx);
+        });
+    }
+    update(session) {
+        let changed = false;
+        transaction(tx => {
+            const artifacts = this._extractIssueArtifacts(session);
+            const gitHubInfo = this._extractGitHubInfo(session, artifacts);
+            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._isExternal, this._extractIsExternal(session), tx) || changed;
+            if (typeof session.metadata?.event_type === "string" && session.metadata.event_type) {
+                changed = setIfChanged(
+                    this.application,
+                    getSessionApplication(session.metadata.event_type),
+                    tx,
+                    structuralEquals
+                ) || 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._artifacts, artifacts, tx, sessionArtifactsEqual) || 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;
+    }
+    _extractDescription(session) {
+        if (!session.description) {
+            return undefined;
+        }
+        return typeof session.description === "string" ? ( new MarkdownString(session.description)) : session.description;
+    }
+    _extractIsExternal(session) {
+        return session.providerType === AgentSessionProviders.Cloud && session.metadata?.external === true;
+    }
+    _extractIssueArtifacts(session) {
+        const linkedIssues = session.metadata?.linkedIssues;
+        if (linkedIssues === undefined) {
+            return [];
+        }
+        if (!Array.isArray(linkedIssues)) {
+            this._logService.warn("Ignoring invalid linked issues metadata for a cloud session.");
+            return [];
+        }
+        const artifacts = [];
+        const seen = ( new Set());
+        const issues = linkedIssues;
+        for (const issue of issues) {
+            if (!issue || typeof issue !== "object" || typeof issue.url !== "string" || typeof issue.title !== "string") {
+                this._logService.warn("Ignoring invalid linked issue metadata for a cloud session.");
+                continue;
+            }
+            let link;
+            try {
+                link = ( URI.parse(issue.url, true));
+            } catch (error) {
+                this._logService.warn("Ignoring an invalid linked issue URL for a cloud session.", error);
+                continue;
+            }
+            if (link.scheme !== Schemas.https || !link.authority || !/^\/[\w.-]+\/[\w.-]+\/issues\/[1-9]\d*\/?$/.test(link.path)) {
+                this._logService.warn("Ignoring an invalid linked issue URL for a cloud session.");
+                continue;
+            }
+            const key = linkKey(issue.url);
+            if (( seen.has(key))) {
+                continue;
+            }
+            seen.add(key);
+            artifacts.push({
+                id: `linked-issue:${key}`,
+                kind: SessionArtifactKind.Issue,
+                label: issue.title || issue.url,
+                isArtifact: true,
+                link,
+                isGitHub: true
+            });
+        }
+        return artifacts;
+    }
+    _extractGitHubInfo(session, artifacts) {
+        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;
+        }
+        const issues = [];
+        for (const artifact of artifacts) {
+            const issue = artifact.link && parseGitHubIssueUrl(( artifact.link.toString(true)));
+            if (issue && artifact.link) {
+                issues.push({
+                    ...issue,
+                    uri: artifact.link,
+                    title: artifact.label
+                });
+            }
+        }
+        const issueInfo = issues.length ? {
+            issues
+        } : {};
+        if (!pullRequestUri || !pullRequestIdentity) {
+            return {
+                owner,
+                repo,
+                ...issueInfo
+            };
+        }
+        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,
+            ...issueInfo,
+            pullRequest: {
+                number: pullRequestIdentity.number,
+                uri: pullRequestUri,
+                icon,
+                baseRefOid,
+                headRefOid
+            }
+        };
+    }
+    _extractPullRequestBranch(session) {
+        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]
+                };
+            }
+        }
+        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 = this._extractRepositoryUri(session);
+        const repoUriResolved = repoUri ?? ( URI.parse("unknown:///"));
+        const gitRepository = {
+            uri: repoUriResolved,
+            workTreeUri: undefined,
+            isRepository: constObservable(repoUri !== undefined),
+            baseBranchName: undefined,
+            gitHubInfo: this.gitHubInfo
+        };
+        const folder = {
+            root: repoUriResolved,
+            workingDirectory: repoUriResolved,
+            name: basename(repoUriResolved),
+            description: undefined,
+            gitRepository
+        };
+        return {
+            uri: repoUriResolved,
+            label: githubRemoteRepoLabel(repoUriResolved) ?? getRepositoryName(session) ?? basename(repoUriResolved),
+            icon: repoUri ? Codicon.repo : Codicon.folder,
+            group: repoUri ? SESSION_WORKSPACE_GROUP_GITHUB : SESSION_WORKSPACE_GROUP_LOCAL,
+            folders: [folder],
+            requiresWorkspaceTrust: false,
+            isVirtualWorkspace: true
+        };
+    }
+    _extractRepositoryUri(session) {
+        const metadata = session.metadata;
+        if (typeof metadata?.owner !== "string" || typeof metadata.name !== "string") {
+            return undefined;
+        }
+        const branch = typeof metadata.branch === "string" ? metadata.branch : "HEAD";
+        return ( URI.from({
+            scheme: GITHUB_REMOTE_FILE_SCHEME,
+            authority: "github",
+            path: `/${metadata.owner}/${metadata.name}/${encodeURIComponent(branch)}`
+        }));
+    }
+}
+let CopilotChatSessionsProvider = class CopilotChatSessionsProvider extends Disposable {
+    static {
+        CopilotChatSessionsProvider_1 = this;
+    }
+    static {
+        this.SANDBOX_MODEL_WAIT_MS = 30_000;
+    }
+    get id() {
+        return this.providerMode === "sandbox" ? CLOUD_SANDBOX_CREATION_PROVIDER_ID : COPILOT_PROVIDER_ID;
+    }
+    get label() {
+        return this.providerMode === "sandbox" ? ( localize(5069, "GitHub Sandboxes")) : ( localize(5070, "Copilot Chat"));
+    }
+    get sessionTypes() {
+        return this.providerMode === "sandbox" ? [CopilotSandboxSessionType] : [CopilotCloudSessionType];
+    }
+    get supportsLocalWorkspaces() {
+        return this.providerMode !== "sandbox";
+    }
+    get supportsAutomationSessionConfiguration() {
+        return this.providerMode === "default" && this.automations?.enabled.get() === true;
+    }
+    get supportsQuickChats() {
+        return isCloudSandboxEnabled(this.configurationService) && !this.configurationService.getValue(ChatAIDisabledSettingId);
+    }
+    constructor(
+        providerMode,
+        agentSessionsService,
+        chatService,
+        chatSessionsService,
+        commandService,
+        instantiationService,
+        languageModelsService,
+        configurationService,
+        logService,
+        notificationService,
+        gitHubService,
+        pullRequestIconCache,
+        labelService,
+        uriIdentityService,
+        fileService,
+        pathService,
+        storageService
+    ) {
+        super();
+        this.providerMode = providerMode;
+        this.agentSessionsService = agentSessionsService;
+        this.chatService = chatService;
+        this.chatSessionsService = chatSessionsService;
+        this.commandService = commandService;
+        this.instantiationService = instantiationService;
+        this.languageModelsService = languageModelsService;
+        this.configurationService = configurationService;
+        this.logService = logService;
+        this.notificationService = notificationService;
+        this.gitHubService = gitHubService;
+        this.pullRequestIconCache = pullRequestIconCache;
+        this.labelService = labelService;
+        this.uriIdentityService = uriIdentityService;
+        this.fileService = fileService;
+        this.pathService = pathService;
+        this.storageService = storageService;
+        this.environment = {
+            id: "cloud",
+            label: ( localize(5071, "Cloud"))
+        };
+        this.icon = Codicon.copilot;
+        this.order = 0;
+        this._onDidChangeSessionTypes = this._register(( new Emitter()));
+        this.onDidChangeSessionTypes = this._onDidChangeSessionTypes.event;
+        this._onDidChangeCapabilities = this._register(( new Emitter()));
+        this.onDidChangeCapabilities = this._onDidChangeCapabilities.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._sandboxSends = ( new Set());
+        this._repositoryPicker = this._register(( new MutableDisposable()));
+        this._sandboxCatalog = this._register(( new MutableDisposable()));
+        this._onDidChangeSandboxModels = this._register(( new Emitter()));
+        this._sandboxConfigs = ( new Map());
+        this._onDidChangeSessionConfig = this._register(( new Emitter()));
+        this.onDidChangeSessionConfig = this._onDidChangeSessionConfig.event;
+        this.sessionConfig = this;
+        this._sessionWrapperCache = ( new Map());
+        this._localGitRepositoryState = ( new Map());
+        this._localGitRepositoryResolutionStarted = ( new Set());
+        this._newSessions = this._register(( new DisposableMap()));
+        this._createdBySessions = ( new Map());
+        this._storedCreatedBySessions = ( new Map());
+        this._loadCreatedBySessions();
+        if (providerMode === "default") {
+            this.automations = this._register(
+                this.instantiationService.createInstance(CloudAutomationStore, this.id, CopilotCloudSessionType.id, async uri => {
+                    if (uri.scheme === GITHUB_REMOTE_FILE_SCHEME) {
+                        return uri;
+                    }
+                    if (uri.scheme !== Schemas.file) {
+                        return undefined;
+                    }
+                    const repository = await resolveGitRepositoryFromGitConfig(this.fileService, uri, ["github.com"]);
+                    return repository?.gitHub ? ( URI.from({
+                        scheme: GITHUB_REMOTE_FILE_SCHEME,
+                        authority: "github",
+                        path: `/${repository.gitHub.owner}/${repository.gitHub.repo}/HEAD`
+                    })) : undefined;
+                })
+            );
+        }
+        this._register(Event.filter(
+            this.configurationService.onDidChangeConfiguration,
+            event => event.affectsConfiguration(UNIFIED_WORKSPACE_PICKER_SETTING)
+        )(() => this._onDidChangeSessionTypes.fire()));
+        this._register(this.configurationService.onDidChangeConfiguration(event => {
+            const sandboxChanged = event.affectsConfiguration(CloudSandboxEnabledSettingId) || event.affectsConfiguration(RemoteAgentHostsEnabledSettingId);
+            if (sandboxChanged || event.affectsConfiguration(ChatAIDisabledSettingId)) {
+                this._onDidChangeSessionTypes.fire();
+                this._onDidChangeCapabilities.fire();
+            }
+            if (sandboxChanged) {
+                if (this._newSessions.size > 0 && this._usesSandbox()) {
+                    this._getSandboxCatalog().load();
+                }
+                for (const sessionId of ( this._newSessions.keys())) {
+                    this._onDidChangeSessionConfig.fire(sessionId);
+                }
+                this._onDidChangeSandboxModels.fire();
+            }
+            if (event.affectsConfiguration(ChatConfiguration.DefaultConfiguration) || event.affectsConfiguration(ChatConfiguration.GlobalAutoApprove)) {
+                for (const [sessionId, config] of this._sandboxConfigs) {
+                    const refreshed = createCloudSandboxSessionConfig(this.configurationService);
+                    for (const [key, value] of Object.entries(config.values)) {
+                        if (refreshed.schema.properties[key]?.enum?.some(candidate => candidate === value)) {
+                            refreshed.values[key] = value;
+                        }
+                    }
+                    this._sandboxConfigs.set(sessionId, refreshed);
+                    this._onDidChangeSessionConfig.fire(sessionId);
+                }
+            }
+        }));
+        this._register(this.agentSessionsService.model.onDidChangeSessions(() => {
+            this._refreshSessionCache();
+        }));
+        this._ensureSessionCache();
+    }
+    get browseActions() {
+        const useConsolidatedRemoteWorkspaces = this.configurationService.getValue(UNIFIED_WORKSPACE_PICKER_SETTING);
+        const isSandbox = this.providerMode === "sandbox";
+        const repositoryAction = {
+            label: isSandbox ? ( localize(5072, "Choose Repository...")) : useConsolidatedRemoteWorkspaces ? ( localize(5073, "Work in Repository...")) : ( localize(5074, "Repository...")),
+            group: SESSION_WORKSPACE_GROUP_GITHUB,
+            icon: isSandbox || useConsolidatedRemoteWorkspaces ? Codicon.github : Codicon.library,
+            providerId: this.id,
+            attachesContext: false,
+            supportsContextAttachment: !isSandbox,
+            run: () => this._browseForRepository()
+        };
+        if (isSandbox) {
+            return [repositoryAction];
+        }
+        return [repositoryAction, {
+            label: ( localize(5075, "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(5076, "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 (this.providerMode === "sandbox") {
+            return this.resolveWorkspace(workspaceUri) ? [CopilotSandboxSessionType] : [];
+        }
+        if (workspaceUri.scheme === GITHUB_REMOTE_FILE_SCHEME || workspaceUri.scheme === SessionType.CopilotCloud) {
+            return [CopilotCloudSessionType];
+        }
+        if (this.configurationService.getValue(UNIFIED_WORKSPACE_PICKER_SETTING) && workspaceUri.scheme === Schemas.file) {
+            const gitRepository = this._getLocalGitRepository(workspaceUri);
+            gitRepository.resolveGitHubInfo?.();
+            if (gitRepository.gitHubInfo.get()) {
+                return [CopilotCloudSessionType];
+            }
+        }
+        return [];
+    }
+    getSessions() {
+        this._ensureSessionCache();
+        return Array.from(( this._sessionCache.values()), chat => this._chatToSession(chat));
+    }
+    _createdBySession(resource) {
+        const key = ( resource.toString());
+        let createdBySession = this._createdBySessions.get(key);
+        if (!createdBySession) {
+            createdBySession = observableValue(this, this._storedCreatedBySessions.get(key));
+            this._createdBySessions.set(key, createdBySession);
+        }
+        return createdBySession;
+    }
+    _setCreatedBySession(resource, reference) {
+        const key = ( resource.toString());
+        this._createdBySession(resource).set(reference, undefined);
+        this._storedCreatedBySessions.set(key, reference);
+        this._saveCreatedBySessions();
+    }
+    _deleteCreatedBySession(resource) {
+        const key = ( resource.toString());
+        this._createdBySessions.delete(key);
+        if (this._storedCreatedBySessions.delete(key)) {
+            this._saveCreatedBySessions();
+        }
+    }
+    _loadCreatedBySessions() {
+        const raw = this.storageService.get(STORAGE_KEY_CREATED_BY_SESSIONS, StorageScope.PROFILE);
+        if (!raw) {
+            return;
+        }
+        try {
+            const stored = JSON.parse(raw);
+            for (const [resource, reference] of Object.entries(stored)) {
+                this._storedCreatedBySessions.set(resource, {
+                    session: ( URI.parse(reference.session)),
+                    chat: reference.chat ? ( URI.parse(reference.chat)) : undefined,
+                    turnId: reference.turnId
+                });
+            }
+        } catch (error) {
+            this.logService.error(
+                "[CopilotChatSessionsProvider] Failed to restore session creation references.",
+                error
+            );
+        }
+    }
+    _saveCreatedBySessions() {
+        const stored = {};
+        for (const [resource, reference] of this._storedCreatedBySessions) {
+            stored[resource] = {
+                session: ( reference.session.toString()),
+                chat: reference.chat?.toString(),
+                turnId: reference.turnId
+            };
+        }
+        this.storageService.store(
+            STORAGE_KEY_CREATED_BY_SESSIONS,
+            JSON.stringify(stored),
+            StorageScope.PROFILE,
+            StorageTarget.MACHINE
+        );
+    }
+    _clearCurrentNewSessionIfMatch(session, leak) {
+        if (this._newSessions.get(session.sessionId) === session) {
+            this._sandboxConfigs.delete(session.sessionId);
+            if (leak) {
+                this._newSessions.deleteAndLeak(session.sessionId);
+            } else {
+                this._newSessions.deleteAndDispose(session.sessionId);
+            }
+        }
+    }
+    deleteNewSession(sessionId) {
+        this._sandboxConfigs.delete(sessionId);
+        if (( this._newSessions.has(sessionId))) {
+            this._newSessions.deleteAndDispose(sessionId);
+            this._sessionWrapperCache.delete(sessionId);
+        }
+    }
+    getSession(sessionId) {
+        const newSession = this._newSessions.get(sessionId);
+        if (newSession) {
+            return newSession;
+        }
+        return this._findChatSession(sessionId);
+    }
+    createNewSession(workspaceUri, sessionTypeId, options) {
+        return this._createDraftSession(workspaceUri, sessionTypeId, options);
+    }
+    _createDraftSession(workspaceUri, sessionTypeId, options) {
+        if (this.providerMode === "sandbox") {
+            if (!isCloudSandboxEnabled(this.configurationService) || this.configurationService.getValue(ChatAIDisabledSettingId)) {
+                throw ( new Error(( localize(5077, "GitHub sandbox sessions are not enabled."))));
+            }
+            if (sessionTypeId !== CopilotSandboxSessionType.id || options?.automationConfiguration || options?.isAutomationDraft) {
+                throw ( new Error(( localize(
+                    5078,
+                    "This configuration is not supported for a new GitHub sandbox session."
+                ))));
+            }
+        }
+        const workspace = workspaceUri ? this.resolveWorkspace(workspaceUri) : undefined;
+        if (workspaceUri && !workspace) {
+            throw ( new Error(`Cannot resolve workspace for URI: ${( workspaceUri.toString())}`));
+        }
+        const automationConfiguration = options?.automationConfiguration;
+        assertAutomationSessionTemplate(automationConfiguration?.sessionTemplate);
+        if (this.providerMode !== "sandbox" && sessionTypeId !== CopilotCloudSessionType.id) {
+            throw ( new Error(`Unsupported session type '${sessionTypeId}'`));
+        }
+        const cloudWorkspace = !workspace || workspaceUri?.scheme === GITHUB_REMOTE_FILE_SCHEME ? workspace : this._getCloudWorkspaceForLocalRepository(workspace);
+        if (workspace && !cloudWorkspace) {
+            throw ( new Error("Copilot Cloud sessions require a local workspace with a GitHub remote"));
+        }
+        const target = this.providerMode === "sandbox" ? CopilotSandboxSessionType.id : AgentSessionProviders.Cloud;
+        const resource = ( URI.from({
+            scheme: target,
+            path: `/untitled-${generateUuid()}`
+        }));
+        const session = this.instantiationService.createInstance(
+            RemoteNewSession,
+            resource,
+            cloudWorkspace,
+            target,
+            this.id,
+            automationConfiguration,
+            options?.isAutomationDraft === true
+        );
+        session.setCreatedBySession(options?.createdBySession);
+        this._newSessions.set(session.sessionId, session);
+        if (this._usesSandbox(session)) {
+            this._getSandboxCatalog().load();
+        }
+        this._onDidChangeSessionConfig.fire(session.sessionId);
+        this._onDidChangeSandboxModels.fire();
+        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;
+        if (this.automations?.enabled.get()) {
+            if (modelConfiguration !== undefined || initialConfiguration?.mode !== undefined || initialConfiguration?.permissionLevel !== undefined) {
+                throw ( new Error(( localize(
+                    5079,
+                    "Cloud automations do not support local mode, approval, or model-specific settings. Remove those settings before saving."
+                ))));
+            }
+            return {
+                sessionTemplate: {
+                    ...(modelId !== undefined ? {
+                        modelId
+                    } : {}),
+                    ...(initialTemplate?.config !== undefined ? {
+                        config: initialTemplate.config
+                    } : {})
+                }
+            };
+        }
+        const initialMode = initialConfiguration?.mode ?? initialTemplate?.config?.[SessionConfigKey.Mode];
+        const mode = typeof initialMode === "string" ? initialMode : undefined;
+        const initialPermissionLevel = initialConfiguration?.permissionLevel ?? initialTemplate?.config?.[SessionConfigKey.AutoApprove];
+        const permissionLevel = isChatPermissionLevel(initialPermissionLevel) ? initialPermissionLevel : ChatPermissionLevel.Default;
+        const config = {
+            ...initialTemplate?.config
+        };
+        if (mode) {
+            config[SessionConfigKey.Mode] = mode;
+        } else {
+            delete config[SessionConfigKey.Mode];
+        }
+        config[SessionConfigKey.AutoApprove] = permissionLevel;
+        const sessionTemplate = {
+            ...(modelId ? {
+                modelId
+            } : {}),
+            ...(modelConfiguration !== undefined ? {
+                modelConfiguration
+            } : {}),
+            ...(( Object.keys(config)).length > 0 ? {
+                config
+            } : {})
+        };
+        return {
+            sessionTemplate,
+            modelId,
+            mode,
+            permissionLevel
+        };
+    }
+    createQuickChat(sessionTypeId, options) {
+        if (!this.supportsQuickChats) {
+            throw ( new Error(( localize(5077, "GitHub sandbox sessions are not enabled."))));
+        }
+        return this._createDraftSession(undefined, sessionTypeId, options);
+    }
+    _applyAutomationSessionConfiguration(session, configuration) {
+        if (!configuration) {
+            return;
+        }
+        const template = configuration.sessionTemplate;
+        if (template?.agent) {
+            throw ( new Error(( localize(
+                5080,
+                "This provider does not support custom agents in Automation session templates."
+            ))));
+        }
+        const modelId = template?.modelId ?? configuration.modelId;
+        if (modelId) {
+            session.setModelId(modelId, ChatModelSource.Chosen);
+        }
+    }
+    get onDidChangeModels() {
+        return Event.signal(Event.any(
+            this._onDidChangeSandboxModels.event,
+            this.languageModelsService.onDidChangeLanguageModels,
+            this.chatSessionsService.onDidChangeOptionGroups
+        ));
+    }
+    getModelsSnapshot(sessionId, desiredModelId) {
+        const draft = this._newSessions.get(sessionId);
+        if (draft && this._usesSandbox(draft)) {
+            return this._sandboxModelsSnapshot(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
+        };
+    }
+    getModelsSnapshotForCreation(_workspaceUri, sessionTypeId, desiredModelId) {
+        if (this.providerMode !== "sandbox" && sessionTypeId !== CopilotCloudSessionType.id) {
+            return {
+                models: [],
+                desiredModelResolution: resolveModelIdentifier([], desiredModelId, true),
+                modelTarget: undefined
+            };
+        }
+        if (this._usesSandbox()) {
+            return this._sandboxModelsSnapshot(desiredModelId);
+        }
+        const group = this.chatSessionsService.getOptionGroupsForSessionType(AgentSessionProviders.Cloud)?.find(candidate => isModelOptionGroup(candidate));
+        const models = group?.items.map(item => this._toSyntheticModel(item)) ?? [];
+        return {
+            models,
+            desiredModelResolution: resolveModelIdentifier(models, desiredModelId, group !== undefined),
+            modelTarget: AgentSessionProviders.Cloud
+        };
+    }
+    getModelPickerOptions(sessionId) {
+        const draft = this._newSessions.get(sessionId);
+        if (draft && this._usesSandbox(draft)) {
+            return {
+                showUnavailableFeatured: false,
+                showManageModelsAction: false,
+                showAutoModel: false
+            };
+        }
+        const sessionType = this.getSession(sessionId)?.sessionType;
+        const showAutoModel = !sessionType || this.chatSessionsService.supportsAutoModelForSessionType(sessionType);
+        return {
+            showUnavailableFeatured: false,
+            showManageModelsAction: false,
+            showAutoModel
+        };
+    }
+    _usesSandbox(session) {
+        return !session?.isAutomationDraft && (session?.isQuickChat.get() === true || this.providerMode === "sandbox" || isCloudSandboxEnabled(this.configurationService));
+    }
+    _getSandboxCatalog() {
+        if (!this._sandboxCatalog.value) {
+            const catalog = this.instantiationService.createInstance(
+                CloudSandboxModels,
+                CopilotSandboxSessionType.id,
+                `${this.id}-sandbox-models`,
+                undefined
+            );
+            this._sandboxCatalog.value = catalog;
+            this._register(catalog.onDidChange(() => this._onDidChangeSandboxModels.fire()));
+        }
+        return this._sandboxCatalog.value;
+    }
+    _sandboxModelsSnapshot(desiredModelId) {
+        const catalog = this._getSandboxCatalog();
+        catalog.load();
+        return {
+            models: catalog.models,
+            desiredModelResolution: resolveModelIdentifier(catalog.models, desiredModelId, catalog.ready),
+            modelTarget: CopilotSandboxSessionType.id
+        };
+    }
+    getSessionConfig(sessionId) {
+        const session = this._newSessions.get(sessionId);
+        if (!session || !this._usesSandbox(session)) {
+            return undefined;
+        }
+        let config = this._sandboxConfigs.get(sessionId);
+        if (!config) {
+            config = createCloudSandboxSessionConfig(this.configurationService);
+            this._sandboxConfigs.set(sessionId, config);
+        }
+        return config;
+    }
+    getCreateSessionConfig(sessionId) {
+        return this.getSessionConfig(sessionId)?.values;
+    }
+    isSessionConfigResolving(_sessionId) {
+        return constObservable(false);
+    }
+    async setSessionConfigValue(sessionId, property, value) {
+        const config = this.getSessionConfig(sessionId);
+        if (!config) {
+            throw ( new Error("Cloud sandbox draft configuration is unavailable."));
+        }
+        validateSessionConfigWrite(config.schema, config.values, property, value, true);
+        this._sandboxConfigs.set(sessionId, {
+            ...config,
+            values: {
+                ...config.values,
+                [property]: value
+            }
+        });
+        this._onDidChangeSessionConfig.fire(sessionId);
+    }
+    _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: COPILOT_VENDOR_ID,
+                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,
+                maxContextWindowTokens: modelMetadata?.maxContextWindowTokens,
+                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);
+            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);
+    }
+    async getNewSessionConfig(sessionId) {
+        const session = this._newSessions.get(sessionId);
+        if (!session) {
+            return undefined;
+        }
+        return {
+            providerConfig: deepClone(
+                Object.fromEntries([...session.selectedOptions].map(([key, value]) => [key, value.id]))
+            )
+        };
+    }
+    async archiveSession(sessionId) {
+        const chatSession = this._findChatSession(sessionId);
+        if (chatSession instanceof RemoteNewSession) {
+            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 instanceof RemoteNewSession) {
+            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 agentSession = this._findAgentSession(sessionId);
+        if (agentSession && agentSession.isRead() !== isRead) {
+            agentSession.setRead(isRead);
+        }
+    }
+    async deleteSession(sessionId) {
+        const agentSession = this._findAgentSession(sessionId);
+        if (!agentSession) {
+            this._cleanupTempSession(sessionId);
+            return;
+        }
+        await this.chatService.removeHistoryEntry(agentSession.resource);
+        this._deleteCreatedBySession(agentSession.resource);
+        this._sessionWrapperCache.delete(sessionId);
+        this._refreshSessionCache();
+    }
+    async deleteSessions(sessionIds) {
+        for (const sessionId of sessionIds) {
+            await this.deleteSession(sessionId);
+        }
+    }
+    async renameChat(_sessionId, _chatUri, _title) {
+        throw ( new Error("Renaming is not supported for Copilot Cloud sessions"));
+    }
+    async renameSession(_sessionId, _title) {
+        throw ( new Error("Renaming is not supported for Copilot Cloud sessions"));
+    }
+    async deleteChat(_sessionId, _chatUri, _options) {
+        throw ( new Error("Deleting individual chats is not supported for Copilot Cloud sessions"));
+    }
+    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`));
+    }
+    startNewSessionRequest(sessionId) {
+        const session = this._newSessions.get(sessionId);
+        if (!session || !this._usesSandbox(session)) {
+            return undefined;
+        }
+        return session.startPreparation();
+    }
+    async createNewChat(sessionId, _prompt) {
+        const session = this._newSessions.get(sessionId);
+        if (!session) {
+            throw ( new Error(
+                `[CopilotChatSessionsProvider] Session '${sessionId}' does not support multiple chats`
+            ));
+        }
+        if (!this._usesSandbox(session)) {
+            (await this._createChatSession(session.resource, session)).dispose();
+        }
+        const newChat = this._withChangesets(buildChatFromSession(session), session.workspace);
+        session.mainChat.set(newChat, undefined);
+        return newChat;
+    }
+    _getCloudSandboxContribution() {
+        return getWorkbenchContribution(CloudSandboxAgentHostContribution.ID);
+    }
+    get _sandboxModelWaitMs() {
+        return CopilotChatSessionsProvider_1.SANDBOX_MODEL_WAIT_MS;
+    }
+    async _sendFirstChatToSandbox(session, repoNwo, options) {
+        this._sandboxSends.add(session.sessionId);
+        const preparation = session.startPreparation();
+        const token = preparation.object;
+        session.setTitle(
+            (options.title || options.query.split("\n")[0]).trim().substring(0, 100) || ( localize(5081, "New Session"))
+        );
+        session.setStatus(SessionStatus.InProgress);
+        this._sessionCache.set(( session.resource.toString()), session);
+        const placeholder = this._chatToSession(session);
+        this._onDidChangeSessions.fire({
+            added: [placeholder],
+            removed: [],
+            changed: []
+        });
+        let provisioned;
+        const selectedModel = this._selectedCloudModel(session);
+        const config = this.getCreateSessionConfig(session.sessionId);
+        const store = ( new DisposableStore());
+        store.add(preparation);
+        store.add(token.onCancellationRequested(() => store.dispose()));
+        const progress = {
+            report: message => {
+                if (!store.isDisposed) {
+                    session.reportPreparationProgress(message);
+                }
+            }
+        };
+        try {
+            const contribution = this._getCloudSandboxContribution();
+            provisioned = await raceCancellationError(contribution.provisionSession({
+                ...(repoNwo ? {
+                    repoNwo
+                } : {}),
+                prompt: options.query
+            }, token, progress), token);
+            if (token.isCancellationRequested) {
+                throw ( new CancellationError());
+            }
+            if (repoNwo) {
+                store.add(
+                    contribution.trackSessionCreationProgress(provisioned.environmentId, repoNwo, progress)
+                );
+                await raceCancellationError(
+                    contribution.prepareSession(provisioned.environmentId, repoNwo, token),
+                    token
+                );
+            }
+            progress.report(( localize(5082, "Starting Copilot agent")));
+            const chat = provisioned.session.mainChat.get();
+            if (session.isQuickChat.get()) {
+                const canResolve = await raceCancellationError(
+                    this.chatSessionsService.canResolveChatSession(chat.resource.scheme),
+                    token
+                );
+                if (!canResolve || !this.chatSessionsService.updateChatSessionMetadata(chat.resource, {
+                    [SESSION_META_WORKSPACELESS_KEY]: true
+                })) {
+                    throw ( new Error(( localize(
+                        5083,
+                        "The sandbox could not start a chat without a workspace. Your prompt was not sent."
+                    ))));
+                }
+            }
+            const sessionConfig = config ? await provisioned.provider.resolveInitialSessionConfig(provisioned.session.sessionId, config, token) : undefined;
+            await raceCancellationError(
+                this._carryModelToSandbox(provisioned, chat.resource, selectedModel),
+                token
+            );
+            await raceCancellationError(
+                provisioned.provider.setInitialSessionTitle(provisioned.session.sessionId, session.title.get()),
+                token
+            );
+            const committed = await provisioned.provider.sendRequest(provisioned.session.sessionId, chat.resource, {
+                ...options,
+                sessionConfig
+            });
+            this._publishSandboxSession(provisioned, {
+                announce: false
+            });
+            this._retirePlaceholder(session, placeholder, committed);
+            return committed;
+        } catch (error) {
+            this.logService.error(
+                `[CopilotChatSessionsProvider] Failed to start cloud sandbox session ${session.sessionId}:`,
+                error
+            );
+            if (provisioned) {
+                this._publishSandboxSession(provisioned);
+            }
+            this._sessionCache.delete(( session.resource.toString()));
+            this._sessionWrapperCache.delete(session.sessionId);
+            this._clearCurrentNewSessionIfMatch(session,  true);
+            this._onDidChangeSessions.fire({
+                added: [],
+                removed: [placeholder],
+                changed: []
+            });
+            session.dispose();
+            throw error;
+        } finally {
+            store.dispose();
+            this._sandboxSends.delete(session.sessionId);
+        }
+    }
+    _publishSandboxSession(provisioned, options) {
+        provisioned.provider.publishWithheldSession(AgentSession.id(provisioned.session.resource), options);
+    }
+    _selectedCloudModel(session) {
+        const selectedModelId = session.selectedModelId;
+        if (!selectedModelId) {
+            return undefined;
+        }
+        const sandboxModel = this._sandboxCatalog.value?.models.find(model => model.identifier === selectedModelId);
+        if (sandboxModel) {
+            return {
+                rawModelId: sandboxModel.metadata.id,
+                label: sandboxModel.metadata.name,
+                config: session.modelConfiguration.captureModelConfiguration(selectedModelId),
+                fromCloudCatalog: true
+            };
+        }
+        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") {
+                    if (selected.config && ( Object.keys(selected.config)).length) {
+                        const schema = resolution.model.metadata.configurationSchema;
+                        for (const [key, value] of Object.entries(selected.config)) {
+                            const property = schema?.properties?.[key];
+                            if (!property || property.readOnly || (property.enum && !property.enum.includes(value))) {
+                                throw ( new Error(( localize(5084, "The sandbox does not support the selected {0} for {1}.", key, label))));
+                            }
+                        }
+                        const configuration = provider.getAutomationModelConfiguration(sessionId);
+                        if (!configuration) {
+                            throw ( new Error("The sandbox model configuration is unavailable."));
+                        }
+                        await configuration.setModelConfiguration(resolution.model.identifier, selected.config);
+                    }
+                    provider.setModel(
+                        sessionId,
+                        chatResource,
+                        resolution.model.identifier,
+                        ChatModelSource.CarriedOver
+                    );
+                    return;
+                }
+                if (resolution.kind !== "pending" && !selected.fromCloudCatalog) {
+                    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(
+            5085,
+            "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._sessionWrapperCache.delete(session.sessionId);
+        this._clearCurrentNewSessionIfMatch(session);
+        this._onDidReplaceSession.fire({
+            from: placeholder,
+            to: committed
+        });
+    }
+    async sendRequest(sessionId, chatResource, options) {
+        if (( this._sandboxSends.has(sessionId))) {
+            throw ( new Error(( localize(
+                5086,
+                "A GitHub sandbox session is already being started. Wait for it to finish before sending another message."
+            ))));
+        }
+        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 (this._usesSandbox(newSession)) {
+                if (!this.supportsQuickChats) {
+                    throw ( new Error(( localize(
+                        5087,
+                        "GitHub sandbox creation is no longer available. Enable the feature to try again."
+                    ))));
+                }
+                if (!newSession.isQuickChat.get() && !newSession.repoNwo) {
+                    throw ( new Error(( localize(
+                        5088,
+                        "GitHub sandbox creation requires a repository for this session. Please choose a repository to try again."
+                    ))));
+                }
+                return this._sendFirstChatToSandbox(newSession, newSession.repoNwo, options);
+            }
+            return this._sendFirstChat(newSession, chatResource, options);
+        }
+        if (!this._findChatSession(sessionId)) {
+            throw ( new Error(`Session '${sessionId}' not found`));
+        }
+        throw ( new Error("Multiple chats per session is not supported"));
+    }
+    async _sendFirstChat(session, chatResource, options) {
+        const {
+            query,
+            attachedContext
+        } = options;
+        session.setTitle(
+            (options.title || query.split("\n")[0]).substring(0, 100) || ( localize(5081, "New Session"))
+        );
+        session.setStatus(SessionStatus.InProgress);
+        this._sessionCache.set(( session.resource.toString()), session);
+        const newSession = this._chatToSession(session);
+        this._onDidChangeSessions.fire({
+            added: [newSession],
+            removed: [],
+            changed: []
+        });
+        const contribution = this.chatSessionsService.getChatSessionContribution(session.target);
+        const permissionLevel = ChatPermissionLevel.Default;
+        const sendOptions = {
+            location: ChatAgentLocation.Chat,
+            userSelectedModelId: session.selectedModelId,
+            userSelectedModelConfiguration: session.modelConfiguration.getModelConfigurationForRequest(session.selectedModelId),
+            modeInfo: {
+                kind: ChatModeKind.Agent,
+                isBuiltin: true,
+                modeInstructions: undefined,
+                telemetryModeId: ChatModeKind.Agent,
+                applyCodeBlockSuggestionId: undefined,
+                permissionLevel
+            },
+            agentIdSilent: contribution?.type,
+            attachedContext,
+            hideFromTranscript: options.hideFromTranscript,
+            onDidCreateResponse: options.onDidCreateResponse
+        };
+        const ref = await this._updateChatSessionState(chatResource, session, 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._sessionWrapperCache.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 responseCreatedPromise = result.kind === "sent" ? result.data.responseCreatedPromise : undefined;
+            responseCreatedPromise?.then(r => {
+                if (r?.isCanceled) {
+                    cts.cancel();
+                }
+            });
+            try {
+                const committedResource = await this._waitForCommittedSession(session.resource, responseCreatedPromise);
+                this._inFlightCommits.add(( committedResource.toString()));
+                try {
+                    const createdBySession = session.createdBySession.get();
+                    if (createdBySession) {
+                        this._setCreatedBySession(committedResource, createdBySession);
+                    }
+                    const committedChat = await this._waitForSessionInCache(committedResource, cts.token);
+                    this._sessionCache.delete(( session.resource.toString()));
+                    this._clearCurrentNewSessionIfMatch(session);
+                    const committedSession = this._chatToSession(committedChat);
+                    this._sessionWrapperCache.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._sessionWrapperCache.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) {
+        await this.chatSessionsService.getOrCreateChatSession(resource, CancellationToken.None);
+        return this._updateChatSessionState(resource, session);
+    }
+    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.selectedOptions.size > 0) {
+            this.chatSessionsService.updateSessionOptions(resource, session.selectedOptions);
+        }
+        if (permissionLevel) {
+            model.inputModel.setState({
+                permissionLevel
+            });
+        }
+        return modelRef;
+    }
+    async _waitForCommittedSession(untitledResource, responseCreatedPromise) {
+        const timeoutMs = 5 * 60_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);
+                    }
+                }));
+            }));
+            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 _pickRepository(allowRepositoryUrl = false) {
+        if (isWeb) {
+            const store = ( new DisposableStore());
+            this._repositoryPicker.value = store;
+            const token = cancelOnDispose(store);
+            const checkHost = () => {
+                if (this.gitHubService.enterpriseHost !== undefined) {
+                    throw ( new Error(( localize(
+                        5089,
+                        "This picker supports github.com repositories only. Switch to a github.com account, then try again."
+                    ))));
+                }
+            };
+            try {
+                checkHost();
+                await raceCancellationError(this.gitHubService.authenticateForRepositoryAccess(token), token);
+                if (token.isCancellationRequested) {
+                    return undefined;
+                }
+                checkHost();
+                const picker = store.add(this.instantiationService.createInstance(RepositoryPicker));
+                const selection = await picker.pickRepository(async (query, requestToken) => {
+                    checkHost();
+                    const repositories = await this.gitHubService.getRepositories(getGitHubRepositoryId(query.trim()) ?? query, requestToken);
+                    checkHost();
+                    return repositories.map(repository => repository.fullName);
+                }, undefined, token);
+                if (selection) {
+                    checkHost();
+                }
+                return selection?.repository;
+            } catch (error) {
+                if (!isCancellationError(error) && !token.isCancellationRequested) {
+                    this.notificationService.error(error);
+                }
+                return undefined;
+            } finally {
+                store.dispose();
+                if (this._repositoryPicker.value === store) {
+                    this._repositoryPicker.clear();
+                }
+            }
+        }
+        return this.commandService.executeCommand(OPEN_REPO_COMMAND, undefined, {
+            allowRepositoryUrl
+        });
+    }
+    async _browseForRepository() {
+        const allowRepositoryUrl = this._supportsLocalRepositoryActions();
+        const repository = await this._pickRepository(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 this.supportsLocalWorkspaces && !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(
+                    5090,
+                    "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._pickRepository();
+        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 (this.providerMode === "sandbox" && (uri.scheme !== GITHUB_REMOTE_FILE_SCHEME || uri.authority !== "github" || !/^\/[^/]+\/[^/]+\/HEAD$/.test(uri.path) || uri.query || uri.fragment)) {
+            return undefined;
+        }
+        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();
+    }
+    _cleanupTempSession(sessionId) {
+        const chatSession = this._findChatSession(sessionId);
+        if (!chatSession) {
+            return;
+        }
+        this._sessionCache.delete(( chatSession.resource.toString()));
+        this._deleteCreatedBySession(chatSession.resource);
+        if (( this._newSessions.has(chatSession.sessionId))) {
+            this._newSessions.deleteAndLeak(chatSession.sessionId);
+        }
+        const removedSession = this._chatToSession(chatSession);
+        this._sessionWrapperCache.delete(chatSession.sessionId);
+        this._onDidChangeSessions.fire({
+            added: [],
+            removed: [removedSession],
+            changed: []
+        });
+        if (chatSession instanceof RemoteNewSession) {
+            chatSession.dispose();
+        }
+    }
+    _refreshSessionCache() {
+        if (this.providerMode === "sandbox") {
+            return;
+        }
+        const currentKeys = ( new Set());
+        const addedData = [];
+        const changedData = [];
+        const sessionsToMarkUnread = [];
+        for (const session of this.agentSessionsService.model.sessions) {
+            if (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.logService
+                ));
+                this._sessionCache.set(key, adapter);
+                addedData.push(adapter);
+            }
+        }
+        const removedData = [];
+        for (const [key, adapter] of this._sessionCache) {
+            if (!( currentKeys.has(key)) && adapter instanceof AgentSessionAdapter && !( this._inFlightCommits.has(key))) {
+                removedData.push(adapter);
+            }
+        }
+        for (const removed of removedData) {
+            this._sessionCache.delete(( removed.resource.toString()));
+        }
+        if (addedData.length > 0 || removedData.length > 0 || changedData.length > 0) {
+            this._onDidChangeSessions.fire({
+                added: addedData.map(d => this._chatToSession(d)),
+                removed: removedData.map(d => {
+                    const session = this._chatToSession(d);
+                    this._sessionWrapperCache.delete(d.sessionId);
+                    return session;
+                }),
+                changed: changedData.map(d => this._chatToSession(d))
+            });
+        }
+        for (const session of sessionsToMarkUnread) {
+            session.setRead(false);
+        }
+    }
+    _findChatSession(sessionId) {
+        return this._sessionCache.get(this._localIdFromSessionId(sessionId));
+    }
+    _findAgentSession(sessionId) {
+        const adapter = this._findChatSession(sessionId);
+        if (!adapter) {
+            return undefined;
+        }
+        return this.agentSessionsService.getSession(adapter.resource);
+    }
+    _localIdFromSessionId(sessionId) {
+        const prefix = `${this.id}:`;
+        return sessionId.startsWith(prefix) ? sessionId.substring(prefix.length) : sessionId;
+    }
+    _chatToSession(chat) {
+        const cached = this._sessionWrapperCache.get(chat.sessionId);
+        if (cached) {
+            return cached;
+        }
+        const mainChat = chat.mainChat.map(mainChat => this._withChangesets(mainChat, chat.workspace));
+        const chatsObs = mainChat.map(c => [c]);
+        const session = {
+            sessionId: chat.sessionId,
+            resource: chat.resource,
+            providerId: chat.providerId,
+            sessionType: chat.sessionType,
+            harness: "copilot",
+            environment: this.environment.id,
+            application: chat.application,
+            icon: chat.icon,
+            createdAt: chat.createdAt,
+            workspace: chat.workspace,
+            isQuickChat: chat.isQuickChat,
+            title: chat.title,
+            updatedAt: chat.updatedAt,
+            status: chat.status,
+            changesSummary: chat.changesSummary,
+            artifacts: chat.artifacts,
+            modelId: chat.modelId,
+            mode: chat.mode,
+            loading: chat.loading,
+            preparationProgress: chat.preparationProgress,
+            isNewSessionRequestInProgress: chat.isNewSessionRequestInProgress,
+            isArchived: chat.isArchived,
+            isRead: chat.isRead,
+            description: chat.description,
+            lastTurnEnd: chat.lastTurnEnd,
+            chats: chatsObs,
+            mainChat,
+            createdBySession: chat.createdBySession ?? this._createdBySession(chat.resource),
+            isExternal: chat.isExternal,
+            capabilities: constObservable({
+                supportsMultipleChats: false,
+                supportsRename: false,
+                supportsDelete: false,
+                runsWorktreeCreatedTasks: chat.sessionType === CopilotCloudSessionType.id
+            })
+        };
+        this._sessionWrapperCache.set(chat.sessionId, session);
+        return session;
+    }
+    _withChangesets(chat, workspace) {
+        return {
+            ...chat,
+            changesets: createChangesets(workspace, constObservable([chat]), this.instantiationService)
+        };
+    }
+};
+CopilotChatSessionsProvider = CopilotChatSessionsProvider_1 = ( __decorate([( __param(1, IAgentSessionsService)), ( __param(2, IChatService)), ( __param(3, IChatSessionsService)), ( __param(4, ICommandService)), ( __param(5, IInstantiationService)), ( __param(6, ILanguageModelsService)), ( __param(7, IConfigurationService)), ( __param(8, ILogService)), ( __param(9, INotificationService)), ( __param(10, IGitHubService)), ( __param(11, IPullRequestIconCache)), ( __param(12, ILabelService)), ( __param(13, IUriIdentityService)), ( __param(14, IFileService)), ( __param(15, IPathService)), ( __param(16, IStorageService))], CopilotChatSessionsProvider));
+
+export { COPILOT_PROVIDER_ID, CopilotChatSessionsProvider, CopilotCloudSessionType, CopilotSandboxSessionType, RemoteNewSession };