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

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

@@ -2,24 +2,52 @@
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { SequencerByKey } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
 import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
-import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Disposable, DisposableStore, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { ResourceMap, ResourceSet } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
 import { equals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
 import { IAgentHostService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService.service';
-import { SessionConfigKey, KNOWN_AUTO_APPROVE_VALUES, KNOWN_MODE_VALUES } from '@codingame/monaco-vscode-katex-common/vscode/vs/platform/agentHost/common/sessionConfigKeys';
-import { migrateLegacyAutopilotConfig } from '../../../../../../platform/agentHost/common/agentHostSchema.js';
+import { SessionConfigKey, KNOWN_MODE_VALUES } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/sessionConfigKeys';
+import { migrateLegacyAutopilotConfig } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema';
 import { ActionType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/actions';
+import { areSessionWorkingDirectoriesEqual } from '../../../../../../platform/agentHost/common/state/sessionWorkingDirectories.js';
+import { withSessionMultiRootMetadata } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
 import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
+import { WorkbenchState } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
 import { IWorkspaceTrustManagementService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service';
 import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
-import { ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ChatConfiguration, getChatPermissionLevelFromDefaultConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { isUntitledChatSession } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
 import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+import { computeWorkingDirectories, supportsMultipleWorkingDirectories, computeDesiredWorkingDirectories, hasImmutablePrimaryWorkingDirectory } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostNewSessionFolderService';
 import { IAgentHostNewSessionFolderService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostNewSessionFolderService.service';
+import { IAgentHostActiveClientService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostActiveClientService.service';
+import { IAgentHostImportConversationStore } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostImportConversationStore.service';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
 
+class ActiveClientBinding extends Disposable {
+    constructor(roots, scope, clientId, publish) {
+        super();
+        this.roots = roots;
+        this.scope = scope;
+        this._register(scope);
+        this._register(autorun(reader => {
+            if (!scope.isResolved.read(reader)) {
+                return;
+            }
+            scope.activeClient(clientId).read(reader);
+            publish();
+        }));
+    }
+}
 let AgentHostUntitledProvisionalSessionService = class AgentHostUntitledProvisionalSessionService extends Disposable {
     constructor(
         _agentHostService,
@@ -28,7 +56,11 @@ let AgentHostUntitledProvisionalSessionService = class AgentHostUntitledProvisio
         _configurationService,
         _environmentService,
         _newSessionFolderService,
-        _workspaceTrustManagementService
+        _workspaceContextService,
+        _workspaceTrustManagementService,
+        _importConversationStore,
+        _activeClientService,
+        _uriIdentityService
     ) {
         super();
         this._agentHostService = _agentHostService;
@@ -36,11 +68,17 @@ let AgentHostUntitledProvisionalSessionService = class AgentHostUntitledProvisio
         this._configurationService = _configurationService;
         this._environmentService = _environmentService;
         this._newSessionFolderService = _newSessionFolderService;
+        this._workspaceContextService = _workspaceContextService;
         this._workspaceTrustManagementService = _workspaceTrustManagementService;
+        this._importConversationStore = _importConversationStore;
+        this._activeClientService = _activeClientService;
+        this._uriIdentityService = _uriIdentityService;
         this._entries = ( new ResourceMap());
         this._pending = ( new ResourceMap());
         this._resolvedConfigs = ( new ResourceMap());
         this._resolvedConfigRequestSeq = ( new ResourceMap());
+        this._sessionCreationMetadata = ( new ResourceMap());
+        this._pendingBackendDisposals = ( new ResourceSet());
         this._rebound = ( new ResourceSet());
         this._sequencer = ( new SequencerByKey());
         this._onDidChange = this._register(( new Emitter()));
@@ -52,6 +90,7 @@ let AgentHostUntitledProvisionalSessionService = class AgentHostUntitledProvisio
                 }
                 this._resolvedConfigs.delete(sessionResource);
                 this._resolvedConfigRequestSeq.delete(sessionResource);
+                this._sessionCreationMetadata.delete(sessionResource);
                 this._rebound.delete(sessionResource);
             }
         }));
@@ -61,16 +100,128 @@ let AgentHostUntitledProvisionalSessionService = class AgentHostUntitledProvisio
                 void this._changeWorkingDirectory(sessionResource, folder);
             }
         }));
