@codingame/monaco-vscode-chat-service-override 30.0.0 → 31.0.0

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

@@ -68,18 +68,23 @@ class ChatDebugServiceImpl extends Disposable {
         super(...arguments);
         this._sessionBuffers = ( new ResourceMap());
         this._sessionOrder = [];
+        this._seenEventIds = ( new ResourceMap());
         this._onDidAddEvent = this._register(( new Emitter()));
         this.onDidAddEvent = this._onDidAddEvent.event;
         this._onDidClearProviderEvents = this._register(( new Emitter()));
         this.onDidClearProviderEvents = this._onDidClearProviderEvents.event;
-        this._onDidAttachDebugData = this._register(( new Emitter()));
-        this.onDidAttachDebugData = this._onDidAttachDebugData.event;
-        this._debugDataAttachedSessions = ( new ResourceMap());
+        this._onDidChangeAvailableSessionResources = this._register(( new Emitter()));
+        this.onDidChangeAvailableSessionResources = this._onDidChangeAvailableSessionResources.event;
         this._providers = ( new Set());
         this._invocationCts = ( new ResourceMap());
         this._providerEvents = ( new WeakSet());
         this._importedSessions = ( new ResourceMap());
+        this._availableSessionResources = [];
+        this._availableSessionResourceSet = ( new Set());
+        this._historicalSessionTitles = ( new ResourceMap());
         this._importedSessionTitles = ( new ResourceMap());
+        this._availableSessionsFetchStarted = false;
+        this._availableSessionsRequested = false;
     }
     static {
         this.MAX_EVENTS_PER_SESSION = 10_000;
@@ -87,6 +92,16 @@ class ChatDebugServiceImpl extends Disposable {
     static {
         this.MAX_SESSIONS = 5;
     }
+    static {
+        this._eventKindPriority = {
+            subagentInvocation: 0,
+            modelTurn: 1,
+            toolCall: 2,
+            agentResponse: 3,
+            userMessage: 4,
+            generic: 5
+        };
+    }
     static {
         this._debugEligibleSchemes = ( new Set([
         LocalChatSessionUri.scheme,
@@ -113,6 +128,27 @@ class ChatDebugServiceImpl extends Disposable {
         });
     }
     addEvent(event) {
+        if (event.id) {
+            let seen = this._seenEventIds.get(event.sessionResource);
+            if (!seen) {
+                seen = ( new Map());
+                this._seenEventIds.set(event.sessionResource, seen);
+            }
+            const existingKind = seen.get(event.id);
+            if (existingKind !== undefined) {
+                const priority = ChatDebugServiceImpl._eventKindPriority;
+                if ((priority[event.kind] ?? 5) >= (priority[existingKind] ?? 5)) {
+                    return;
+                }
+            }
+            seen.set(event.id, event.kind);
+            if (seen.size > ChatDebugServiceImpl.MAX_EVENTS_PER_SESSION) {
+                const firstKey = ( seen.keys()).next().value;
+                if (firstKey !== undefined) {
+                    seen.delete(firstKey);
+                }
+            }
+        }
         let buffer = this._sessionBuffers.get(event.sessionResource);
         if (!buffer) {
             if (this._sessionOrder.length >= ChatDebugServiceImpl.MAX_SESSIONS) {
@@ -123,10 +159,13 @@ class ChatDebugServiceImpl extends Disposable {
             this._sessionBuffers.set(event.sessionResource, buffer);
             this._sessionOrder.push(event.sessionResource);
         } else {
-            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);
+            const last = this._sessionOrder.length - 1;
+            if (last < 0 || !extUri.isEqual(this._sessionOrder[last], event.sessionResource)) {
+                const idx = this._sessionOrder.findIndex(u => extUri.isEqual(u, event.sessionResource));
+                if (idx !== -1 && idx !== last) {
+                    this._sessionOrder.splice(idx, 1);
+                    this._sessionOrder.push(event.sessionResource);
+                }
             }
         }
         buffer.push(event);
@@ -137,34 +176,73 @@ class ChatDebugServiceImpl extends Disposable {
         this.addEvent(event);
     }
     getEvents(sessionResource) {
-        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());
+            if (!buffer) {
+                return [];
+            }
+            let result = buffer.toArray();
+            if (!this._isSorted(result)) {
+                result.sort((a, b) => a.created.getTime() - b.created.getTime());
             }
+            result = this._deduplicateEvents(result);
+            return result;
+        }
+        const result = [];
+        for (const buffer of ( this._sessionBuffers.values())) {
+            result.push(...buffer.toArray());
         }
         result.sort((a, b) => a.created.getTime() - b.created.getTime());
         return result;
     }
+    _isSorted(events) {
+        for (let i = 1; i < events.length; i++) {
+            if (events[i].created.getTime() < events[i - 1].created.getTime()) {
+                return false;
+            }
+        }
+        return true;
+    }
+    _deduplicateEvents(events) {
+        const seen = ( new Map());
+        const priority = ChatDebugServiceImpl._eventKindPriority;
+        const result = [];
+        for (const event of events) {
+            if (!event.id) {
+                result.push(event);
+                continue;
+            }
+            const existingIdx = seen.get(event.id);
+            if (existingIdx === undefined) {
+                seen.set(event.id, result.length);
+                result.push(event);
+            } else {
+                const existing = result[existingIdx];
+                if ((priority[event.kind] ?? 5) < (priority[existing.kind] ?? 5)) {
+                    result[existingIdx] = event;
+                }
+            }
+        }
+        return result;
+    }
     getSessionResources() {
         return [...this._sessionOrder];
     }
     clear() {
         this._sessionBuffers.clear();
         this._sessionOrder.length = 0;
-        this._debugDataAttachedSessions.clear();
+        this._seenEventIds.clear();
         this._importedSessions.clear();
         this._importedSessionTitles.clear();
+        this._availableSessionResources.length = 0;
+        this._availableSessionResourceSet.clear();
+        this._historicalSessionTitles.clear();
     }
     _evictSession(sessionResource) {
         this._sessionBuffers.delete(sessionResource);
+        this._seenEventIds.delete(sessionResource);
         this._importedSessions.delete(sessionResource);
         this._importedSessionTitles.delete(sessionResource);
-        this._debugDataAttachedSessions.delete(sessionResource);
         const cts = this._invocationCts.get(sessionResource);
         if (cts) {
             cts.cancel();
@@ -234,24 +312,19 @@ class ChatDebugServiceImpl extends Disposable {
             cts.dispose();
             this._invocationCts.delete(sessionResource);
         }
-        this._debugDataAttachedSessions.delete(sessionResource);
     }
     _clearProviderEvents(sessionResource) {
         const buffer = this._sessionBuffers.get(sessionResource);
         if (buffer) {
-            buffer.removeWhere(event => ( this._providerEvents.has(event)));
+            const coreEvents = buffer.toArray().filter(e => !( this._providerEvents.has(e)));
+            buffer.clear();
+            for (const e of coreEvents) {
+                buffer.push(e);
+            }
         }
+        this._seenEventIds.delete(sessionResource);
         this._onDidClearProviderEvents.fire(sessionResource);
     }
-    markDebugDataAttached(sessionResource) {
-        if (!( this._debugDataAttachedSessions.has(sessionResource))) {
-            this._debugDataAttachedSessions.set(sessionResource, true);
-            this._onDidAttachDebugData.fire(sessionResource);
-        }
-    }
-    hasAttachedDebugData(sessionResource) {
-        return ( this._debugDataAttachedSessions.has(sessionResource));
-    }
     async resolveEvent(eventId) {
         for (const provider of this._providers) {
             if (provider.resolveChatDebugLogEvent) {
@@ -276,6 +349,59 @@ class ChatDebugServiceImpl extends Disposable {
     getImportedSessionTitle(sessionResource) {
         return this._importedSessionTitles.get(sessionResource);
     }
+    addAvailableSessionResources(resources) {
+        let added = false;
+        for (const {
+            uri,
+            title
+        } of resources) {
+            const key = ( uri.toString());
+            if (!( this._availableSessionResourceSet.has(key))) {
+                this._availableSessionResourceSet.add(key);
+                this._availableSessionResources.push(uri);
+                added = true;
+            }
+            if (title) {
+                this._historicalSessionTitles.set(uri, title);
+            }
+        }
+        if (added) {
+            this._onDidChangeAvailableSessionResources.fire();
+        }
+    }
+    getAvailableSessionResources() {
+        this._availableSessionsRequested = true;
+        this._tryFetchAvailableSessions();
+        const known = ( new Set(( this._sessionOrder.map(u => ( u.toString())))));
+        const result = [...this._sessionOrder];
+        for (const uri of this._availableSessionResources) {
+            if (!( known.has(( uri.toString())))) {
+                known.add(( uri.toString()));
+                result.push(uri);
+            }
+        }
+        return result;
+    }
+    registerAvailableSessionsFetcher(fetcher) {
+        this._availableSessionsFetcher = fetcher;
+        this._availableSessionsFetchStarted = false;
+        this._tryFetchAvailableSessions();
+    }
+    _tryFetchAvailableSessions() {
+        if (!this._availableSessionsFetcher || !this._availableSessionsRequested || this._availableSessionsFetchStarted) {
+            return;
+        }
+        this._availableSessionsFetchStarted = true;
+        const fetcher = this._availableSessionsFetcher;
+        fetcher(CancellationToken.None).then(entries => {
+            if (entries.length > 0) {
+                this.addAvailableSessionResources(entries);
+            }
+        }).catch(onUnexpectedError);
+    }
+    getHistoricalSessionTitle(sessionResource) {
+        return this._historicalSessionTitles.get(sessionResource);
+    }
     async exportLog(sessionResource) {
         for (const provider of this._providers) {
             if (provider.provideChatDebugLogExport) {

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

@@ -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, IChatQuestionAnswers, 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, 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";
@@ -97,10 +97,6 @@ export declare class ChatService extends Disposable implements IChatService {
     private info;
     private error;
     private deserializeChats;
-    /**
-     * todo@connor4312 This will be cleaned up with the globalization of edits.
-     */
-    private reviveSessionsWithEdits;
     /**
      * Returns an array of chat details for all persisted chat sessions that have at least one request.
      * Chat sessions that have already been loaded into the chat view are excluded from the result.
@@ -126,13 +122,13 @@ export declare class ChatService extends Disposable implements IChatService {
     private initializeSession;
     activateDefaultAgent(location: ChatAgentLocation): Promise<void>;
     getSession(sessionResource: URI): IChatModel | undefined;
-    acquireExistingSession(sessionResource: URI): IChatModelReference | undefined;
+    acquireExistingSession(sessionResource: URI, debugOwner?: string): IChatModelReference | undefined;
+    getChatModelReferenceDebugInfo(): import("../model/chatModelStore.js").IChatModelReferenceDebugSnapshot;
     private acquireOrRestoreLocalSession;
     getSessionTitle(sessionResource: URI): string | undefined;
-    loadSessionFromData(data: IExportableChatData | ISerializableChatData): IChatModelReference;
-    acquireOrLoadSession(sessionResource: URI, location: ChatAgentLocation, token: CancellationToken): Promise<IChatModelReference | undefined>;
+    loadSessionFromData(data: IExportableChatData | ISerializableChatData, debugOwner?: string): IChatModelReference;
+    acquireOrLoadSession(sessionResource: URI, location: ChatAgentLocation, token: CancellationToken, debugOwner?: string): Promise<IChatModelReference | undefined>;
     private loadRemoteSession;
-    getChatSessionFromInternalUri(sessionResource: URI): IChatSessionContext | undefined;
     resendRequest(request: IChatRequestModel, options?: IChatSendRequestOptions): Promise<void>;
     private queuePendingRequest;
     sendRequest(sessionResource: URI, request: string, options?: IChatSendRequestOptions): Promise<ChatSendResult>;