@codingame/monaco-vscode-chat-service-override 23.2.2 → 24.1.0

package/vscode/src/vs/workbench/contrib/chat/common/chatServiceImpl.js

@@ -3,17 +3,18 @@ import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib
 import { DeferredPromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
 import { CancellationToken, CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 import { toErrorMessage } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errorMessage';
-import { ErrorNoTelemetry } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { ErrorNoTelemetry, BugIndicatingError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
 import { Iterable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/iterator';
-import { Disposable, DisposableMap, DisposableStore, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Disposable, DisposableResourceMap, DisposableStore, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { revive } from '@codingame/monaco-vscode-api/vscode/vs/base/common/marshalling';
 import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 import { StopWatch } from '@codingame/monaco-vscode-api/vscode/vs/base/common/stopwatch';
 import { isDefined } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
 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 { OffsetRange } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/ranges/offsetRange';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
@@ -24,12 +25,16 @@ import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode
 import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
 import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
 import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
+import { InlineChatConfigKeys } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
 import { IMcpService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service';
+import { awaitStatsForSession } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chat';
 import { IChatAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents.service';
-import { normalizeSerializableChatData, ChatModel, ChatRequestRemovalReason, updateRanges, toChatHistoryContent, ChatRequestModel } from '@codingame/monaco-vscode-2339d6ac-d6bb-53cd-95ee-81911735d1c7-common/vscode/vs/workbench/contrib/chat/common/chatModel';
-import { ChatRequestTextPart, ChatRequestAgentPart, ChatRequestAgentSubcommandPart, chatSubcommandLeader, chatAgentLeader, ChatRequestSlashCommandPart, getPromptText } from '@codingame/monaco-vscode-aac7027b-326c-513a-95a9-e4eedd151b38-common/vscode/vs/workbench/contrib/chat/common/chatParserTypes';
-import { ChatRequestParser } from '@codingame/monaco-vscode-bc6f260d-ec63-5c95-9446-1ca7d0872719-common/vscode/vs/workbench/contrib/chat/common/chatRequestParser';
-import { ChatMcpServersStarting } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService';
+import { chatEditingSessionIsReady } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService';
+import { normalizeSerializableChatData, ChatModel, ChatRequestRemovalReason, updateRanges, toChatHistoryContent, ChatRequestModel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModel';
+import { ChatModelStore } from './chatModelStore.js';
+import { ChatRequestTextPart, ChatRequestAgentPart, ChatRequestAgentSubcommandPart, chatSubcommandLeader, chatAgentLeader, ChatRequestSlashCommandPart, getPromptText } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatParserTypes';
+import { ChatRequestParser } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatRequestParser';
+import { ResponseModelState, ChatMcpServersStarting } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService';
 import { ChatServiceTelemetry, ChatRequestTelemetry } from './chatServiceTelemetry.js';
 import { IChatSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service';
 import { ChatSessionStore } from './chatSessionStore.js';
@@ -41,7 +46,6 @@ import { ChatMessageRole } from '@codingame/monaco-vscode-api/vscode/vs/workbenc
 import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.service';
 import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
 import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
-import { ObservableMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/map';
 
 const serializedChatKey = 'interactive.sessions';
 const TransferredGlobalChatKey = 'chat.workspaceTransfer';
@@ -65,60 +69,16 @@ let CancellableRequest = class CancellableRequest {
 CancellableRequest = ( __decorate([
     ( __param(2, ILanguageModelToolsService))
 ], CancellableRequest));
-class ChatModelStore {
-    constructor() {
-        this._models = ( new ObservableMap());
-    }
-    get observable() {
-        return this._models.observable;
-    }
-    values() {
-        return ( this._models.values());
-    }
-    get(uri) {
-        return this._models.get(this.toKey(uri));
-    }
-    has(uri) {
-        return ( this._models.has(this.toKey(uri)));
-    }
-    set(uri, value) {
-        this._models.set(this.toKey(uri), value);
-    }
-    delete(uri) {
-        return this._models.delete(this.toKey(uri));
-    }
-    toKey(uri) {
-        return ( uri.toString());
-    }
-}
-class DisposableResourceMap extends Disposable {
-    constructor() {
-        super(...arguments);
-        this._map = this._register(( new DisposableMap()));
-    }
-    get(sessionResource) {
-        return this._map.get(this.toKey(sessionResource));
-    }
-    set(sessionResource, value) {
-        this._map.set(this.toKey(sessionResource), value);
-    }
-    has(sessionResource) {
-        return ( this._map.has(this.toKey(sessionResource)));
-    }
-    deleteAndLeak(sessionResource) {
-        return this._map.deleteAndLeak(this.toKey(sessionResource));
-    }
-    deleteAndDispose(sessionResource) {
-        this._map.deleteAndDispose(this.toKey(sessionResource));
-    }
-    toKey(uri) {
-        return ( uri.toString());
-    }
-}
 let ChatService = class ChatService extends Disposable {
     get transferredSessionData() {
         return this._transferredSessionData;
     }
+    setSaveModelsEnabled(enabled) {
+        this._saveModelsEnabled = enabled;
+    }
+    waitForModelDisposals() {
+        return this._sessionModels.waitForModelDisposals();
+    }
     get edits2Enabled() {
         return this.configurationService.getValue(ChatConfiguration.Edits2Enabled);
     }
@@ -139,9 +99,8 @@ let ChatService = class ChatService extends Disposable {
         this.chatTransferService = chatTransferService;
         this.chatSessionService = chatSessionService;
         this.mcpService = mcpService;
-        this._sessionModels = ( new ChatModelStore());
-        this._contentProviderSessionModels = this._register(( new DisposableResourceMap()));
         this._pendingRequests = this._register(( new DisposableResourceMap()));
+        this._saveModelsEnabled = true;
         this._onDidSubmitRequest = this._register(( new Emitter()));
         this.onDidSubmitRequest = this._onDidSubmitRequest.event;
         this._onDidPerformUserAction = this._register(( new Emitter()));
@@ -149,6 +108,26 @@ let ChatService = class ChatService extends Disposable {
         this._onDidDisposeSession = this._register(( new Emitter()));
         this.onDidDisposeSession = this._onDidDisposeSession.event;
         this._sessionFollowupCancelTokens = this._register(( new DisposableResourceMap()));
+        this._sessionModels = this._register(instantiationService.createInstance(ChatModelStore, {
+            createModel: (props) => this._startSession(props),
+            willDisposeModel: async (model) => {
+                const localSessionId = LocalChatSessionUri.parseLocalSessionId(model.sessionResource);
+                if (localSessionId && this.shouldStoreSession(model)) {
+                    if (model.getRequests().length === 0 && !model.customTitle) {
+                        await this._chatSessionStore.deleteSession(localSessionId);
+                    }
+                    else if (this._saveModelsEnabled) {
+                        await this._chatSessionStore.storeSessions([model]);
+                    }
+                }
+                else if (!localSessionId && model.getRequests().length > 0) {
+                    await this._chatSessionStore.storeSessionsMetadataOnly([model]);
+                }
+            }
+        }));
+        this._register(this._sessionModels.onDidDisposeModel(model => {
+            this._onDidDisposeSession.fire({ sessionResource: model.sessionResource, reason: 'cleared' });
+        }));
         this._chatServiceTelemetry = this.instantiationService.createInstance(ChatServiceTelemetry);
         const sessionData = storageService.get(serializedChatKey, this.isEmptyWindow ? StorageScope.APPLICATION : StorageScope.WORKSPACE, '');
         if (sessionData) {
@@ -168,18 +147,20 @@ let ChatService = class ChatService extends Disposable {
             this._persistedSessions[transferredChat.sessionId] = transferredChat;
             this._transferredSessionData = {
                 sessionId: transferredChat.sessionId,
-                inputValue: transferredData.inputValue,
                 location: transferredData.location,
-                mode: transferredData.mode,
+                inputState: transferredData.inputState
             };
         }
         this._chatSessionStore = this._register(this.instantiationService.createInstance(ChatSessionStore));
         this._chatSessionStore.migrateDataIfNeeded(() => this._persistedSessions);
-        this.initializePersistedSessionsFromFileStorage();
+        this.initializePersistedSessionsFromFileStorage().then(() => {
+            this.reviveSessionsWithEdits();
+        });
         this._register(storageService.onWillSaveState(() => this.saveState()));
+        this.chatModels = derived(this, reader => [...( this._sessionModels.observable.read(reader).values())]);
         this.requestInProgressObs = derived(reader => {
             const models = ( this._sessionModels.observable.read(reader).values());
-            return ( Array.from(models).some(model => model.requestInProgressObs.read(reader)));
+            return ( Iterable.some(models, model => model.requestInProgress.read(reader)));
         });
     }
     get editingSessions() {
@@ -189,14 +170,21 @@ let ChatService = class ChatService extends Disposable {
         return this.chatAgentService.getContributedDefaultAgent(location) !== undefined;
     }
     saveState() {
-        const liveChats = Array.from(( this._sessionModels.values()))
-            .filter(session => {
-            if (!LocalChatSessionUri.parseLocalSessionId(session.sessionResource)) {
-                return false;
-            }
-            return session.initialLocation === ChatAgentLocation.Chat;
-        });
-        this._chatSessionStore.storeSessions(liveChats);
+        if (!this._saveModelsEnabled) {
+            return;
+        }
+        const liveLocalChats = Array.from(( this._sessionModels.values()))
+            .filter(session => this.shouldStoreSession(session));
+        this._chatSessionStore.storeSessions(liveLocalChats);
+        const liveNonLocalChats = Array.from(( this._sessionModels.values()))
+            .filter(session => !LocalChatSessionUri.parseLocalSessionId(session.sessionResource));
+        this._chatSessionStore.storeSessionsMetadataOnly(liveNonLocalChats);
+    }
+    shouldStoreSession(session) {
+        if (!LocalChatSessionUri.parseLocalSessionId(session.sessionResource)) {
+            return false;
+        }
+        return session.initialLocation === ChatAgentLocation.Chat && !session.isImported;
     }
     notifyUserAction(action) {
         this._chatServiceTelemetry.notifyUserAction(action);
@@ -209,13 +197,15 @@ let ChatService = class ChatService extends Disposable {
         }
     }
     async setChatSessionTitle(sessionResource, title) {
-        const sessionId = this.toLocalSessionId(sessionResource);
         const model = this._sessionModels.get(sessionResource);
         if (model) {
             model.setCustomTitle(title);
         }
-        await this._chatSessionStore.setSessionTitle(sessionId, title);
-        this.saveState();
+        const localSessionId = LocalChatSessionUri.parseLocalSessionId(sessionResource);
+        if (localSessionId) {
+            await this._chatSessionStore.setSessionTitle(localSessionId, title);
+            this.saveState();
+        }
     }
     trace(method, message) {
         if (message) {
@@ -271,6 +261,19 @@ let ChatService = class ChatService extends Disposable {
         this.storageService.store(TransferredGlobalChatKey, JSON.stringify(filtered), StorageScope.PROFILE, StorageTarget.MACHINE);
         return transferred;
     }
+    async reviveSessionsWithEdits() {
+        await Promise.all(( ( Object.values(this._persistedSessions)).map(async (session) => {
+            if (!session.hasPendingEdits) {
+                return;
+            }
+            const sessionResource = LocalChatSessionUri.forSession(session.sessionId);
+            const sessionRef = await this.getOrRestoreSession(sessionResource);
+            if (sessionRef?.object.editingSession) {
+                await chatEditingSessionIsReady(sessionRef.object.editingSession);
+                sessionRef.dispose();
+            }
+        })));
+    }
     async initializePersistedSessionsFromFileStorage() {
         const index = await this._chatSessionStore.getIndex();
         const sessionIds = ( Object.keys(index));
@@ -283,48 +286,69 @@ let ChatService = class ChatService extends Disposable {
                     customTitle: metadata.title,
                     creationDate: Date.now(),
                     lastMessageDate: metadata.lastMessageDate,
-                    isImported: metadata.isImported || false,
                     initialLocation: metadata.initialLocation,
                     requests: [],
-                    requesterUsername: '',
                     responderUsername: '',
-                    requesterAvatarIconUri: undefined,
                     responderAvatarIconUri: undefined,
+                    hasPendingEdits: metadata.hasPendingEdits,
                 };
                 this._persistedSessions[sessionId] = minimalSession;
             }
         }
     }
     async getLocalSessionHistory() {
-        const liveSessionItems = ( Array.from(( this._sessionModels.values()))
+        const liveSessionItems = await this.getLiveSessionItems();
+        const historySessionItems = await this.getHistorySessionItems();
+        return [...liveSessionItems, ...historySessionItems];
+    }
+    async getLiveSessionItems() {
+        return await Promise.all(( Array.from(( this._sessionModels.values()))
             .filter(session => this.shouldBeInHistory(session))
-            .map((session) => {
-            const title = session.title || ( localize(5826, "New Chat"));
+            .map(async (session) => {
+            const title = session.title || ( localize(5945, "New Chat"));
             return {
                 sessionResource: session.sessionResource,
                 title,
                 lastMessageDate: session.lastMessageDate,
+                timing: session.timing,
                 isActive: true,
+                stats: await awaitStatsForSession(session),
+                lastResponseState: session.lastRequest?.response?.state ?? ResponseModelState.Pending,
             };
-        }));
+        })));
+    }
+    async getHistorySessionItems() {
         const index = await this._chatSessionStore.getIndex();
-        const entries = ( ( Object.values(index))
-            .filter(entry => !( this._sessionModels.has(LocalChatSessionUri.forSession(entry.sessionId))) && this.shouldBeInHistory(entry) && !entry.isEmpty)
+        return ( ( Object.values(index))
+            .filter(entry => !entry.isExternal)
+            .filter(entry => !( this._sessionModels.has(LocalChatSessionUri.forSession(entry.sessionId))) && entry.initialLocation === ChatAgentLocation.Chat && !entry.isEmpty)
             .map((entry) => {
             const sessionResource = LocalChatSessionUri.forSession(entry.sessionId);
             return ({
                 ...entry,
                 sessionResource,
-                isActive: ( this._sessionModels.has(sessionResource))
+                timing: entry.timing ?? { startTime: entry.lastMessageDate },
+                isActive: ( this._sessionModels.has(sessionResource)),
+                lastResponseState: entry.lastResponseState ?? ResponseModelState.Complete
             });
         }));
-        return [...liveSessionItems, ...entries];
     }
-    shouldBeInHistory(entry) {
-        if (entry.sessionResource) {
-            return !entry.isImported && LocalChatSessionUri.parseLocalSessionId(entry.sessionResource) && entry.initialLocation !== ChatAgentLocation.EditorInline;
+    async getMetadataForSession(sessionResource) {
+        const index = await this._chatSessionStore.getIndex();
+        const metadata = index[( sessionResource.toString())];
+        if (metadata) {
+            return {
+                ...metadata,
+                sessionResource,
+                timing: metadata.timing ?? { startTime: metadata.lastMessageDate },
+                isActive: ( this._sessionModels.has(sessionResource)),
+                lastResponseState: metadata.lastResponseState ?? ResponseModelState.Complete,
+            };
         }
-        return !entry.isImported && entry.initialLocation !== ChatAgentLocation.EditorInline;
+        return undefined;
+    }
+    shouldBeInHistory(entry) {
+        return !entry.isImported && !!LocalChatSessionUri.parseLocalSessionId(entry.sessionResource) && entry.initialLocation === ChatAgentLocation.Chat;
     }
     async removeHistoryEntry(sessionResource) {
         await this._chatSessionStore.deleteSession(this.toLocalSessionId(sessionResource));
@@ -332,21 +356,30 @@ let ChatService = class ChatService extends Disposable {
     async clearAllHistoryEntries() {
         await this._chatSessionStore.clearAllSessions();
     }
-    startSession(location, token, isGlobalEditingSession = true, options) {
+    startSession(location, options) {
         this.trace('startSession');
-        return this._startSession(undefined, location, isGlobalEditingSession, token, options);
+        const sessionId = generateUuid();
+        const sessionResource = LocalChatSessionUri.forSession(sessionId);
+        return this._sessionModels.acquireOrCreate({
+            initialData: undefined,
+            location,
+            sessionResource,
+            sessionId,
+            canUseTools: options?.canUseTools ?? true,
+            disableBackgroundKeepAlive: options?.disableBackgroundKeepAlive
+        });
     }
-    _startSession(someSessionHistory, location, isGlobalEditingSession, token, options, transferEditingSession) {
-        const model = this.instantiationService.createInstance(ChatModel, someSessionHistory, { initialLocation: location, canUseTools: options?.canUseTools ?? true, resource: options?.sessionResource });
+    _startSession(props) {
+        const { initialData, location, sessionResource, sessionId, canUseTools, transferEditingSession, disableBackgroundKeepAlive, inputState } = props;
+        const model = this.instantiationService.createInstance(ChatModel, initialData, { initialLocation: location, canUseTools, resource: sessionResource, sessionId, disableBackgroundKeepAlive, inputState });
         if (location === ChatAgentLocation.Chat) {
-            model.startEditingSession(isGlobalEditingSession, transferEditingSession);
+            model.startEditingSession(true, transferEditingSession);
         }
-        this._sessionModels.set(model.sessionResource, model);
-        this.initializeSession(model, token);
+        this.initializeSession(model);
         return model;
     }
-    initializeSession(model, token) {
-        this.trace('initializeSession', `Initialize session ${model.sessionId}`);
+    initializeSession(model) {
+        this.trace('initializeSession', `Initialize session ${model.sessionResource}`);
         this.activateDefaultAgent(model.initialLocation).catch(e => this.logService.error(e));
     }
     async activateDefaultAgent(location) {
@@ -370,14 +403,14 @@ let ChatService = class ChatService extends Disposable {
     getSession(sessionResource) {
         return this._sessionModels.get(sessionResource);
     }
-    getSessionByLegacyId(sessionId) {
-        return Array.from(( this._sessionModels.values())).find(session => session.sessionId === sessionId);
+    getActiveSessionReference(sessionResource) {
+        return this._sessionModels.acquireExisting(sessionResource);
     }
     async getOrRestoreSession(sessionResource) {
         this.trace('getOrRestoreSession', `${sessionResource}`);
-        const model = this._sessionModels.get(sessionResource);
-        if (model) {
-            return model;
+        const existingRef = this._sessionModels.acquireExisting(sessionResource);
+        if (existingRef) {
+            return existingRef;
         }
         const sessionId = LocalChatSessionUri.parseLocalSessionId(sessionResource);
         if (!sessionId) {
@@ -393,12 +426,18 @@ let ChatService = class ChatService extends Disposable {
         if (!sessionData) {
             return undefined;
         }
-        const session = this._startSession(sessionData, sessionData.initialLocation ?? ChatAgentLocation.Chat, true, CancellationToken.None, { canUseTools: true, sessionResource });
+        const sessionRef = this._sessionModels.acquireOrCreate({
+            initialData: sessionData,
+            location: sessionData.initialLocation ?? ChatAgentLocation.Chat,
+            sessionResource,
+            sessionId,
+            canUseTools: true,
+        });
         const isTransferred = this.transferredSessionData?.sessionId === sessionId;
         if (isTransferred) {
             this._transferredSessionData = undefined;
         }
-        return session;
+        return sessionRef;
     }
     isPersistedSessionEmpty(sessionResource) {
         const sessionId = LocalChatSessionUri.parseLocalSessionId(sessionResource);
@@ -432,35 +471,50 @@ let ChatService = class ChatService extends Disposable {
         return undefined;
     }
     loadSessionFromContent(data) {
-        return this._startSession(data, data.initialLocation ?? ChatAgentLocation.Chat, true, CancellationToken.None);
+        const sessionId = 'sessionId' in data && data.sessionId ? data.sessionId : generateUuid();
+        const sessionResource = LocalChatSessionUri.forSession(sessionId);
+        return this._sessionModels.acquireOrCreate({
+            initialData: data,
+            location: data.initialLocation ?? ChatAgentLocation.Chat,
+            sessionResource,
+            sessionId,
+            canUseTools: true,
+        });
     }
     async loadSessionForResource(chatSessionResource, location, token) {
         if (chatSessionResource.scheme === Schemas.vscodeLocalChatSession) {
             return this.getOrRestoreSession(chatSessionResource);
         }
-        const existing = this._contentProviderSessionModels.get(chatSessionResource);
-        if (existing) {
-            return existing.model;
+        const existingRef = this._sessionModels.acquireExisting(chatSessionResource);
+        if (existingRef) {
+            return existingRef;
         }
         const providedSession = await this.chatSessionService.getOrCreateChatSession(chatSessionResource, CancellationToken.None);
         const chatSessionType = chatSessionResource.scheme;
-        const model = this._startSession(undefined, location, true, CancellationToken.None, { sessionResource: chatSessionResource, canUseTools: false }, providedSession.initialEditingSession);
-        model.setContributedChatSession({
+        const modelRef = this._sessionModels.acquireOrCreate({
+            initialData: undefined,
+            location,
+            sessionResource: chatSessionResource,
+            canUseTools: false,
+            transferEditingSession: providedSession.transferredState?.editingSession,
+            inputState: providedSession.transferredState?.inputState,
+        });
+        modelRef.object.setContributedChatSession({
             chatSessionResource,
             chatSessionType,
             isUntitled: chatSessionResource.path.startsWith('/untitled-')
         });
+        const model = modelRef.object;
         const disposables = ( new DisposableStore());
-        this._contentProviderSessionModels.set(chatSessionResource, { model, dispose: () => disposables.dispose() });
-        disposables.add(model.onDidDispose(() => {
-            this._contentProviderSessionModels.deleteAndDispose(chatSessionResource);
+        disposables.add(modelRef.object.onDidDispose(() => {
+            disposables.dispose();
             providedSession.dispose();
         }));
         let lastRequest;
         for (const message of providedSession.history) {
             if (message.type === 'request') {
                 if (lastRequest) {
-                    model.completeResponse(lastRequest);
+                    lastRequest.response?.completeResponseIfNeeded();
                 }
                 const requestText = message.prompt;
                 const parsedRequest = {
@@ -475,8 +529,8 @@ let ChatService = class ChatService extends Disposable {
                 undefined,
                 undefined,
                 undefined,
-                true
-                );
+                false,
+                undefined, undefined, message.id);
             }
             else {
                 if (lastRequest) {
@@ -486,6 +540,9 @@ let ChatService = class ChatService extends Disposable {
                 }
             }
         }
+        if (providedSession.isCompleteObs?.get()) {
+            lastRequest?.response?.completeResponseIfNeeded();
+        }
         if (providedSession.progressObs && lastRequest && providedSession.interruptActiveResponseCallback) {
             const initialCancellationRequest = this.instantiationService.createInstance(CancellableRequest, ( new CancellationTokenSource()), undefined);
             this._pendingRequests.set(model.sessionResource, initialCancellationRequest);
@@ -514,17 +571,18 @@ let ChatService = class ChatService extends Disposable {
                     lastProgressLength = progressArray.length;
                 }
                 if (isComplete) {
-                    model?.completeResponse(lastRequest);
+                    lastRequest.response?.completeResponseIfNeeded();
                     cancellationListener.clear();
                 }
             }));
         }
         else {
-            if (lastRequest) {
-                model.completeResponse(lastRequest);
+            if (lastRequest && model.editingSession) {
+                await chatEditingSessionIsReady(model.editingSession);
+                lastRequest.response?.completeResponseIfNeeded();
             }
         }
-        return model;
+        return modelRef;
     }
     getChatSessionFromInternalUri(sessionResource) {
         const model = this._sessionModels.get(sessionResource);
@@ -654,7 +712,7 @@ let ChatService = class ChatService extends Disposable {
                     const isLast = i === progress.length - 1;
                     const progressItem = progress[i];
                     if (progressItem.kind === 'markdownContent') {
-                        this.trace('sendRequest', `Provider returned progress for session ${model.sessionId}, ${progressItem.content.value.length} chars`);
+                        this.trace('sendRequest', `Provider returned progress for session ${model.sessionResource}, ${progressItem.content.value.length} chars`);
                     }
                     else {
                         this.trace('sendRequest', `Provider returned progress: ${JSON.stringify(progressItem)}`);
@@ -667,7 +725,7 @@ let ChatService = class ChatService extends Disposable {
             let detectedCommand;
             const stopWatch = ( new StopWatch(false));
             store.add(token.onCancellationRequested(() => {
-                this.trace('sendRequest', `Request for session ${model.sessionId} was cancelled`);
+                this.trace('sendRequest', `Request for session ${model.sessionResource} was cancelled`);
                 if (!request) {
                     return;
                 }
@@ -703,7 +761,7 @@ let ChatService = class ChatService extends Disposable {
                             message = promptTextResult.message;
                         }
                         const agentRequest = {
-                            sessionId: model.sessionId,
+                            sessionResource: model.sessionResource,
                             requestId: request.id,
                             agentId: agent.id,
                             message,
@@ -720,7 +778,6 @@ let ChatService = class ChatService extends Disposable {
                             userSelectedTools: options?.userSelectedTools?.get(),
                             modeInstructions: options?.modeInfo?.modeInstructions,
                             editedFileEvents: request.editedFileEvents,
-                            chatSummary: options?.chatSummary
                         };
                         let isInitialTools = true;
                         store.add(autorun(reader => {
@@ -742,10 +799,11 @@ let ChatService = class ChatService extends Disposable {
                         !commandPart &&
                         !agentSlashCommandPart &&
                         enableCommandDetection &&
+                        (location !== ChatAgentLocation.EditorInline || !this.configurationService.getValue(InlineChatConfigKeys.EnableV2)) &&
                         options?.modeInfo?.kind !== ChatModeKind.Agent &&
                         options?.modeInfo?.kind !== ChatModeKind.Edit &&
                         !options?.agentIdSilent) {
-                        const defaultAgentHistory = this.getHistoryEntriesFromModel(requests, model.sessionId, location, defaultAgent.id);
+                        const defaultAgentHistory = this.getHistoryEntriesFromModel(requests, location, defaultAgent.id);
                         const chatAgentRequest = prepareChatAgentRequest(defaultAgent, undefined, enableCommandDetection, undefined, false);
                         const result = await this.chatAgentService.detectAgentOrCommand(chatAgentRequest, defaultAgentHistory, { location }, token);
                         if (result && this.chatAgentService.getAgent(result.agent.id)?.locations?.includes(location)) {
@@ -757,7 +815,7 @@ let ChatService = class ChatService extends Disposable {
                     const agent = (detectedAgent ?? agentPart?.agent ?? defaultAgent);
                     const command = detectedCommand ?? agentSlashCommandPart?.command;
                     await this.extensionService.activateByEvent(`onChatParticipant:${agent.id}`);
-                    const history = this.getHistoryEntriesFromModel(requests, model.sessionId, location, agent.id);
+                    const history = this.getHistoryEntriesFromModel(requests, location, agent.id);
                     const requestProps = prepareChatAgentRequest(agent, command, enableCommandDetection, request , !!detectedAgent);
                     const pendingRequest = this._pendingRequests.get(sessionResource);
                     if (pendingRequest && !pendingRequest.requestId) {
@@ -775,7 +833,7 @@ let ChatService = class ChatService extends Disposable {
                     rawResult = agentResult;
                     agentOrCommandFollowups = this.chatAgentService.getFollowups(agent.id, requestProps, agentResult, history, followupsCancelToken);
                     if (model.getRequests().length === 1 && !model.customTitle) {
-                        const chatHistory = this.getHistoryEntriesFromModel(model.getRequests(), model.sessionId, location, agent.id);
+                        const chatHistory = this.getHistoryEntriesFromModel(model.getRequests(), location, agent.id);
                         chatTitlePromise = this.chatAgentService.getChatTitle(agent.id, chatHistory, CancellationToken.None).then((title) => {
                             if (title === undefined) {
                                 const defaultAgentForTitle = this.chatAgentService.getDefaultAgent(location);
@@ -803,7 +861,7 @@ let ChatService = class ChatService extends Disposable {
                     const message = parsedRequest.text;
                     const commandResult = await this.chatSlashCommandService.executeCommand(commandPart.slashCommand.command, message.substring(commandPart.slashCommand.command.length + 1).trimStart(), ( new Progress(p => {
                         progressCallback([p]);
-                    })), history, location, token);
+                    })), history, location, model.sessionResource, token);
                     agentOrCommandFollowups = Promise.resolve(commandResult?.followUp);
                     rawResult = {};
                 }
@@ -815,8 +873,8 @@ let ChatService = class ChatService extends Disposable {
                 }
                 else {
                     if (!rawResult) {
-                        this.trace('sendRequest', `Provider returned no response for session ${model.sessionId}`);
-                        rawResult = { errorDetails: { message: ( localize(5827, "Provider returned null response")) } };
+                        this.trace('sendRequest', `Provider returned no response for session ${model.sessionResource}`);
+                        rawResult = { errorDetails: { message: ( localize(5946, "Provider returned null response")) } };
                     }
                     const result = rawResult.errorDetails?.responseIsFiltered ? 'filtered' :
                         rawResult.errorDetails && gotProgress ? 'errorWithOutput' :
@@ -832,8 +890,8 @@ let ChatService = class ChatService extends Disposable {
                     });
                     model.setResponse(request, rawResult);
                     completeResponseCreated();
-                    this.trace('sendRequest', `Provider returned response for session ${model.sessionId}`);
-                    model.completeResponse(request);
+                    this.trace('sendRequest', `Provider returned response for session ${model.sessionResource}`);
+                    request.response?.complete();
                     if (agentOrCommandFollowups) {
                         agentOrCommandFollowups.then(followups => {
                             model.setFollowups(request, followups);
@@ -862,7 +920,7 @@ let ChatService = class ChatService extends Disposable {
                     const rawResult = { errorDetails: { message: err.message } };
                     model.setResponse(request, rawResult);
                     completeResponseCreated();
-                    model.completeResponse(request);
+                    request.response?.complete();
                 }
             }
             finally {
@@ -896,14 +954,14 @@ let ChatService = class ChatService extends Disposable {
         });
         return attachedContextVariables;
     }
-    getHistoryEntriesFromModel(requests, sessionId, location, forAgentId) {
+    getHistoryEntriesFromModel(requests, location, forAgentId) {
         const history = [];
         const agent = this.chatAgentService.getAgent(forAgentId);
         for (const request of requests) {
             if (!request.response) {
                 continue;
             }
-            if (forAgentId !== request.response.agent?.id && !agent?.isDefault) {
+            if (forAgentId !== request.response.agent?.id && !agent?.isDefault && !agent?.canAccessPreviousChatHistory) {
                 continue;
             }
             if (location === ChatAgentLocation.EditorInline) {
@@ -911,7 +969,7 @@ let ChatService = class ChatService extends Disposable {
             }
             const promptTextResult = getPromptText(request.message);
             const historyRequest = {
-                sessionId: sessionId,
+                sessionResource: request.session.sessionResource,
                 requestId: request.id,
                 agentId: request.response.agent?.id ?? '',
                 message: promptTextResult.message,
@@ -976,34 +1034,13 @@ let ChatService = class ChatService extends Disposable {
         if (response.followups !== undefined) {
             model.setFollowups(request, response.followups);
         }
-        model.completeResponse(request);
+        request.response?.complete();
     }
     cancelCurrentRequestForSession(sessionResource) {
         this.trace('cancelCurrentRequestForSession', `session: ${sessionResource}`);
         this._pendingRequests.get(sessionResource)?.cancel();
         this._pendingRequests.deleteAndDispose(sessionResource);
     }
-    async clearSession(sessionResource) {
-        this.trace('clearSession', `session: ${sessionResource}`);
-        const model = this._sessionModels.get(sessionResource);
-        if (!model) {
-            throw ( new Error(`Unknown session: ${sessionResource}`));
-        }
-        const localSessionId = LocalChatSessionUri.parseLocalSessionId(sessionResource);
-        if (localSessionId && (model.initialLocation === ChatAgentLocation.Chat)) {
-            if (model.getRequests().length === 0 && !model.customTitle) {
-                await this._chatSessionStore.deleteSession(localSessionId);
-            }
-            else {
-                await this._chatSessionStore.storeSessions([model]);
-            }
-        }
-        this._sessionModels.delete(sessionResource);
-        model.dispose();
-        this._pendingRequests.get(sessionResource)?.cancel();
-        this._pendingRequests.deleteAndDispose(sessionResource);
-        this._onDidDisposeSession.fire({ sessionResource, reason: 'cleared' });
-    }
     hasSessions() {
         return this._chatSessionStore.hasSessions();
     }
@@ -1019,13 +1056,12 @@ let ChatService = class ChatService extends Disposable {
             chat: model.toJSON(),
             timestampInMilliseconds: Date.now(),
             toWorkspace: toWorkspace,
-            inputValue: transferredSessionData.inputValue,
+            inputState: transferredSessionData.inputState,
             location: transferredSessionData.location,
-            mode: transferredSessionData.mode,
         });
         this.storageService.store(TransferredGlobalChatKey, JSON.stringify(existingRaw), StorageScope.PROFILE, StorageTarget.MACHINE);
         this.chatTransferService.addWorkspaceToTransferred(toWorkspace);
-        this.trace('transferChatSession', `Transferred session ${model.sessionId} to workspace ${( toWorkspace.toString())}`);
+        this.trace('transferChatSession', `Transferred session ${model.sessionResource} to workspace ${( toWorkspace.toString())}`);
     }
     getChatStorageFolder() {
         return this._chatSessionStore.getChatStorageFolder();
@@ -1033,6 +1069,16 @@ let ChatService = class ChatService extends Disposable {
     logChatIndex() {
         this._chatSessionStore.logIndex();
     }
+    setTitle(sessionResource, title) {
+        this._sessionModels.get(sessionResource)?.setCustomTitle(title);
+    }
+    appendProgress(request, progress) {
+        const model = this._sessionModels.get(request.session.sessionResource);
+        if (!(request instanceof ChatRequestModel)) {
+            throw ( new BugIndicatingError('Can only append progress to requests of type ChatRequestModel'));
+        }
+        model?.acceptResponseProgress(request, progress);
+    }
     toLocalSessionId(sessionResource) {
         const localSessionId = LocalChatSessionUri.parseLocalSessionId(sessionResource);
         if (!localSessionId) {