+        this._register(this._workspaceContextService.onDidChangeWorkspaceFolders(e => {
+            for (const [sessionResource, entry] of this._entries) {
+                if (entry.disposed) {
+                    continue;
+                }
+                if (isUntitledChatSession(sessionResource) && this._primaryWasRemoved(entry, e)) {
+                    void this._changeWorkingDirectory(
+                        sessionResource,
+                        this._newSessionFolderService.resolveNewSessionPrimary(sessionResource)
+                    );
+                    continue;
+                }
+                this._reconcileWorkspaceRootSet(sessionResource, entry);
+            }
+        }));
+        const rootStateListeners = this._register(( new DisposableStore()));
+        const bindRootState = () => {
+            rootStateListeners.clear();
+            rootStateListeners.add(
+                this._agentHostService.rootState.onDidChange(() => this._reconcileUntitledDraftsForRootSet())
+            );
+            this._reconcileUntitledDraftsForRootSet();
+        };
+        bindRootState();
+        this._register(this._agentHostService.onAgentHostStart(bindRootState));
+        this._register(
+            this._agentHostService.onAgentHostStart(() => this._retryPendingBackendDisposals())
+        );
     }
     get(sessionResource) {
-        return this._entries.get(sessionResource)?.backendSession;
+        const entry = this._entries.get(sessionResource);
+        if (!entry || entry.disposed) {
+            return undefined;
+        }
+        return this._generationMatchingDesiredState(entry)?.backendSession;
+    }
+    getProvisionalWorkingDirectories(sessionResource) {
+        const entry = this._entries.get(sessionResource);
+        if (!entry || entry.disposed) {
+            return undefined;
+        }
+        return this._generationMatchingDesiredState(entry)?.workingDirectories;
+    }
+    _computeWorkingDirectories(primary, provider) {
+        return computeWorkingDirectories(primary, ( this._workspaceContextService.getWorkspace().folders.map(folder => folder.uri)), this._agentHostService.rootState.value, provider);
+    }
+    _computeEntryWorkingDirectories(entry) {
+        const primary = entry.workingDirectory;
+        if (!primary || !entry.usesWorkspaceRootSet || !supportsMultipleWorkingDirectories(this._agentHostService.rootState.value, entry.provider)) {
+            return primary ? [primary] : undefined;
+        }
+        const current = entry.generation?.workingDirectories ?? [primary];
+        return computeDesiredWorkingDirectories(primary, current, ( this._workspaceContextService.getWorkspace().folders.map(folder => folder.uri)));
+    }
+    _updateActiveClientScope(entry) {
+        const roots = this._computeEntryWorkingDirectories(entry) ?? [];
+        if (entry.activeClientBinding.value && this._activeClientService.areScopeRootsEqual(entry.activeClientBinding.value.roots, roots)) {
+            return;
+        }
+        const scope = this._activeClientService.acquireScope(`agent-host-${entry.provider}`, roots);
+        entry.activeClientBinding.value = ( new ActiveClientBinding(
+            roots,
+            scope,
+            this._agentHostService.clientId,
+            () => this._publishActiveClient(entry)
+        ));
+    }
+    _reconcileUntitledDraftsForRootSet() {
+        for (const [sessionResource, entry] of this._entries) {
+            if (entry.disposed || !isUntitledChatSession(sessionResource)) {
+                continue;
+            }
+            this._reconcileWorkspaceRootSet(sessionResource, entry);
+        }
+    }
+    _reconcileWorkspaceRootSet(sessionResource, entry) {
+        if (!entry.usesWorkspaceRootSet && (this._computeWorkingDirectories(entry.workingDirectory, entry.provider)?.length ?? 0) > 1) {
+            entry.usesWorkspaceRootSet = true;
+        }
+        this._updateActiveClientScope(entry);
+        if (entry.usesWorkspaceRootSet && !this._generationMatchingDesiredState(entry)) {
+            void this._queue(sessionResource, () => this._reconcileGeneration(sessionResource, entry));
+        }
+    }
+    getInitialSessionMetadata(sessionResource) {
+        const workspace = this._workspaceContextService.getWorkspace();
+        const workspaceMetadata = this._environmentService.isSessionsWindow || this._workspaceContextService.getWorkbenchState() !== WorkbenchState.WORKSPACE || !URI.isUri(workspace.configuration) ? undefined : withSessionMultiRootMetadata(undefined, {
+            workspaceFile: ( workspace.configuration.toString())
+        });
+        const sessionMetadata = sessionResource ? this._sessionCreationMetadata.get(sessionResource) : undefined;
+        if (!sessionMetadata) {
+            return workspaceMetadata;
+        }
+        return {
+            ...(workspaceMetadata ?? {}),
+            ...sessionMetadata
+        };
+    }
+    setSessionCreationMetadata(sessionResource, metadata) {
+        this._sessionCreationMetadata.set(sessionResource, metadata);
+    }
+    clearSessionCreationMetadata(sessionResource) {
+        this._sessionCreationMetadata.delete(sessionResource);
+    }
+    getInitialSessionConfig() {
+        return this._getInitialConfig();
     }
     async waitForPending(sessionResource) {
-        const inflight = this._pending.get(sessionResource);
-        if (inflight) {
-            await inflight;
+        while (true) {
+            const pending = this._pending.get(sessionResource);
+            if (!pending) {
+                return this.get(sessionResource);
+            }
+            try {
+                await pending;
+            } catch {
+                return undefined;
+            }
+            if (this._pending.get(sessionResource) === pending) {
+                return this.get(sessionResource);
+            }
         }
-        return this.get(sessionResource);
     }
     getOrCreate(sessionResource, provider, workingDirectory) {
         const existing = this.get(sessionResource);
@@ -82,48 +233,187 @@ let AgentHostUntitledProvisionalSessionService = class AgentHostUntitledProvisio
         }
         const inflight = this._pending.get(sessionResource);
         if (inflight) {
-            return inflight;
+            return inflight.then(() => this.get(sessionResource));
+        }
+        const entry = this._ensureEntry(sessionResource, provider, workingDirectory);
+        if (!entry) {
+            return Promise.resolve(undefined);
         }
-        const work = this._sequencer.queue(( sessionResource.toString()), async () => {
+        return this._queue(sessionResource, async () => {
             const settled = this.get(sessionResource);
             if (settled) {
                 return settled;
             }
+            return this._reconcileGeneration(sessionResource, entry);
+        });
+    }
+    _ensureEntry(sessionResource, provider, workingDirectory) {
+        const existing = this._entries.get(sessionResource);
+        if (existing) {
+            return existing;
+        }
+        if (( this._rebound.has(sessionResource))) {
+            return undefined;
+        }
+        const entry = this._createEntry(provider, {
+            ...(this._getInitialConfig() ?? {})
+        }, 0, workingDirectory);
+        this._entries.set(sessionResource, entry);
+        return entry;
+    }
+    _createEntry(provider, config, configVersion, workingDirectory, resolvedConfig) {
+        const entry = {
+            provider,
+            activeClientBinding: ( new MutableDisposable()),
+            generation: undefined,
+            config,
+            configVersion,
+            workingDirectory,
+            usesWorkspaceRootSet: (this._computeWorkingDirectories(workingDirectory, provider)?.length ?? 0) > 1,
+            resolvedConfig,
+            disposed: false
+        };
+        this._updateActiveClientScope(entry);
+        return entry;
+    }
+    _publishActiveClient(entry) {
+        if (entry.disposed || !entry.generation) {
+            return;
+        }
+        const scope = entry.activeClientBinding.value?.scope;
+        if (!scope || !scope.isResolved.get()) {
+            return;
+        }
+        const activeClient = scope.activeClient(this._agentHostService.clientId).get();
+        this._agentHostService.dispatch(( entry.generation.backendSession.toString()), {
+            type: ActionType.SessionActiveClientSet,
+            activeClient
+        });
+    }
+    _queue(sessionResource, task) {
+        const work = this._sequencer.queue(( sessionResource.toString()), task);
+        this._pending.set(sessionResource, work);
+        void work.finally(() => {
+            if (this._pending.get(sessionResource) === work) {
+                this._pending.delete(sessionResource);
+            }
+        }).catch(() => {});
+        return work;
+    }
+    _generationMatchingDesiredState(entry) {
+        const generation = entry.generation;
+        const desired = this._computeEntryWorkingDirectories(entry);
+        return generation && this._sameUri(generation.workingDirectory, entry.workingDirectory) && this._sameWorkingDirectories(entry.provider, generation.workingDirectories, desired) ? generation : undefined;
+    }
+    _sameUri(first, second) {
+        return first === undefined || second === undefined ? first === second : isEqual(first, second);
+    }
+    _primaryWasRemoved(entry, e) {
+        const primary = entry.workingDirectory;
+        if (!primary || e.removed.length === 0) {
+            return false;
+        }
+        const extUri = this._uriIdentityService.extUri;
+        const stillPresent = ( this._workspaceContextService.getWorkspace().folders.some(folder => extUri.isEqual(folder.uri, primary)));
+        return !stillPresent && ( e.removed.some(removed => extUri.isEqual(removed.uri, primary)));
+    }
+    _sameWorkingDirectories(provider, first, second) {
+        return areSessionWorkingDirectoriesEqual(
+            first,
+            second,
+            hasImmutablePrimaryWorkingDirectory(this._agentHostService.rootState.value, provider)
+        );
+    }
+    _newProvisionalUri(provider) {
+        return ( URI.from({
+            scheme: provider,
+            path: `/${generateUuid()}`
+        }));
+    }
+    async _reconcileGeneration(sessionResource, entry) {
+        while (this._entries.get(sessionResource) === entry && !entry.disposed) {
+            const currentGeneration = this._generationMatchingDesiredState(entry);
+            if (currentGeneration) {
+                return currentGeneration.backendSession;
+            }
+            const workingDirectory = entry.workingDirectory;
+            const workingDirectories = this._computeEntryWorkingDirectories(entry);
+            const configVersion = entry.configVersion;
+            const config = {
+                ...entry.config
+            };
             if (!(await this._isTargetFolderTrusted(workingDirectory))) {
+                await this._retireGeneration(sessionResource, entry);
                 return undefined;
             }
-            const backendSession = this._toBackendUri(sessionResource, provider);
-            const initialConfig = this._getInitialConfig();
+            const candidate = this._newProvisionalUri(entry.provider);
+            let created;
             try {
-                const created = await this._agentHostService.createSession({
-                    provider,
-                    session: backendSession,
-                    workingDirectory,
-                    config: initialConfig
-                });
-                this._entries.set(sessionResource, {
-                    backendSession: created,
-                    config: {
-                        ...(initialConfig ?? {})
-                    },
-                    workingDirectory
+                created = await this._agentHostService.createSession({
+                    provider: entry.provider,
+                    session: candidate,
+                    _meta: this.getInitialSessionMetadata(),
+                    workingDirectories,
+                    config,
+                    progressToken: generateUuid()
                 });
-                this._onDidChange.fire(sessionResource);
-                return created;
             } catch (err) {
                 this._logService.warn(
                     `[AgentHostProvisional] Failed to create provisional session for ${( sessionResource.toString())}: ${err instanceof Error ? err.message : String(err)}`
                 );
+                await this._disposeBackend(candidate, "failed provisional candidate");
+                await this._retireGeneration(sessionResource, entry);
                 return undefined;
             }
-        });
-        this._pending.set(sessionResource, work);
-        work.finally(() => {
-            if (this._pending.get(sessionResource) === work) {
-                this._pending.delete(sessionResource);
+            if (this._entries.get(sessionResource) !== entry || entry.disposed || entry.configVersion !== configVersion || !this._sameUri(entry.workingDirectory, workingDirectory) || !this._sameWorkingDirectories(
+                entry.provider,
+                this._computeEntryWorkingDirectories(entry),
+                workingDirectories
+            )) {
+                await this._disposeBackend(created, "obsolete provisional candidate");
+                continue;
             }
-        });
-        return work;
+            const previous = entry.generation;
+            entry.generation = {
+                backendSession: created,
+                workingDirectory,
+                workingDirectories
+            };
+            this._publishActiveClient(entry);
+            this._onDidChange.fire(sessionResource);
+            if (previous) {
+                await this._disposeBackend(previous.backendSession, "replaced provisional generation");
+            }
+            return created;
+        }
+        return undefined;
+    }
+    async _retireGeneration(sessionResource, entry) {
+        const generation = entry.generation;
+        if (!generation) {
+            return;
+        }
+        entry.generation = undefined;
+        if (this._entries.get(sessionResource) === entry) {
+            this._onDidChange.fire(sessionResource);
+        }
+        await this._disposeBackend(generation.backendSession, "retired provisional generation");
+    }
+    async _disposeBackend(backendSession, reason) {
+        this._pendingBackendDisposals.add(backendSession);
+        try {
+            await this._agentHostService.disposeSession(backendSession);
+            this._pendingBackendDisposals.delete(backendSession);
+            return true;
+        } catch (err) {
+            this._logService.warn(`[AgentHostProvisional] Failed to dispose ${reason} ${( backendSession.toString())}: ${err instanceof Error ? err.message : String(err)}`);
+            return false;
+        }
+    }
+    _retryPendingBackendDisposals() {
+        for (const backendSession of this._pendingBackendDisposals) {
+            void this._disposeBackend(backendSession, "pending provisional cleanup");
+        }
     }
     async _isTargetFolderTrusted(workingDirectory) {
         if (workingDirectory) {
@@ -134,109 +424,148 @@ let AgentHostUntitledProvisionalSessionService = class AgentHostUntitledProvisio
         }
         return this._workspaceTrustManagementService.isWorkspaceTrusted();
     }
-    async tryRebind(oldSessionResource, newSessionResource, provider, workingDirectory) {
-        const alreadyBound = this.get(newSessionResource);
-        if (alreadyBound) {
-            return alreadyBound;
-        }
-        await this.waitForPending(oldSessionResource);
-        const oldEntry = this._entries.get(oldSessionResource);
-        if (!oldEntry) {
-            return undefined;
-        }
-        const config = oldEntry.config;
-        const newBackendSession = this._toBackendUri(newSessionResource, provider);
-        let created;
-        try {
-            created = await this._agentHostService.createSession({
-                provider,
-                session: newBackendSession,
-                workingDirectory,
-                config
-            });
-        } catch (err) {
-            this._logService.warn(
-                `[AgentHostProvisional] Failed to create rebound provisional: ${err instanceof Error ? err.message : String(err)}`
-            );
+    tryRebind(oldSessionResource, newSessionResource, provider) {
+        return this._queue(oldSessionResource, async () => {
+            const alreadyBound = this.get(newSessionResource);
+            if (alreadyBound) {
+                return alreadyBound;
+            }
+            const oldEntry = this._entries.get(oldSessionResource);
+            if (!oldEntry || oldEntry.disposed) {
+                return undefined;
+            }
+            const newBackendSession = this._toBackendUri(newSessionResource, provider);
+            const imported = this._importConversationStore.take(newSessionResource);
+            while (this._entries.get(oldSessionResource) === oldEntry && !oldEntry.disposed) {
+                const config = {
+                    ...oldEntry.config
+                };
+                const configVersion = oldEntry.configVersion;
+                const targetWorkingDirectory = oldEntry.workingDirectory;
+                if (!oldEntry.usesWorkspaceRootSet && (this._computeWorkingDirectories(targetWorkingDirectory, provider)?.length ?? 0) > 1) {
+                    oldEntry.usesWorkspaceRootSet = true;
+                }
+                const targetWorkingDirectories = this._computeEntryWorkingDirectories(oldEntry);
+                let created;
+                try {
+                    created = await this._agentHostService.createSession({
+                        provider,
+                        session: newBackendSession,
+                        _meta: this.getInitialSessionMetadata(),
+                        workingDirectories: targetWorkingDirectories,
+                        config,
+                        ...(imported ? {
+                            model: imported.model,
+                            importConversation: {
+                                turns: imported.turns,
+                                model: imported.model
+                            }
+                        } : {}),
+                        progressToken: generateUuid()
+                    });
+                } catch (err) {
+                    this._logService.warn(
+                        `[AgentHostProvisional] Failed to create rebound provisional: ${err instanceof Error ? err.message : String(err)}`
+                    );
+                    this._restoreImportedConversation(newSessionResource, imported);
+                    const disposed = await this._disposeBackend(newBackendSession, "failed rebound candidate");
+                    if (!disposed) {
+                        throw ( new Error(`Cannot safely recover rebound session ${( newBackendSession.toString())} until its candidate is retired`));
+                    }
+                    return undefined;
+                }
+                if (this._entries.get(oldSessionResource) !== oldEntry || oldEntry.disposed) {
+                    const disposed = await this._disposeBackend(created, "retired rebound candidate");
+                    this._restoreImportedConversation(newSessionResource, imported);
+                    if (!disposed) {
+                        throw ( new Error(`Cannot safely recover rebound session ${( newBackendSession.toString())} until its candidate is retired`));
+                    }
+                    return undefined;
+                }
+                if (oldEntry.configVersion !== configVersion || !this._sameUri(oldEntry.workingDirectory, targetWorkingDirectory) || !this._sameWorkingDirectories(
+                    oldEntry.provider,
+                    this._computeEntryWorkingDirectories(oldEntry),
+                    targetWorkingDirectories
+                )) {
+                    const disposed = await this._disposeBackend(created, "obsolete rebound candidate");
+                    if (!disposed) {
+                        this._restoreImportedConversation(newSessionResource, imported);
+                        throw ( new Error(`Cannot safely retry rebound session ${( newBackendSession.toString())} until its stale candidate is retired`));
+                    }
+                    continue;
+                }
+                const oldGeneration = oldEntry.generation;
+                const newEntry = this._createEntry(
+                    provider,
+                    config,
+                    configVersion,
+                    targetWorkingDirectory,
+                    oldEntry.resolvedConfig
+                );
+                newEntry.usesWorkspaceRootSet = oldEntry.usesWorkspaceRootSet;
+                this._updateActiveClientScope(newEntry);
+                newEntry.generation = {
+                    backendSession: created,
+                    workingDirectory: targetWorkingDirectory,
+                    workingDirectories: targetWorkingDirectories
+                };
+                this._entries.set(newSessionResource, newEntry);
+                this._publishActiveClient(newEntry);
+                this._entries.delete(oldSessionResource);
+                oldEntry.disposed = true;
+                oldEntry.activeClientBinding.dispose();
+                this._resolvedConfigs.delete(oldSessionResource);
+                this._resolvedConfigRequestSeq.delete(oldSessionResource);
+                this._rebound.add(oldSessionResource);
+                this._onDidChange.fire(newSessionResource);
+                if (oldGeneration) {
+                    await this._disposeBackend(oldGeneration.backendSession, "temporary provisional generation");
+                }
+                return created;
+            }
+            this._restoreImportedConversation(newSessionResource, imported);
             return undefined;
-        }
-        this._entries.set(newSessionResource, {
-            backendSession: created,
-            config: {
-                ...config
-            },
-            workingDirectory,
-            resolvedConfig: oldEntry.resolvedConfig
         });
-        this._entries.delete(oldSessionResource);
-        this._resolvedConfigs.delete(oldSessionResource);
-        this._resolvedConfigRequestSeq.delete(oldSessionResource);
-        this._rebound.add(oldSessionResource);
-        this._onDidChange.fire(newSessionResource);
-        this._agentHostService.disposeSession(oldEntry.backendSession).catch(err => {
-            this._logService.warn(
-                `[AgentHostProvisional] Failed to dispose temporary provisional ${( oldEntry.backendSession.toString())}: ${err instanceof Error ? err.message : String(err)}`
-            );
-        });
-        return created;
+    }
+    _restoreImportedConversation(sessionResource, imported) {
+        if (imported) {
+            this._importConversationStore.set(sessionResource, imported);
+        }
     }
     _changeWorkingDirectory(sessionResource, newWorkingDirectory) {
-        return this._sequencer.queue(( sessionResource.toString()), async () => {
-            const entry = this._entries.get(sessionResource);
-            if (!entry) {
+        const entry = this._entries.get(sessionResource);
+        if (!entry || entry.disposed || this._sameUri(entry.workingDirectory, newWorkingDirectory)) {
+            return Promise.resolve();
+        }
+        entry.workingDirectory = newWorkingDirectory;
+        entry.usesWorkspaceRootSet = (this._computeWorkingDirectories(newWorkingDirectory, entry.provider)?.length ?? 0) > 1;
+        this._updateActiveClientScope(entry);
+        entry.configVersion++;
+        entry.resolvedConfig = undefined;
+        const work = this._queue(sessionResource, async () => {
+            if (this._entries.get(sessionResource) !== entry || entry.disposed) {
                 return;
             }
-            if (entry.workingDirectory?.toString() === ( newWorkingDirectory.toString())) {
+            const backend = await this._reconcileGeneration(sessionResource, entry);
+            if (!backend) {
                 return;
             }
-            const provider = entry.backendSession.scheme;
-            const config = {
-                ...entry.config
-            };
-            try {
-                await this._agentHostService.disposeSession(entry.backendSession);
-            } catch (err) {
-                this._logService.warn(
-                    `[AgentHostProvisional] Failed to dispose provisional before cwd change ${( entry.backendSession.toString())}: ${err instanceof Error ? err.message : String(err)}`
-                );
-            }
-            let created;
-            try {
-                created = await this._agentHostService.createSession({
-                    provider,
-                    session: entry.backendSession,
-                    workingDirectory: newWorkingDirectory,
-                    config
-                });
-            } catch (err) {
-                this._logService.warn(
-                    `[AgentHostProvisional] Failed to recreate provisional at new cwd: ${err instanceof Error ? err.message : String(err)}`
-                );
-                this._entries.delete(sessionResource);
-                this._onDidChange.fire(sessionResource);
-                return;
-            }
-            this._entries.set(sessionResource, {
-                backendSession: created,
-                config,
-                workingDirectory: newWorkingDirectory,
-                resolvedConfig: entry.resolvedConfig
-            });
+            const configVersion = entry.configVersion;
+            const workingDirectory = entry.workingDirectory;
             try {
                 const resolved = await this._agentHostService.resolveSessionConfig({
-                    provider,
-                    workingDirectory: newWorkingDirectory,
+                    provider: entry.provider,
+                    workingDirectory,
                     config: {
-                        ...config
+                        ...entry.config
                     }
                 });
-                const current = this._entries.get(sessionResource);
-                if (current && ( current.backendSession.toString()) === ( created.toString())) {
-                    current.config = {
-                        ...current.config,
+                if (this._entries.get(sessionResource) === entry && !entry.disposed && entry.configVersion === configVersion && this._sameUri(entry.workingDirectory, workingDirectory)) {
+                    entry.config = {
+                        ...entry.config,
                         ...resolved.values
                     };
-                    current.resolvedConfig = resolved;
+                    entry.resolvedConfig = resolved;
                 }
             } catch (err) {
                 this._logService.warn(
@@ -245,31 +574,45 @@ let AgentHostUntitledProvisionalSessionService = class AgentHostUntitledProvisio
             }
             this._onDidChange.fire(sessionResource);
         });
+        this._onDidChange.fire(sessionResource);
+        return work;
     }
-    async disposeSession(sessionResource) {
-        await this.waitForPending(sessionResource);
+    disposeSession(sessionResource) {
         const entry = this._entries.get(sessionResource);
         this._resolvedConfigs.delete(sessionResource);
         this._resolvedConfigRequestSeq.delete(sessionResource);
+        this._sessionCreationMetadata.delete(sessionResource);
         if (!entry) {
-            return;
+            return Promise.resolve();
         }
+        entry.disposed = true;
+        entry.activeClientBinding.dispose();
         this._entries.delete(sessionResource);
         this._onDidChange.fire(sessionResource);
-        try {
-            await this._agentHostService.disposeSession(entry.backendSession);
-        } catch (err) {
-            this._logService.warn(`[AgentHostProvisional] Failed to dispose provisional ${( entry.backendSession.toString())}: ${err instanceof Error ? err.message : String(err)}`);
-        }
+        return this._queue(sessionResource, async () => {
+            if (entry.generation) {
+                await this._disposeBackend(entry.generation.backendSession, "provisional generation");
+                entry.generation = undefined;
+            }
+        });
     }
     dispose() {
         for (const [, entry] of this._entries) {
-            this._agentHostService.disposeSession(entry.backendSession).catch(() => {});
+            entry.disposed = true;
+            entry.activeClientBinding.dispose();
+            if (entry.generation) {
+                this._agentHostService.disposeSession(entry.generation.backendSession).catch(() => {});
+            }
+        }
+        for (const backendSession of this._pendingBackendDisposals) {
+            this._agentHostService.disposeSession(backendSession).catch(() => {});
         }
         this._entries.clear();
         this._pending.clear();
+        this._pendingBackendDisposals.clear();
         this._resolvedConfigs.clear();
         this._resolvedConfigRequestSeq.clear();
+        this._sessionCreationMetadata.clear();
         this._rebound.clear();
         super.dispose();
     }
@@ -313,60 +656,57 @@ let AgentHostUntitledProvisionalSessionService = class AgentHostUntitledProvisio
         }
     }
     async applyConfigChange(sessionResource, provider, workingDirectory, partial) {
-        const preExisting = this._entries.get(sessionResource);
-        if (preExisting) {
-            Object.assign(preExisting.config, partial);
-            if (preExisting.resolvedConfig) {
-                preExisting.resolvedConfig = {
-                    ...preExisting.resolvedConfig,
-                    values: {
-                        ...preExisting.resolvedConfig.values,
-                        ...partial
-                    }
-                };
-            }
-        }
-        const backend = await this.getOrCreate(sessionResource, provider, workingDirectory);
-        if (!backend) {
+        const entry = this._ensureEntry(sessionResource, provider, workingDirectory);
+        if (!entry) {
             return undefined;
         }
-        if (!preExisting) {
-            const entry = this._entries.get(sessionResource);
-            if (entry) {
-                Object.assign(entry.config, partial);
-            }
+        Object.assign(entry.config, partial);
+        entry.configVersion++;
+        if (entry.resolvedConfig) {
+            entry.resolvedConfig = {
+                ...entry.resolvedConfig,
+                values: {
+                    ...entry.resolvedConfig.values,
+                    ...partial
+                }
+            };
         }
-        this._agentHostService.dispatch(( backend.toString()), {
-            type: ActionType.SessionConfigChanged,
-            config: partial
-        });
-        return this._sequencer.queue(( sessionResource.toString()), async () => {
-            const current = this._entries.get(sessionResource);
-            if (!current) {
-                return backend;
+        return this._queue(sessionResource, async () => {
+            if (this._entries.get(sessionResource) !== entry || entry.disposed) {
+                return undefined;
+            }
+            const backend = await this._reconcileGeneration(sessionResource, entry);
+            if (!backend || this._entries.get(sessionResource) !== entry || entry.disposed) {
+                return undefined;
             }
+            this._agentHostService.dispatch(( backend.toString()), {
+                type: ActionType.SessionConfigChanged,
+                config: partial
+            });
+            const configVersion = entry.configVersion;
+            const resolvedWorkingDirectory = entry.workingDirectory;
             try {
                 const resolved = await this._agentHostService.resolveSessionConfig({
                     provider,
-                    workingDirectory,
+                    workingDirectory: resolvedWorkingDirectory,
                     config: {
-                        ...current.config
+                        ...entry.config
                     }
                 });
                 const stillCurrent = this._entries.get(sessionResource);
-                if (stillCurrent === current) {
+                if (stillCurrent === entry && !entry.disposed && entry.configVersion === configVersion && this._sameUri(entry.workingDirectory, resolvedWorkingDirectory)) {
                     const resolvedValues = {
                         ...resolved.values
                     };
                     const mergedConfig = {
-                        ...stillCurrent.config,
+                        ...entry.config,
                         ...resolvedValues
                     };
-                    const configChanged = !equals(stillCurrent.config, mergedConfig);
-                    const resolvedChanged = !equals(stillCurrent.resolvedConfig, resolved);
+                    const configChanged = !equals(entry.config, mergedConfig);
+                    const resolvedChanged = !equals(entry.resolvedConfig, resolved);
                     if (configChanged || resolvedChanged) {
-                        stillCurrent.config = mergedConfig;
-                        stillCurrent.resolvedConfig = resolved;
+                        entry.config = mergedConfig;
+                        entry.resolvedConfig = resolved;
                         this._onDidChange.fire(sessionResource);
                     }
                 }
@@ -387,8 +727,8 @@ let AgentHostUntitledProvisionalSessionService = class AgentHostUntitledProvisio
         };
         const configuredDefaults = this._configurationService.getValue(ChatConfiguration.DefaultConfiguration);
         const policyValue = this._configurationService.inspect(ChatConfiguration.GlobalAutoApprove).policyValue;
-        const configuredApprovals = configuredDefaults?.approvals;
-        if (typeof configuredApprovals === "string" && ( KNOWN_AUTO_APPROVE_VALUES.has(configuredApprovals))) {
+        const configuredApprovals = getChatPermissionLevelFromDefaultConfiguration(configuredDefaults?.approvals);
+        if (configuredApprovals) {
             const policyRestricted = policyValue === false;
             config[SessionConfigKey.AutoApprove] = policyRestricted && configuredApprovals !== "default" ? "default" : configuredApprovals;
         }
@@ -399,6 +739,6 @@ let AgentHostUntitledProvisionalSessionService = class AgentHostUntitledProvisio
         return migrateLegacyAutopilotConfig(config);
     }
 };
-AgentHostUntitledProvisionalSessionService = ( __decorate([( __param(0, IAgentHostService)), ( __param(1, ILogService)), ( __param(2, IChatService)), ( __param(3, IConfigurationService)), ( __param(4, IWorkbenchEnvironmentService)), ( __param(5, IAgentHostNewSessionFolderService)), ( __param(6, IWorkspaceTrustManagementService))], AgentHostUntitledProvisionalSessionService));
+AgentHostUntitledProvisionalSessionService = ( __decorate([( __param(0, IAgentHostService)), ( __param(1, ILogService)), ( __param(2, IChatService)), ( __param(3, IConfigurationService)), ( __param(4, IWorkbenchEnvironmentService)), ( __param(5, IAgentHostNewSessionFolderService)), ( __param(6, IWorkspaceContextService)), ( __param(7, IWorkspaceTrustManagementService)), ( __param(8, IAgentHostImportConversationStore)), ( __param(9, IAgentHostActiveClientService)), ( __param(10, IUriIdentityService))], AgentHostUntitledProvisionalSessionService));
 
 export { AgentHostUntitledProvisionalSessionService };