@codingame/monaco-vscode-chat-service-override 4.5.1 → 5.0.0

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

@@ -17,7 +17,7 @@ let ChatSlashCommandService = class ChatSlashCommandService extends Disposable {
     }
     registerSlashCommand(data, command) {
         if (( this._commands.has(data.command))) {
-            throw new Error(`Already registered a command with id ${data.command}}`);
+            throw ( new Error(`Already registered a command with id ${data.command}}`));
         }
         this._commands.set(data.command, { data, command });
         this._onDidChangeCommands.fire();
@@ -36,13 +36,13 @@ let ChatSlashCommandService = class ChatSlashCommandService extends Disposable {
     async executeCommand(id, prompt, progress, history, token) {
         const data = this._commands.get(id);
         if (!data) {
-            throw new Error('No command with id ${id} NOT registered');
+            throw ( new Error('No command with id ${id} NOT registered'));
         }
         if (!data.command) {
             await this._extensionService.activateByEvent(`onSlash:${id}`);
         }
         if (!data.command) {
-            throw new Error(`No command with id ${id} NOT resolved`);
+            throw ( new Error(`No command with id ${id} NOT resolved`));
         }
         return await data.command(prompt, progress, history, token);
     }

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

@@ -2,6 +2,7 @@ import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
 import { Emitter } from 'vscode/vscode/vs/base/common/event';
 import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
 import { Memento } from 'vscode/vscode/vs/workbench/common/memento';
+import { CHAT_PROVIDER_ID } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatParticipantContribTypes';
 
 let ChatWidgetHistoryService = class ChatWidgetHistoryService {
     constructor(storageService) {
@@ -14,14 +15,14 @@ let ChatWidgetHistoryService = class ChatWidgetHistoryService {
         }
         this.viewState = loadedState;
     }
-    getHistory(providerId) {
-        return this.viewState.history?.[providerId] ?? [];
+    getHistory() {
+        return this.viewState.history?.[CHAT_PROVIDER_ID] ?? [];
     }
-    saveHistory(providerId, history) {
+    saveHistory(history) {
         if (!this.viewState.history) {
             this.viewState.history = {};
         }
-        this.viewState.history[providerId] = history;
+        this.viewState.history[CHAT_PROVIDER_ID] = history;
         this.memento.saveMemento();
     }
     clearHistory() {

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

@@ -0,0 +1,131 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
+import { ExtensionIdentifier } from 'vscode/vscode/vs/platform/extensions/common/extensions';
+import { Extensions } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionFeatures';
+import { IExtensionFeaturesManagementService } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionFeatures.service';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+
+var LanguageModelStatsService_1;
+const _moduleId = "vs/workbench/contrib/chat/common/languageModelStats";
+let LanguageModelStatsService = class LanguageModelStatsService extends Disposable {
+    static { LanguageModelStatsService_1 = this; }
+    static { this.MODEL_STATS_STORAGE_KEY_PREFIX = 'languageModelStats.'; }
+    static { this.MODEL_ACCESS_STORAGE_KEY_PREFIX = 'languageModelAccess.'; }
+    constructor(extensionFeaturesManagementService, _storageService) {
+        super();
+        this.extensionFeaturesManagementService = extensionFeaturesManagementService;
+        this._storageService = _storageService;
+        this._onDidChangeStats = this._register(( (new Emitter())));
+        this.onDidChangeLanguageMoelStats = this._onDidChangeStats.event;
+        this.sessionStats = ( (new Map()));
+        this._register(_storageService.onDidChangeValue(-1 , undefined, this._store)(e => {
+            const model = this.getModel(e.key);
+            if (model) {
+                this._onDidChangeStats.fire(model);
+            }
+        }));
+    }
+    hasAccessedModel(extensionId, model) {
+        return this.getAccessExtensions(model).includes(extensionId.toLowerCase());
+    }
+    async update(model, extensionId, agent, tokenCount) {
+        await this.extensionFeaturesManagementService.getAccess(extensionId, 'languageModels');
+        this.addAccess(model, extensionId.value);
+        let sessionStats = this.sessionStats.get(model);
+        if (!sessionStats) {
+            sessionStats = { extensions: [] };
+            this.sessionStats.set(model, sessionStats);
+        }
+        this.add(sessionStats, extensionId.value, agent, tokenCount);
+        this.write(model, extensionId.value, agent, tokenCount);
+        this._onDidChangeStats.fire(model);
+    }
+    addAccess(model, extensionId) {
+        extensionId = extensionId.toLowerCase();
+        const extensions = this.getAccessExtensions(model);
+        if (!extensions.includes(extensionId)) {
+            extensions.push(extensionId);
+            this._storageService.store(this.getAccessKey(model), JSON.stringify(extensions), -1 , 0 );
+        }
+    }
+    getAccessExtensions(model) {
+        const key = this.getAccessKey(model);
+        const data = this._storageService.get(key, -1 );
+        try {
+            if (data) {
+                const parsed = JSON.parse(data);
+                if (Array.isArray(parsed)) {
+                    return parsed;
+                }
+            }
+        }
+        catch (e) {
+        }
+        return [];
+    }
+    async write(model, extensionId, participant, tokenCount) {
+        const modelStats = await this.read(model);
+        this.add(modelStats, extensionId, participant, tokenCount);
+        this._storageService.store(this.getKey(model), JSON.stringify(modelStats), -1 , 0 );
+    }
+    add(modelStats, extensionId, participant, tokenCount) {
+        let extensionStats = modelStats.extensions.find(e => ExtensionIdentifier.equals(e.extensionId, extensionId));
+        if (!extensionStats) {
+            extensionStats = { extensionId, requestCount: 0, tokenCount: 0, participants: [] };
+            modelStats.extensions.push(extensionStats);
+        }
+        if (participant) {
+            let participantStats = extensionStats.participants.find(p => p.id === participant);
+            if (!participantStats) {
+                participantStats = { id: participant, requestCount: 0, tokenCount: 0 };
+                extensionStats.participants.push(participantStats);
+            }
+            participantStats.requestCount++;
+            participantStats.tokenCount += tokenCount ?? 0;
+        }
+        else {
+            extensionStats.requestCount++;
+            extensionStats.tokenCount += tokenCount ?? 0;
+        }
+    }
+    async read(model) {
+        try {
+            const value = this._storageService.get(this.getKey(model), -1 );
+            if (value) {
+                return JSON.parse(value);
+            }
+        }
+        catch (error) {
+        }
+        return { extensions: [] };
+    }
+    getModel(key) {
+        if (key.startsWith(LanguageModelStatsService_1.MODEL_STATS_STORAGE_KEY_PREFIX)) {
+            return key.substring(LanguageModelStatsService_1.MODEL_STATS_STORAGE_KEY_PREFIX.length);
+        }
+        return undefined;
+    }
+    getKey(model) {
+        return `${LanguageModelStatsService_1.MODEL_STATS_STORAGE_KEY_PREFIX}${model}`;
+    }
+    getAccessKey(model) {
+        return `${LanguageModelStatsService_1.MODEL_ACCESS_STORAGE_KEY_PREFIX}${model}`;
+    }
+};
+LanguageModelStatsService = LanguageModelStatsService_1 = ( (__decorate([
+    ( (__param(0, IExtensionFeaturesManagementService))),
+    ( (__param(1, IStorageService)))
+], LanguageModelStatsService)));
+( (Registry.as(Extensions.ExtensionFeaturesRegistry))).registerExtensionFeature({
+    id: 'languageModels',
+    label: ( localizeWithPath(_moduleId, 0, "Language Models")),
+    description: ( localizeWithPath(_moduleId, 1, "Language models usage statistics of this extension.")),
+    access: {
+        canToggle: false
+    },
+});
+
+export { LanguageModelStatsService };

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

@@ -19,7 +19,9 @@ class LanguageModelsService {
     }
     registerLanguageModelChat(identifier, provider) {
         if (( this._providers.has(identifier))) {
-            throw new Error(`Chat response provider with identifier ${identifier} is already registered.`);
+            throw ( new Error(
+                `Chat response provider with identifier ${identifier} is already registered.`
+            ));
         }
         this._providers.set(identifier, provider);
         this._onDidChangeProviders.fire({ added: [provider.metadata] });
@@ -32,10 +34,17 @@ class LanguageModelsService {
     makeLanguageModelChatRequest(identifier, from, messages, options, progress, token) {
         const provider = this._providers.get(identifier);
         if (!provider) {
-            throw new Error(`Chat response provider with identifier ${identifier} is not registered.`);
+            throw ( new Error(`Chat response provider with identifier ${identifier} is not registered.`));
         }
         return provider.provideChatResponse(messages, from, options, progress, token);
     }
+    computeTokenLength(identifier, message, token) {
+        const provider = this._providers.get(identifier);
+        if (!provider) {
+            throw ( new Error(`Chat response provider with identifier ${identifier} is not registered.`));
+        }
+        return provider.provideTokenCount(message, token);
+    }
 }
 
 export { LanguageModelsService };

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

@@ -35,13 +35,13 @@ let VoiceChatService = class VoiceChatService extends Disposable {
     createPhrases(model) {
         const phrases = ( new Map());
         for (const agent of this.chatAgentService.getActivatedAgents()) {
-            const agentPhrase = `${VoiceChatService_1.PHRASES_LOWER[VoiceChatService_1.AGENT_PREFIX]} ${VoiceChatService_1.CHAT_AGENT_ALIAS.get(agent.id) ?? agent.id}`.toLowerCase();
-            phrases.set(agentPhrase, { agent: agent.id });
+            const agentPhrase = `${VoiceChatService_1.PHRASES_LOWER[VoiceChatService_1.AGENT_PREFIX]} ${VoiceChatService_1.CHAT_AGENT_ALIAS.get(agent.name) ?? agent.name}`.toLowerCase();
+            phrases.set(agentPhrase, { agent: agent.name });
             for (const slashCommand of agent.slashCommands) {
                 const slashCommandPhrase = `${VoiceChatService_1.PHRASES_LOWER[VoiceChatService_1.COMMAND_PREFIX]} ${slashCommand.name}`.toLowerCase();
-                phrases.set(slashCommandPhrase, { agent: agent.id, command: slashCommand.name });
+                phrases.set(slashCommandPhrase, { agent: agent.name, command: slashCommand.name });
                 const agentSlashCommandPhrase = `${agentPhrase} ${slashCommandPhrase}`.toLowerCase();
-                phrases.set(agentSlashCommandPhrase, { agent: agent.id, command: slashCommand.name });
+                phrases.set(agentSlashCommandPhrase, { agent: agent.name, command: slashCommand.name });
             }
         }
         return phrases;

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChat.contribution.js

@@ -1,7 +1,7 @@
 import { registerEditorContribution } from 'vscode/vscode/vs/editor/browser/editorExtensions';
 import { registerAction2 } from 'vscode/vscode/vs/platform/actions/common/actions';
 import { InlineChatController } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatController';
-import { InlineAccessibilityHelpContribution, StartSessionAction, CloseAction, ConfigureInlineChatAction, UnstashSessionAction, ReRunRequestAction, ReRunRequestWithIntentDetectionAction, DiscardHunkAction, DiscardAction, DiscardToClipboardAction, DiscardUndoToNewFileAction, CancelSessionAction, MoveToNextHunk, MoveToPreviousHunk, ArrowOutUpAction, ArrowOutDownAction, FocusInlineChat, ViewInChatAction, ToggleDiffForChange, ReportIssueForBugCommand, AcceptChanges, CopyRecordings } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatActions';
+import { InlineAccessibilityHelpContribution, StartSessionAction, CloseAction, ConfigureInlineChatAction, UnstashSessionAction, DiscardHunkAction, DiscardAction, DiscardToClipboardAction, DiscardUndoToNewFileAction, CancelSessionAction, MoveToNextHunk, MoveToPreviousHunk, ArrowOutUpAction, ArrowOutDownAction, FocusInlineChat, ViewInChatAction, ToggleDiffForChange, AcceptChanges, CopyRecordings } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatActions';
 import { INLINE_CHAT_ID, INTERACTIVE_EDITOR_ACCESSIBILITY_HELP_ID } from 'vscode/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
 import 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import '../common/inlineChatServiceImpl.js';
@@ -18,8 +18,6 @@ registerAction2(StartSessionAction);
 registerAction2(CloseAction);
 registerAction2(ConfigureInlineChatAction);
 registerAction2(UnstashSessionAction);
-registerAction2(ReRunRequestAction);
-registerAction2(ReRunRequestWithIntentDetectionAction);
 registerAction2(DiscardHunkAction);
 registerAction2(DiscardAction);
 registerAction2(DiscardToClipboardAction);
@@ -32,7 +30,6 @@ registerAction2(ArrowOutDownAction);
 registerAction2(FocusInlineChat);
 registerAction2(ViewInChatAction);
 registerAction2(ToggleDiffForChange);
-registerAction2(ReportIssueForBugCommand);
 registerAction2(AcceptChanges);
 registerAction2(CopyRecordings);
 const workbenchContributionsRegistry = ( Registry.as(Extensions.Workbench));

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatSavingServiceImpl.js

@@ -19,6 +19,7 @@ import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
 import { Event } from 'vscode/vscode/vs/base/common/event';
 import { InlineChatController } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatController';
 
+const _moduleId = "vs/workbench/contrib/inlineChat/browser/inlineChatSavingServiceImpl";
 let InlineChatSavingServiceImpl = class InlineChatSavingServiceImpl {
     constructor(_fileConfigService, _editorGroupService, _textFileService, _editorService, _inlineChatSessionService, _configService, _workingCopyFileService, _logService) {
         this._fileConfigService = _fileConfigService;
@@ -29,19 +30,19 @@ let InlineChatSavingServiceImpl = class InlineChatSavingServiceImpl {
         this._configService = _configService;
         this._workingCopyFileService = _workingCopyFileService;
         this._logService = _logService;
-        this._store = ( new DisposableStore());
-        this._saveParticipant = this._store.add(( new MutableDisposable()));
-        this._sessionData = ( new Map());
+        this._store = ( (new DisposableStore()));
+        this._saveParticipant = this._store.add(( (new MutableDisposable())));
+        this._sessionData = ( (new Map()));
         this._store.add(Event.any(_inlineChatSessionService.onDidEndSession, _inlineChatSessionService.onDidStashSession)(e => {
             this._sessionData.get(e.session)?.dispose();
         }));
     }
     dispose() {
         this._store.dispose();
-        dispose(( this._sessionData.values()));
+        dispose(( (this._sessionData.values())));
     }
     markChanged(session) {
-        if (!( this._sessionData.has(session))) {
+        if (!( (this._sessionData.has(session)))) {
             let uri = session.targetUri;
             if (uri.scheme === Schemas.vscodeNotebookCell) {
                 const data = CellUri.parse(uri);
@@ -69,7 +70,7 @@ let InlineChatSavingServiceImpl = class InlineChatSavingServiceImpl {
         }
     }
     _installSaveParticpant() {
-        const queue = ( new Queue());
+        const queue = ( (new Queue()));
         const d1 = this._textFileService.files.addSaveParticipant({
             participate: (model, ctx, progress, token) => {
                 return queue.queue(() => this._participate(ctx.savedFrom ?? model.textEditorModel?.uri, ctx.reason, progress, token));
@@ -89,9 +90,9 @@ let InlineChatSavingServiceImpl = class InlineChatSavingServiceImpl {
         if (!this._configService.getValue("inlineChat.acceptedOrDiscardBeforeSave" )) {
             return;
         }
-        const sessions = ( new Map());
+        const sessions = ( (new Map()));
         for (const [session, data] of this._sessionData) {
-            if (uri?.toString() === ( data.resourceUri.toString())) {
+            if (uri?.toString() === ( (data.resourceUri.toString()))) {
                 sessions.set(session, data);
             }
         }
@@ -101,29 +102,29 @@ let InlineChatSavingServiceImpl = class InlineChatSavingServiceImpl {
         progress.report({
             message: sessions.size === 1
                 ? ( localizeWithPath(
-                'vs/workbench/contrib/inlineChat/browser/inlineChatSavingServiceImpl',
-                'inlineChat',
+                _moduleId,
+                0,
                 "Waiting for Inline Chat changes to be Accepted or Discarded..."
             ))
                 : ( localizeWithPath(
-                'vs/workbench/contrib/inlineChat/browser/inlineChatSavingServiceImpl',
-                'inlineChat.N',
+                _moduleId,
+                1,
                 "Waiting for Inline Chat changes in {0} editors to be Accepted or Discarded...",
                 sessions.size
             ))
         });
-        const { groups, orphans } = this._getGroupsAndOrphans(( sessions.values()));
+        const { groups, orphans } = this._getGroupsAndOrphans(( (sessions.values())));
         const editorsOpenedAndSessionsEnded = this._openAndWait(groups, token).then(() => {
             if (token.isCancellationRequested) {
                 return;
             }
-            return this._openAndWait(( Iterable.map(orphans, s => [this._editorGroupService.activeGroup, s])), token);
+            return this._openAndWait(( (Iterable.map(orphans, s => [this._editorGroupService.activeGroup, s]))), token);
         });
-        const allSessionsEnded = this._whenSessionsEnded(Iterable.concat(( groups.map(tuple => tuple[1])), orphans), token);
+        const allSessionsEnded = this._whenSessionsEnded(Iterable.concat(( (groups.map(tuple => tuple[1]))), orphans), token);
         await Promise.race([allSessionsEnded, editorsOpenedAndSessionsEnded]);
     }
     _getGroupsAndOrphans(sessions) {
-        const groupByEditor = ( new Map());
+        const groupByEditor = ( (new Map()));
         for (const group of this._editorGroupService.getGroups(1 )) {
             const candidate = group.activeEditorPane?.getControl();
             if (isCodeEditor(candidate)) {
@@ -131,7 +132,7 @@ let InlineChatSavingServiceImpl = class InlineChatSavingServiceImpl {
             }
         }
         const groups = [];
-        const orphans = ( new Set());
+        const orphans = ( (new Set()));
         for (const data of sessions) {
             const editor = this._inlineChatSessionService.getCodeEditor(data.session);
             const group = groupByEditor.get(editor);
@@ -148,7 +149,7 @@ let InlineChatSavingServiceImpl = class InlineChatSavingServiceImpl {
         return { groups, orphans };
     }
     async _openAndWait(groups, token) {
-        const dataByGroup = ( new Map());
+        const dataByGroup = ( (new Map()));
         for (const [group, data] of groups) {
             let array = dataByGroup.get(group);
             if (!array) {
@@ -161,7 +162,7 @@ let InlineChatSavingServiceImpl = class InlineChatSavingServiceImpl {
             if (token.isCancellationRequested) {
                 break;
             }
-            array.sort((a, b) => compare(( a.session.targetUri.toString()), ( b.session.targetUri.toString())));
+            array.sort((a, b) => compare(( (a.session.targetUri.toString())), ( (b.session.targetUri.toString()))));
             for (const data of array) {
                 const input = { resource: data.resourceUri };
                 const pane = await this._editorService.openEditor(input, group);
@@ -174,7 +175,7 @@ let InlineChatSavingServiceImpl = class InlineChatSavingServiceImpl {
                         if (cell) {
                             await notebookEditor.revealRangeInCenterIfOutsideViewportAsync(cell, data.session.wholeRange.value);
                         }
-                        const tuple = notebookEditor.codeEditors.find(tuple => tuple[1].getModel()?.uri.toString() === ( data.session.targetUri.toString()));
+                        const tuple = notebookEditor.codeEditors.find(tuple => tuple[1].getModel()?.uri.toString() === ( (data.session.targetUri.toString())));
                         editor = tuple?.[1];
                     }
                 }
@@ -188,13 +189,13 @@ let InlineChatSavingServiceImpl = class InlineChatSavingServiceImpl {
                 }
                 this._inlineChatSessionService.moveSession(data.session, editor);
                 InlineChatController.get(editor)?.showSaveHint();
-                this._logService.info('WAIT for session to end', editor.getId(), ( data.session.targetUri.toString()));
+                this._logService.info('WAIT for session to end', editor.getId(), ( (data.session.targetUri.toString())));
                 await this._whenSessionsEnded(Iterable.single(data), token);
             }
         }
     }
     async _whenSessionsEnded(iterable, token) {
-        const sessions = ( new Map());
+        const sessions = ( (new Map()));
         for (const item of iterable) {
             sessions.set(item.session, item);
         }
@@ -202,7 +203,7 @@ let InlineChatSavingServiceImpl = class InlineChatSavingServiceImpl {
             return;
         }
         let listener;
-        const whenEnded = ( new Promise(resolve => {
+        const whenEnded = ( (new Promise(resolve => {
             listener = Event.any(this._inlineChatSessionService.onDidEndSession, this._inlineChatSessionService.onDidStashSession)(e => {
                 const data = sessions.get(e.session);
                 if (data) {
@@ -213,7 +214,7 @@ let InlineChatSavingServiceImpl = class InlineChatSavingServiceImpl {
                     }
                 }
             });
-        }));
+        })));
         try {
             await raceCancellation(whenEnded, token);
         }
@@ -222,15 +223,15 @@ let InlineChatSavingServiceImpl = class InlineChatSavingServiceImpl {
         }
     }
 };
-InlineChatSavingServiceImpl = ( __decorate([
-    ( __param(0, IFilesConfigurationService)),
-    ( __param(1, IEditorGroupsService)),
-    ( __param(2, ITextFileService)),
-    ( __param(3, IEditorService)),
-    ( __param(4, IInlineChatSessionService)),
-    ( __param(5, IConfigurationService)),
-    ( __param(6, IWorkingCopyFileService)),
-    ( __param(7, ILogService))
-], InlineChatSavingServiceImpl));
+InlineChatSavingServiceImpl = ( (__decorate([
+    ( (__param(0, IFilesConfigurationService))),
+    ( (__param(1, IEditorGroupsService))),
+    ( (__param(2, ITextFileService))),
+    ( (__param(3, IEditorService))),
+    ( (__param(4, IInlineChatSessionService))),
+    ( (__param(5, IConfigurationService))),
+    ( (__param(6, IWorkingCopyFileService))),
+    ( (__param(7, ILogService)))
+], InlineChatSavingServiceImpl)));
 
 export { InlineChatSavingServiceImpl };