@codingame/monaco-vscode-chat-service-override 28.4.1 → 29.1.0

package/vscode/src/vs/workbench/contrib/chat/browser/widgetHosts/viewPane/chatViewPane.js

@@ -6,11 +6,12 @@ import { $, append, addDisposableListener, EventType, setVisibility, getWindow,
 import { StandardMouseEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/mouseEvent';
 import { Button } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/button/button';
 import { Sash, Orientation } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/sash/sash';
-import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { CancellationToken, CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { MutableDisposable, toDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { MarshalledId } from '@codingame/monaco-vscode-api/vscode/vs/base/common/marshallingIds';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { MenuWorkbenchToolBar } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/toolbar';
 import { MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
@@ -140,6 +141,7 @@ let ChatViewPane = class ChatViewPane extends ViewPane {
         this.workbenchEnvironmentService = workbenchEnvironmentService;
         this.hostService = hostService;
         this.lastDimensionsPerOrientation = ( new Map());
+        this.loadSessionCts = this._register(( new MutableDisposable()));
         this.modelRef = this._register(( new MutableDisposable()));
         this.activityBadge = this._register(( new MutableDisposable()));
         this.sessionsViewerOrientation = AgentSessionsViewerOrientation.Stacked;
@@ -256,7 +258,7 @@ let ChatViewPane = class ChatViewPane extends ViewPane {
                     const wasVisible = this._widget.visible;
                     try {
                         this._widget.setVisible(false);
-                        await this.showModel(modelRef);
+                        await this.showModel(CancellationToken.None, modelRef);
                     } finally {
                         this._widget.setVisible(wasVisible);
                     }
@@ -313,7 +315,7 @@ let ChatViewPane = class ChatViewPane extends ViewPane {
         const sessionsContainer = this.sessionsContainer = parent.appendChild($(".agent-sessions-container"));
         const sessionsTitleContainer = this.sessionsTitleContainer = append(sessionsContainer, $(".agent-sessions-title-container"));
         const sessionsTitle = this.sessionsTitle = append(sessionsTitleContainer, $("span.agent-sessions-title"));
-        sessionsTitle.textContent = ( localize(6894, "Sessions"));
+        sessionsTitle.textContent = ( localize(7101, "Sessions"));
         this._register(addDisposableListener(sessionsTitle, EventType.CLICK, () => {
             this.sessionsControl?.scrollToTop();
             this.sessionsControl?.focus();
@@ -341,7 +343,7 @@ let ChatViewPane = class ChatViewPane extends ViewPane {
             ...defaultButtonStyles,
             secondary: true
         })));
-        newSessionButton.label = ( localize(6895, "New Session"));
+        newSessionButton.label = ( localize(7102, "New Session"));
         this._register(
             newSessionButton.onDidClick(() => this.commandService.executeCommand(ACTION_ID_NEW_CHAT))
         );
@@ -555,6 +557,14 @@ let ChatViewPane = class ChatViewPane extends ViewPane {
                 sessionsControl.reveal(sessionResource);
             }
         }));
+        this._register(this.agentSessionsService.model.onDidChangeSessionArchivedState(e => {
+            if (e.isArchived()) {
+                const currentSessionResource = chatWidget.viewModel?.sessionResource;
+                if (currentSessionResource && isEqual(currentSessionResource, e.resource)) {
+                    this.clear();
+                }
+            }
+        }));
         this._register(autorun(reader => {
             chatWidget.inputPart.height.read(reader);
             if (this.sessionsViewerVisible && this.sessionsViewerOrientation === AgentSessionsViewerOrientation.Stacked) {
@@ -573,7 +583,7 @@ let ChatViewPane = class ChatViewPane extends ViewPane {
                 progressBadgeDisposables.value.add(autorun(reader => {
                     if (model.requestInProgress.read(reader)) {
                         this.activityBadge.value = this.activityService.showViewActivity(this.id, {
-                            badge: ( new ProgressBadge(() => ( localize(6896, "Agent Session in Progress"))))
+                            badge: ( new ProgressBadge(() => ( localize(7103, "Agent Session in Progress"))))
                         });
                     } else {
                         this.activityBadge.clear();
@@ -607,33 +617,40 @@ let ChatViewPane = class ChatViewPane extends ViewPane {
     async _applyModel() {
         const sessionResource = this.getTransferredOrPersistedSessionInfo();
         const modelRef = sessionResource ? await this.chatService.acquireOrLoadSession(sessionResource, ChatAgentLocation.Chat, CancellationToken.None) : undefined;
-        await this.showModel(modelRef);
+        await this.showModel(CancellationToken.None, modelRef);
     }
-    async showModel(modelRef, startNewSession = true) {
+    async showModel(token, modelRef, startNewSession = true) {
         const oldModelResource = this.modelRef.value?.object.sessionResource;
         this.modelRef.value = undefined;
         let ref;
         if (startNewSession) {
-            ref = modelRef ?? (this.chatService.transferredSessionResource ? await this.chatService.acquireOrLoadSession(
-                this.chatService.transferredSessionResource,
-                ChatAgentLocation.Chat,
-                CancellationToken.None
-            ) : this.chatService.startNewLocalSession(ChatAgentLocation.Chat));
+            ref = modelRef ?? (this.chatService.transferredSessionResource ? await this.chatService.acquireOrLoadSession(this.chatService.transferredSessionResource, ChatAgentLocation.Chat, token) : this.chatService.startNewLocalSession(ChatAgentLocation.Chat));
             if (!ref) {
                 throw ( new Error("Could not start chat session"));
             }
         }
+        if (token.isCancellationRequested) {
+            ref?.dispose();
+            return undefined;
+        }
         this.modelRef.value = ref;
         const model = ref?.object;
         if (model) {
             await this.updateWidgetLockState(getChatSessionType(model.sessionResource));
+            if (token.isCancellationRequested) {
+                this.modelRef.value = undefined;
+                return undefined;
+            }
             this.viewState.sessionResource = model.sessionResource;
         }
         this._widget.setModel(model);
         this.titleControl?.update(model);
         this.updateActions();
         if (oldModelResource) {
-            this.agentSessionsService.model.getSession(oldModelResource)?.setRead(true);
+            const oldSession = this.agentSessionsService.model.getSession(oldModelResource);
+            if (oldSession && !oldSession.isMarkedUnread()) {
+                oldSession.setRead(true);
+            }
         }
         return model;
     }
@@ -654,39 +671,59 @@ let ChatViewPane = class ChatViewPane extends ViewPane {
         }
         const contribution = this.chatSessionsService.getChatSessionContribution(sessionType);
         if (contribution) {
-            this._widget.lockToCodingAgent(contribution.name, contribution.displayName, contribution.type);
+            this._widget.lockToCodingAgent(contribution.name, contribution.displayName, sessionType);
         } else {
             this._widget.unlockFromCodingAgent();
         }
     }
     async clear() {
+        this.loadSessionCts.value?.cancel();
         this.updateViewState();
-        await this.showModel(undefined);
+        await this.showModel(CancellationToken.None);
         this.updateActions();
     }
     async loadSession(sessionResource) {
+        this.loadSessionCts.value?.cancel();
+        const cts = this.loadSessionCts.value = ( new CancellationTokenSource());
+        const token = cts.token;
         if (this.restoringSession) {
             await this.restoringSession;
         }
+        if (token.isCancellationRequested) {
+            return undefined;
+        }
         return this.progressService.withProgress({
             location: ChatViewId,
             delay: 200
         }, async () => {
             let queue = Promise.resolve();
             const clearWidget = disposableTimeout(() => {
-                queue = this.showModel(undefined, false).then(() => {});
+                if (token.isCancellationRequested || this.loadSessionCts.value !== cts) {
+                    return;
+                }
+                queue = this.showModel(token, undefined, false).then(() => {});
             }, 100);
+            const clearWidgetCancellationListener = token.onCancellationRequested(() => clearWidget.dispose());
             try {
-                const newModelRef = await this.chatService.acquireOrLoadSession(sessionResource, ChatAgentLocation.Chat, CancellationToken.None);
+                const newModelRef = await this.chatService.acquireOrLoadSession(sessionResource, ChatAgentLocation.Chat, token);
                 clearWidget.dispose();
                 await queue;
-                return this.showModel(newModelRef);
+                if (token.isCancellationRequested) {
+                    newModelRef?.dispose();
+                    return undefined;
+                }
+                return this.showModel(token, newModelRef);
             } catch (err) {
                 clearWidget.dispose();
                 await queue;
+                if (token.isCancellationRequested) {
+                    return undefined;
+                }
                 this.logService.error(`Failed to load chat session '${( sessionResource.toString())}'`, err);
-                this.notificationService.error(( localize(6897, "Failed to open chat session: {0}", toErrorMessage(err))));
-                return this.showModel(undefined);
+                this.notificationService.error(( localize(7104, "Failed to open chat session: {0}", toErrorMessage(err))));
+                return this.showModel(token, undefined);
+            } finally {
+                clearWidgetCancellationListener.dispose();
             }
         });
     }

package/vscode/src/vs/workbench/contrib/chat/browser/widgetHosts/viewPane/chatViewTitleControl.js

@@ -23,7 +23,7 @@ let ChatViewTitleControl = class ChatViewTitleControl extends Disposable {
         ChatViewTitleControl_1 = this;
     }
     static {
-        this.DEFAULT_TITLE = ( localize(6898, "Chat"));
+        this.DEFAULT_TITLE = ( localize(7105, "Chat"));
     }
     static {
         this.PICK_AGENT_SESSION_ACTION_ID = "workbench.action.chat.pickAgentSession";
@@ -48,7 +48,7 @@ let ChatViewTitleControl = class ChatViewTitleControl extends Disposable {
             constructor() {
                 super({
                     id: ChatViewTitleControl_1.PICK_AGENT_SESSION_ACTION_ID,
-                    title: ( localize(6899, "Pick Agent Session")),
+                    title: ( localize(7106, "Pick Agent Session")),
                     f1: false,
                     menu: [{
                         id: MenuId.ChatViewSessionTitleNavigationToolbar,

package/vscode/src/vs/workbench/contrib/chat/common/chatDebugServiceImpl.d.ts

@@ -1,14 +1,16 @@
 import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
 import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
-import { ChatDebugLogLevel, IChatDebugEvent, IChatDebugLogProvider, IChatDebugResolvedEventContent } from "./chatDebugService.js";
+import { ChatDebugLogLevel, IChatDebugEvent, IChatDebugLogProvider, IChatDebugResolvedEventContent } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService";
 import { IChatDebugService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService.service";
 export declare class ChatDebugServiceImpl extends Disposable implements IChatDebugService {
     readonly _serviceBrand: undefined;
-    private static readonly MAX_EVENTS;
-    private readonly _buffer;
-    private _head;
-    private _size;
+    static readonly MAX_EVENTS_PER_SESSION = 10000;
+    static readonly MAX_SESSIONS = 5;
+    /** Per-session event buffers. Ordered from oldest to newest session (LRU). */
+    private readonly _sessionBuffers;
+    /** Ordered list of session URIs for LRU eviction. */
+    private readonly _sessionOrder;
     private readonly _onDidAddEvent;
     readonly onDidAddEvent: Event<IChatDebugEvent>;
     private readonly _onDidClearProviderEvents;
@@ -20,7 +22,14 @@ export declare class ChatDebugServiceImpl extends Disposable implements IChatDeb
     private readonly _invocationCts;
     /** Events that were returned by providers (not internally logged). */
     private readonly _providerEvents;
+    /** Session URIs created via import. */
+    private readonly _importedSessions;
+    /** Human-readable titles for imported sessions. */
+    private readonly _importedSessionTitles;
     activeSessionResource: URI | undefined;
+    /** Schemes eligible for debug logging and provider invocation. */
+    private static readonly _debugEligibleSchemes;
+    private _isDebugEligibleSession;
     log(sessionResource: URI, name: string, details?: string, level?: ChatDebugLogLevel, options?: {
         id?: string;
         category?: string;
@@ -31,6 +40,8 @@ export declare class ChatDebugServiceImpl extends Disposable implements IChatDeb
     getEvents(sessionResource?: URI): readonly IChatDebugEvent[];
     getSessionResources(): readonly URI[];
     clear(): void;
+    /** Remove all ancillary state for an evicted session. */
+    private _evictSession;
     registerProvider(provider: IChatDebugLogProvider): IDisposable;
     hasInvokedProviders(sessionResource: URI): boolean;
     invokeProviders(sessionResource: URI): Promise<void>;
@@ -40,5 +51,10 @@ export declare class ChatDebugServiceImpl extends Disposable implements IChatDeb
     markDebugDataAttached(sessionResource: URI): void;
     hasAttachedDebugData(sessionResource: URI): boolean;
     resolveEvent(eventId: string): Promise<IChatDebugResolvedEventContent | undefined>;
+    isCoreEvent(event: IChatDebugEvent): boolean;
+    setImportedSessionTitle(sessionResource: URI, title: string): void;
+    getImportedSessionTitle(sessionResource: URI): string | undefined;
+    exportLog(sessionResource: URI): Promise<Uint8Array | undefined>;
+    importLog(data: Uint8Array): Promise<URI | undefined>;
     dispose(): void;
 }

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

@@ -1,18 +1,73 @@
 
+import { timeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
 import { CancellationTokenSource, CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { onUnexpectedError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 import { Disposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
-import { ChatDebugLogLevel } from './chatDebugService.js';
+import { extUri } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { ChatDebugLogLevel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService';
 import { LocalChatSessionUri } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
 
+class SessionEventBuffer {
+    constructor(capacity) {
+        this.capacity = capacity;
+        this._head = 0;
+        this._size = 0;
+        this._buffer = ( new Array(capacity));
+    }
+    get size() {
+        return this._size;
+    }
+    push(event) {
+        const idx = (this._head + this._size) % this.capacity;
+        this._buffer[idx] = event;
+        if (this._size < this.capacity) {
+            this._size++;
+        } else {
+            this._head = (this._head + 1) % this.capacity;
+        }
+    }
+    toArray() {
+        const result = [];
+        for (let i = 0; i < this._size; i++) {
+            const event = this._buffer[(this._head + i) % this.capacity];
+            if (event) {
+                result.push(event);
+            }
+        }
+        return result;
+    }
+    removeWhere(predicate) {
+        let write = 0;
+        for (let i = 0; i < this._size; i++) {
+            const idx = (this._head + i) % this.capacity;
+            const event = this._buffer[idx];
+            if (event && predicate(event)) {
+                continue;
+            }
+            if (write !== i) {
+                const writeIdx = (this._head + write) % this.capacity;
+                this._buffer[writeIdx] = event;
+            }
+            write++;
+        }
+        for (let i = write; i < this._size; i++) {
+            this._buffer[(this._head + i) % this.capacity] = undefined;
+        }
+        this._size = write;
+    }
+    clear() {
+        this._buffer.fill(undefined);
+        this._head = 0;
+        this._size = 0;
+    }
+}
 class ChatDebugServiceImpl extends Disposable {
     constructor() {
         super(...arguments);
-        this._buffer = ( new Array(ChatDebugServiceImpl.MAX_EVENTS));
-        this._head = 0;
-        this._size = 0;
+        this._sessionBuffers = ( new ResourceMap());
+        this._sessionOrder = [];
         this._onDidAddEvent = this._register(( new Emitter()));
         this.onDidAddEvent = this._onDidAddEvent.event;
         this._onDidClearProviderEvents = this._register(( new Emitter()));
@@ -23,12 +78,26 @@ class ChatDebugServiceImpl extends Disposable {
         this._providers = ( new Set());
         this._invocationCts = ( new ResourceMap());
         this._providerEvents = ( new WeakSet());
+        this._importedSessions = ( new ResourceMap());
+        this._importedSessionTitles = ( new ResourceMap());
     }
     static {
-        this.MAX_EVENTS = 10_000;
+        this.MAX_EVENTS_PER_SESSION = 10_000;
+    }
+    static {
+        this.MAX_SESSIONS = 5;
+    }
+    static {
+        this._debugEligibleSchemes = ( new Set([
+        LocalChatSessionUri.scheme,
+        "copilotcli",
+        "claude-code"]));
+    }
+    _isDebugEligibleSession(sessionResource) {
+        return ( ChatDebugServiceImpl._debugEligibleSchemes.has(sessionResource.scheme)) || ( this._importedSessions.has(sessionResource));
     }
     log(sessionResource, name, details, level = ChatDebugLogLevel.Info, options) {
-        if (!LocalChatSessionUri.isLocalSession(sessionResource)) {
+        if (!this._isDebugEligibleSession(sessionResource)) {
             return;
         }
         this.addEvent({
@@ -44,13 +113,23 @@ class ChatDebugServiceImpl extends Disposable {
         });
     }
     addEvent(event) {
-        const idx = (this._head + this._size) % ChatDebugServiceImpl.MAX_EVENTS;
-        this._buffer[idx] = event;
-        if (this._size < ChatDebugServiceImpl.MAX_EVENTS) {
-            this._size++;
+        let buffer = this._sessionBuffers.get(event.sessionResource);
+        if (!buffer) {
+            if (this._sessionOrder.length >= ChatDebugServiceImpl.MAX_SESSIONS) {
+                const evicted = this._sessionOrder.shift();
+                this._evictSession(evicted);
+            }
+            buffer = ( new SessionEventBuffer(ChatDebugServiceImpl.MAX_EVENTS_PER_SESSION));
+            this._sessionBuffers.set(event.sessionResource, buffer);
+            this._sessionOrder.push(event.sessionResource);
         } else {
-            this._head = (this._head + 1) % ChatDebugServiceImpl.MAX_EVENTS;
+            const idx = this._sessionOrder.findIndex(u => extUri.isEqual(u, event.sessionResource));
+            if (idx !== -1 && idx !== this._sessionOrder.length - 1) {
+                this._sessionOrder.splice(idx, 1);
+                this._sessionOrder.push(event.sessionResource);
+            }
         }
+        buffer.push(event);
         this._onDidAddEvent.fire(event);
     }
     addProviderEvent(event) {
@@ -58,40 +137,40 @@ class ChatDebugServiceImpl extends Disposable {
         this.addEvent(event);
     }
     getEvents(sessionResource) {
-        const result = [];
-        const key = sessionResource?.toString();
-        for (let i = 0; i < this._size; i++) {
-            const event = this._buffer[(this._head + i) % ChatDebugServiceImpl.MAX_EVENTS];
-            if (!event) {
-                continue;
-            }
-            if (!key || ( event.sessionResource.toString()) === key) {
-                result.push(event);
+        let result;
+        if (sessionResource) {
+            const buffer = this._sessionBuffers.get(sessionResource);
+            result = buffer ? buffer.toArray() : [];
+        } else {
+            result = [];
+            for (const buffer of ( this._sessionBuffers.values())) {
+                result.push(...buffer.toArray());
             }
         }
         result.sort((a, b) => a.created.getTime() - b.created.getTime());
         return result;
     }
     getSessionResources() {
-        const seen = ( new ResourceMap());
-        const result = [];
-        for (let i = 0; i < this._size; i++) {
-            const event = this._buffer[(this._head + i) % ChatDebugServiceImpl.MAX_EVENTS];
-            if (!event) {
-                continue;
-            }
-            if (!( seen.has(event.sessionResource))) {
-                seen.set(event.sessionResource, true);
-                result.push(event.sessionResource);
-            }
-        }
-        return result;
+        return [...this._sessionOrder];
     }
     clear() {
-        this._buffer.fill(undefined);
-        this._head = 0;
-        this._size = 0;
+        this._sessionBuffers.clear();
+        this._sessionOrder.length = 0;
         this._debugDataAttachedSessions.clear();
+        this._importedSessions.clear();
+        this._importedSessionTitles.clear();
+    }
+    _evictSession(sessionResource) {
+        this._sessionBuffers.delete(sessionResource);
+        this._importedSessions.delete(sessionResource);
+        this._importedSessionTitles.delete(sessionResource);
+        this._debugDataAttachedSessions.delete(sessionResource);
+        const cts = this._invocationCts.get(sessionResource);
+        if (cts) {
+            cts.cancel();
+            cts.dispose();
+            this._invocationCts.delete(sessionResource);
+        }
     }
     registerProvider(provider) {
         this._providers.add(provider);
@@ -108,7 +187,7 @@ class ChatDebugServiceImpl extends Disposable {
         return ( this._invocationCts.has(sessionResource));
     }
     async invokeProviders(sessionResource) {
-        if (!LocalChatSessionUri.isLocalSession(sessionResource)) {
+        if (!this._isDebugEligibleSession(sessionResource)) {
             return;
         }
         const existingCts = this._invocationCts.get(sessionResource);
@@ -130,11 +209,18 @@ class ChatDebugServiceImpl extends Disposable {
         try {
             const events = await provider.provideChatDebugLog(sessionResource, token);
             if (events) {
-                for (const event of events) {
+                const BATCH_SIZE = 500;
+                for (let i = 0; i < events.length; i++) {
+                    if (token.isCancellationRequested) {
+                        break;
+                    }
                     this.addProviderEvent({
-                        ...event,
-                        sessionResource: event.sessionResource ?? sessionResource
+                        ...events[i],
+                        sessionResource: events[i].sessionResource ?? sessionResource
                     });
+                    if (i > 0 && i % BATCH_SIZE === 0) {
+                        await timeout(0);
+                    }
                 }
             }
         } catch (err) {
@@ -151,24 +237,10 @@ class ChatDebugServiceImpl extends Disposable {
         this._debugDataAttachedSessions.delete(sessionResource);
     }
     _clearProviderEvents(sessionResource) {
-        const key = ( sessionResource.toString());
-        let write = 0;
-        for (let i = 0; i < this._size; i++) {
-            const idx = (this._head + i) % ChatDebugServiceImpl.MAX_EVENTS;
-            const event = this._buffer[idx];
-            if (event && ( this._providerEvents.has(event)) && ( event.sessionResource.toString()) === key) {
-                continue;
-            }
-            if (write !== i) {
-                const writeIdx = (this._head + write) % ChatDebugServiceImpl.MAX_EVENTS;
-                this._buffer[writeIdx] = event;
-            }
-            write++;
-        }
-        for (let i = write; i < this._size; i++) {
-            this._buffer[(this._head + i) % ChatDebugServiceImpl.MAX_EVENTS] = undefined;
+        const buffer = this._sessionBuffers.get(sessionResource);
+        if (buffer) {
+            buffer.removeWhere(event => ( this._providerEvents.has(event)));
         }
-        this._size = write;
         this._onDidClearProviderEvents.fire(sessionResource);
     }
     markDebugDataAttached(sessionResource) {
@@ -195,12 +267,54 @@ class ChatDebugServiceImpl extends Disposable {
         }
         return undefined;
     }
+    isCoreEvent(event) {
+        return !( this._providerEvents.has(event));
+    }
+    setImportedSessionTitle(sessionResource, title) {
+        this._importedSessionTitles.set(sessionResource, title);
+    }
+    getImportedSessionTitle(sessionResource) {
+        return this._importedSessionTitles.get(sessionResource);
+    }
+    async exportLog(sessionResource) {
+        for (const provider of this._providers) {
+            if (provider.provideChatDebugLogExport) {
+                try {
+                    const data = await provider.provideChatDebugLogExport(sessionResource, CancellationToken.None);
+                    if (data !== undefined) {
+                        return data;
+                    }
+                } catch (err) {
+                    onUnexpectedError(err);
+                }
+            }
+        }
+        return undefined;
+    }
+    async importLog(data) {
+        for (const provider of this._providers) {
+            if (provider.resolveChatDebugLogImport) {
+                try {
+                    const sessionUri = await provider.resolveChatDebugLogImport(data, CancellationToken.None);
+                    if (sessionUri !== undefined) {
+                        this._importedSessions.set(sessionUri, true);
+                        return sessionUri;
+                    }
+                } catch (err) {
+                    onUnexpectedError(err);
+                }
+            }
+        }
+        return undefined;
+    }
     dispose() {
         for (const cts of ( this._invocationCts.values())) {
             cts.cancel();
             cts.dispose();
         }
         this._invocationCts.clear();
+        this.clear();
+        this._providers.clear();
         super.dispose();
     }
 }

package/vscode/src/vs/workbench/contrib/chat/common/chatService/chatServiceImpl.d.ts

@@ -1,6 +1,6 @@
 import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
 import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
-import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
@@ -16,7 +16,7 @@ import { IMcpService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/co
 import { IChatAgentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatAgents.service";
 import { ChatModel, IChatModel, IChatRequestModel, IChatRequestVariableData, IExportableChatData, ISerializableChatData } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatModel";
 import { IParsedChatRequest } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/requestParser/chatParserTypes";
-import { ChatRequestQueueKind, ChatSendResult, IChatCompleteResponse, IChatDetail, IChatModelReference, IChatProgress, IChatSendRequestOptions, IChatSessionContext, IChatSessionStartOptions, IChatUserActionEvent } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
+import { ChatRequestQueueKind, ChatSendResult, IChatCompleteResponse, IChatDetail, IChatModelReference, IChatProgress, IChatQuestionAnswers, IChatSendRequestOptions, IChatSessionContext, IChatSessionStartOptions, IChatUserActionEvent } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
 import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
 import { IChatSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service";
 import { IChatSlashCommandService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatSlashCommands.service";
@@ -60,7 +60,7 @@ export declare class ChatService extends Disposable implements IChatService {
     readonly onDidReceiveQuestionCarouselAnswer: Event<{
         requestId: string;
         resolveId: string;
-        answers: Record<string, unknown> | undefined;
+        answers: IChatQuestionAnswers | undefined;
     }>;
     private readonly _onDidDisposeSession;
     readonly onDidDisposeSession: Event<{
@@ -91,7 +91,7 @@ export declare class ChatService extends Disposable implements IChatService {
      */
     private shouldStoreSession;
     notifyUserAction(action: IChatUserActionEvent): void;
-    notifyQuestionCarouselAnswer(requestId: string, resolveId: string, answers: Record<string, unknown> | undefined): void;
+    notifyQuestionCarouselAnswer(requestId: string, resolveId: string, answers: IChatQuestionAnswers | undefined): void;
     setChatSessionTitle(sessionResource: URI, title: string): Promise<void>;
     private trace;
     private info;
@@ -152,8 +152,9 @@ export declare class ChatService extends Disposable implements IChatService {
     removeRequest(sessionResource: URI, requestId: string): Promise<void>;
     adoptRequest(sessionResource: URI, request: IChatRequestModel): Promise<void>;
     addCompleteRequest(sessionResource: URI, message: IParsedChatRequest | string, variableData: IChatRequestVariableData | undefined, attempt: number | undefined, response: IChatCompleteResponse): Promise<void>;
-    cancelCurrentRequestForSession(sessionResource: URI, source?: string): void;
+    cancelCurrentRequestForSession(sessionResource: URI, source?: string): Promise<void>;
     setYieldRequested(sessionResource: URI): void;
+    migrateRequests(originalResource: URI, targetResource: URI): void;
     removePendingRequest(sessionResource: URI, requestId: string): void;
     setPendingRequests(sessionResource: URI, requests: readonly {
         requestId: string;
@@ -166,4 +167,5 @@ export declare class ChatService extends Disposable implements IChatService {
     setSessionTitle(sessionResource: URI, title: string): void;
     appendProgress(request: IChatRequestModel, progress: IChatProgress): void;
     private toLocalSessionId;
+    registerChatModelChangeListeners(chatSessionType: string, onChange: (chatSessionResource: URI) => void): IDisposable;
 }