@codingame/monaco-vscode-extensions-service-override 22.1.8 → 23.0.0

package/vscode/src/vs/workbench/api/browser/mainThreadChatAgents2.js

@@ -19,15 +19,17 @@ import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/plat
 import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
 import { IChatAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents.service';
 import { IChatEditingService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService.service';
-import { ChatRequestAgentPart } from '@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/common/chatParserTypes';
-import { ChatRequestParser } from '@codingame/monaco-vscode-5084de40-f866-5cb5-9d9b-33a10f6f235d-common/vscode/vs/workbench/contrib/chat/common/chatRequestParser';
+import { ChatRequestAgentPart } 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 { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
+import { IChatSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service';
+import { LocalChatSessionUri } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatUri';
 import { ChatModeKind, ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
 import { ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
 import { NotebookDto } from './mainThreadNotebookDto.js';
-import { addDynamicVariableActionId } from '@codingame/monaco-vscode-bba55be6-41a2-50cd-a3cc-8bafa35bfa89-common/vscode/vs/workbench/contrib/chat/browser/contrib/chatDynamicVariablesConstant';
+import { addDynamicVariableActionId } from '@codingame/monaco-vscode-9d2c06d1-1f89-51a5-9964-aa01fe50c198-common/vscode/vs/workbench/contrib/chat/browser/contrib/chatDynamicVariablesConstant';
 
 class MainThreadChatTask {
     get onDidAddProgress() { return this._onDidAddProgress.event; }
@@ -60,9 +62,10 @@ class MainThreadChatTask {
     }
 }
 let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
-    constructor(extHostContext, _chatAgentService, _chatService, _chatEditingService, _languageFeaturesService, _chatWidgetService, _instantiationService, _logService, _extensionService, _uriIdentityService) {
+    constructor(extHostContext, _chatAgentService, _chatSessionService, _chatService, _chatEditingService, _languageFeaturesService, _chatWidgetService, _instantiationService, _logService, _extensionService, _uriIdentityService) {
         super();
         this._chatAgentService = _chatAgentService;
+        this._chatSessionService = _chatSessionService;
         this._chatService = _chatService;
         this._chatEditingService = _chatEditingService;
         this._languageFeaturesService = _languageFeaturesService;
@@ -81,7 +84,10 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
         this._unresolvedAnchors = ( new Map());
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostChatAgents2));
         this._register(this._chatService.onDidDisposeSession(e => {
-            this._proxy.$releaseSession(e.sessionId);
+            const localSessionId = LocalChatSessionUri.parseLocalSessionId(e.sessionResource);
+            if (localSessionId) {
+                this._proxy.$releaseSession(localSessionId);
+            }
         }));
         this._register(this._chatService.onDidPerformUserAction(e => {
             if (typeof e.agentId === 'string') {
@@ -117,7 +123,8 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
     async $registerAgent(handle, extension, id, metadata, dynamicProps) {
         await this._extensionService.whenInstalledExtensionsRegistered();
         const staticAgentRegistration = this._chatAgentService.getAgent(id, true);
-        if (!staticAgentRegistration && !dynamicProps) {
+        const chatSessionRegistration = this._chatSessionService.getAllChatSessionContributions().find(c => c.type === id || c.alternativeIds?.includes(id));
+        if (!staticAgentRegistration && !chatSessionRegistration && !dynamicProps) {
             if (this._chatAgentService.getAgentsByName(id).length) {
                 throw ( new Error(
                     `chatParticipant must be declared with an ID in package.json. The "id" property may be missing! "${id}"`
@@ -127,10 +134,14 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
         }
         const impl = {
             invoke: async (request, progress, history, token) => {
-                this._pendingProgress.set(request.requestId, progress);
+                const chatSession = this._chatService.getSessionByLegacyId(request.sessionId);
+                this._pendingProgress.set(request.requestId, { progress, chatSession });
                 try {
-                    const chatSessionContext = this._chatService.getChatSessionFromInternalId(request.sessionId);
-                    return (await this._proxy.$invokeAgent(handle, request, { history, chatSessionContext }, token)) ?? {};
+                    return (await this._proxy.$invokeAgent(handle, request, {
+                        history,
+                        chatSessionContext: chatSession?.contributedChatSession,
+                        chatSummary: request.chatSummary
+                    }, token)) ?? {};
                 }
                 finally {
                     this._pendingProgress.delete(request.requestId);
@@ -193,9 +204,25 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
         this._chatAgentService.updateAgent(data.id, revive(metadataUpdate));
     }
     async $handleProgressChunk(requestId, chunks) {
+        const pendingProgress = this._pendingProgress.get(requestId);
+        if (!pendingProgress) {
+            this._logService.warn(`MainThreadChatAgents2#$handleProgressChunk: No pending progress for requestId ${requestId}`);
+            return;
+        }
+        const { progress, chatSession } = pendingProgress;
         const chatProgressParts = [];
-        chunks.forEach(item => {
+        for (const item of chunks) {
             const [progress, responsePartHandle] = Array.isArray(item) ? item : [item];
+            if (progress.kind === 'externalEdits') {
+                const response = chatSession?.getRequests().at(-1)?.response;
+                if (chatSession?.editingSession && responsePartHandle !== undefined && response) {
+                    const parts = progress.start
+                        ? await chatSession.editingSession.startExternalEdits(response, responsePartHandle, revive(progress.resources))
+                        : await chatSession.editingSession.stopExternalEdits(response, responsePartHandle);
+                    chatProgressParts.push(...parts);
+                }
+                continue;
+            }
             const revivedProgress = progress.kind === 'notebookEdit'
                 ? ChatNotebookEdit.fromChatEdit(progress)
                 : revive(progress);
@@ -211,7 +238,6 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
                     const task = ( new MainThreadChatTask(revivedProgress.content));
                     this._activeTasks.set(responsePartId, task);
                     chatProgressParts.push(task);
-                    return;
                 }
                 else if (responsePartHandle !== undefined) {
                     const responsePartId = `${requestId}_${responsePartHandle}`;
@@ -225,13 +251,14 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
                             else {
                                 task?.complete(undefined);
                             }
-                            return;
+                            break;
                         case 'warning':
                         case 'reference':
                             task?.add(revivedProgress);
-                            return;
+                            break;
                     }
                 }
+                continue;
             }
             if (revivedProgress.kind === 'inlineReference' && revivedProgress.resolveId) {
                 if (!( this._unresolvedAnchors.has(requestId))) {
@@ -240,8 +267,8 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
                 this._unresolvedAnchors.get(requestId)?.set(revivedProgress.resolveId, revivedProgress);
             }
             chatProgressParts.push(revivedProgress);
-        });
-        this._pendingProgress.get(requestId)?.(chatProgressParts);
+        }
+        progress(chatProgressParts);
     }
     $handleAnchorResolve(requestId, handle, resolveAnchor) {
         const anchor = this._unresolvedAnchors.get(requestId)?.get(handle);
@@ -274,7 +301,7 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
                 if (query && !( triggerCharacters.some(c => query.startsWith(c)))) {
                     return;
                 }
-                const parsedRequest = this._instantiationService.createInstance(ChatRequestParser).parseChatRequest(widget.viewModel.sessionId, model.getValue()).parts;
+                const parsedRequest = this._instantiationService.createInstance(ChatRequestParser).parseChatRequest(widget.viewModel.sessionResource, model.getValue()).parts;
                 const agentPart = parsedRequest.find((part) => part instanceof ChatRequestAgentPart);
                 const thisAgentId = this._agents.get(handle)?.id;
                 if (agentPart?.agent.id !== thisAgentId) {
@@ -338,14 +365,15 @@ let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
 MainThreadChatAgents2 = __decorate([
     extHostNamedCustomer(MainContext.MainThreadChatAgents2),
     ( __param(1, IChatAgentService)),
-    ( __param(2, IChatService)),
-    ( __param(3, IChatEditingService)),
-    ( __param(4, ILanguageFeaturesService)),
-    ( __param(5, IChatWidgetService)),
-    ( __param(6, IInstantiationService)),
-    ( __param(7, ILogService)),
-    ( __param(8, IExtensionService)),
-    ( __param(9, IUriIdentityService))
+    ( __param(2, IChatSessionsService)),
+    ( __param(3, IChatService)),
+    ( __param(4, IChatEditingService)),
+    ( __param(5, ILanguageFeaturesService)),
+    ( __param(6, IChatWidgetService)),
+    ( __param(7, IInstantiationService)),
+    ( __param(8, ILogService)),
+    ( __param(9, IExtensionService)),
+    ( __param(10, IUriIdentityService))
 ], MainThreadChatAgents2);
 function computeCompletionRanges(model, position, reg) {
     const varWord = getWordAtText(position.column, reg, model.getLineContent(position.lineNumber), 0);

package/vscode/src/vs/workbench/api/browser/mainThreadChatContext.d.ts

@@ -0,0 +1,16 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ThemeIcon } from "@codingame/monaco-vscode-api/vscode/vs/base/common/themables";
+import { IChatContextSupport } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatContext";
+import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
+import { IDocumentFilterDto, MainThreadChatContextShape } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
+import { IChatContextService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatContextService.service";
+export declare class MainThreadChatContext extends Disposable implements MainThreadChatContextShape {
+    private readonly _chatContextService;
+    private readonly _proxy;
+    private readonly _providers;
+    constructor(extHostContext: IExtHostContext, _chatContextService: IChatContextService);
+    $registerChatContextProvider(handle: number, id: string, selector: IDocumentFilterDto[], _options: {
+        icon: ThemeIcon;
+    }, support: IChatContextSupport): void;
+    $unregisterChatContextProvider(handle: number): void;
+}

package/vscode/src/vs/workbench/api/browser/mainThreadChatContext.js

@@ -0,0 +1,43 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
+import { IChatContextService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatContextService.service';
+
+let MainThreadChatContext = class MainThreadChatContext extends Disposable {
+    constructor(extHostContext, _chatContextService) {
+        super();
+        this._chatContextService = _chatContextService;
+        this._providers = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostChatContext));
+    }
+    $registerChatContextProvider(handle, id, selector, _options, support) {
+        this._providers.set(handle, { selector, support, id });
+        this._chatContextService.registerChatContextProvider(id, selector, {
+            provideChatContext: (token) => {
+                return this._proxy.$provideChatContext(handle, token);
+            },
+            resolveChatContext: support.supportsResolve ? (context, token) => {
+                return this._proxy.$resolveChatContext(handle, context, token);
+            } : undefined,
+            provideChatContextForResource: support.supportsResource ? (resource, token) => {
+                return this._proxy.$provideChatContextForResource(handle, { resource }, token);
+            } : undefined
+        });
+    }
+    $unregisterChatContextProvider(handle) {
+        const provider = this._providers.get(handle);
+        if (!provider) {
+            return;
+        }
+        this._chatContextService.unregisterChatContextProvider(provider.id);
+        this._providers.delete(handle);
+    }
+};
+MainThreadChatContext = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadChatContext),
+    ( __param(1, IChatContextService))
+], MainThreadChatContext);
+
+export { MainThreadChatContext };

package/vscode/src/vs/workbench/api/browser/mainThreadChatSessions.d.ts

@@ -1,24 +1,24 @@
 import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { URI, UriComponents } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { IDialogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service";
 import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
-import { IChatAgentRequest } from "@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/common/chatAgents";
+import { IChatAgentRequest } from "@codingame/monaco-vscode-aac7027b-326c-513a-95a9-e4eedd151b38-common/vscode/vs/workbench/contrib/chat/common/chatAgents";
 import { IChatContentInlineReference, IChatProgress } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService";
-import { ChatSession, IChatSessionHistoryItem } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService";
+import { IChatSession, IChatSessionHistoryItem } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService";
 import { IChatSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service";
-import { EditorGroupColumn } from "@codingame/monaco-vscode-a17e9d37-b6c1-5556-8402-5db73960fae3-common/vscode/vs/workbench/services/editor/common/editorGroupColumn";
 import { IEditorGroupsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service";
 import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
 import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
 import { Dto } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/proxyIdentifier";
-import { IViewsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/views/common/viewsService.service";
 import { ExtHostChatSessionsShape, IChatProgressDto, MainThreadChatSessionsShape } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
-export declare class ObservableChatSession extends Disposable implements ChatSession {
-    static generateSessionKey(providerHandle: number, sessionId: string): string;
-    readonly sessionId: string;
+export declare class ObservableChatSession extends Disposable implements IChatSession {
+    readonly sessionResource: URI;
     readonly providerHandle: number;
     readonly history: Array<IChatSessionHistoryItem>;
+    private _options?;
+    get options(): Record<string, string> | undefined;
     private readonly _progressObservable;
     private readonly _isCompleteObservable;
     private readonly _onWillDispose;
@@ -34,10 +34,9 @@ export declare class ObservableChatSession extends Disposable implements ChatSes
     private readonly _providerHandle;
     private readonly _logService;
     private readonly _dialogService;
-    get sessionKey(): string;
     get progressObs(): IObservable<IChatProgress[]>;
     get isCompleteObs(): IObservable<boolean>;
-    constructor(id: string, providerHandle: number, proxy: ExtHostChatSessionsShape, logService: ILogService, dialogService: IDialogService);
+    constructor(resource: URI, providerHandle: number, proxy: ExtHostChatSessionsShape, logService: ILogService, dialogService: IDialogService);
     initialize(token: CancellationToken): Promise<void>;
     private _doInitializeContent;
     /**
@@ -60,29 +59,36 @@ export declare class MainThreadChatSessions extends Disposable implements MainTh
     private readonly _editorService;
     private readonly editorGroupService;
     private readonly _logService;
-    private readonly _viewsService;
     private readonly _itemProvidersRegistrations;
     private readonly _contentProvidersRegistrations;
+    private readonly _sessionTypeToHandle;
     private readonly _activeSessions;
     private readonly _sessionDisposables;
     private readonly _proxy;
-    constructor(_extHostContext: IExtHostContext, _chatSessionsService: IChatSessionsService, _dialogService: IDialogService, _editorService: IEditorService, editorGroupService: IEditorGroupsService, _logService: ILogService, _viewsService: IViewsService);
+    constructor(_extHostContext: IExtHostContext, _chatSessionsService: IChatSessionsService, _dialogService: IDialogService, _editorService: IEditorService, editorGroupService: IEditorGroupsService, _logService: ILogService);
+    private _getHandleForSessionType;
     $registerChatSessionItemProvider(handle: number, chatSessionType: string): void;
     $onDidChangeChatSessionItems(handle: number): void;
-    $onDidCommitChatSessionItem(handle: number, original: string, modified: string): void;
+    $onDidCommitChatSessionItem(handle: number, originalComponents: UriComponents, modifiedCompoennts: UriComponents): Promise<void>;
     private _provideChatSessionItems;
     private _provideNewChatSessionItem;
     private _provideChatSessionContent;
     $unregisterChatSessionItemProvider(handle: number): void;
-    $registerChatSessionContentProvider(handle: number, chatSessionType: string): void;
+    $registerChatSessionContentProvider(handle: number, chatSessionScheme: string): void;
     $unregisterChatSessionContentProvider(handle: number): void;
-    $handleProgressChunk(handle: number, sessionId: string, requestId: string, chunks: (IChatProgressDto | [
+    $handleProgressChunk(handle: number, sessionResource: UriComponents, requestId: string, chunks: (IChatProgressDto | [
         IChatProgressDto,
         number
     ])[]): Promise<void>;
-    $handleProgressComplete(handle: number, sessionId: string, requestId: string): void;
-    $handleAnchorResolve(handle: number, sessionId: string, requestId: string, requestHandle: string, anchor: Dto<IChatContentInlineReference>): void;
+    $handleProgressComplete(handle: number, sessionResource: UriComponents, requestId: string): void;
+    $handleAnchorResolve(handle: number, sesssionResource: UriComponents, requestId: string, requestHandle: string, anchor: Dto<IChatContentInlineReference>): void;
     dispose(): void;
     private _reviveTooltip;
-    $showChatSession(chatSessionType: string, sessionId: string, position: EditorGroupColumn | undefined): Promise<void>;
+    /**
+     * Notify the extension about option changes for a session
+     */
+    notifyOptionsChange(handle: number, sessionResource: URI, updates: ReadonlyArray<{
+        optionId: string;
+        value: string | undefined;
+    }>): Promise<void>;
 }