@codingame/monaco-vscode-api 22.1.9 → 23.0.0

package/vscode/src/vs/workbench/api/common/extHostChatAgents2.js

@@ -18,7 +18,7 @@ import { ChatAgentLocation } from '../../contrib/chat/common/constants.js';
 import { checkProposedApiEnabled, isProposedApiEnabled } from '../../services/extensions/common/extensions.js';
 import { MainContext } from './extHost.protocol.js';
 import { ChatResponseWarningPart, ChatResponseReferencePart, ChatTaskResult, ChatTask, ChatResponseProgressPart, ChatResponseThinkingProgressPart as ChatResponseThinkingProgressPart$1, ChatResponseAnchorPart as ChatResponseAnchorPart$1, ChatPrepareToolInvocationPart as ChatPrepareToolInvocationPart$1, ChatResponsePart, ChatResponseConfirmationPart as ChatResponseConfirmationPart$1, ChatResponseNotebookEditPart as ChatResponseNotebookEditPart$1, ChatResponseTextEditPart as ChatResponseTextEditPart$1, ChatResponseCodeCitationPart as ChatResponseCodeCitationPart$1, ChatResponseCommandButtonPart as ChatResponseCommandButtonPart$1, ChatResponseFilesPart, ChatResponseCodeblockUriPart as ChatResponseCodeblockUriPart$1, ChatResponseMarkdownWithVulnerabilitiesPart as ChatResponseMarkdownWithVulnerabilitiesPart$1, ChatResponseMarkdownPart as ChatResponseMarkdownPart$1, ChatRequestDraft, ChatAgentRequest, ChatLocation, Selection, Range, ChatAgentResult, ChatLanguageModelToolReference, ChatPromptReference, ChatFollowup, ChatAgentUserActionEvent, ChatAgentCompletionItem, MarkdownString as MarkdownString$1 } from './extHostTypeConverters.js';
-import { ChatResponseTextEditPart, ChatResponseNotebookEditPart, ChatResponseMarkdownWithVulnerabilitiesPart, ChatResponseWarningPart as ChatResponseWarningPart$1, ChatResponseConfirmationPart, ChatResponseCodeCitationPart, ChatResponseMovePart, ChatResponseExtensionsPart, ChatResponseThinkingProgressPart, ChatResponsePullRequestPart, ChatResponseProgressPart2, ChatResponseReferencePart as ChatResponseReferencePart$1, ChatResponseAnchorPart, ChatPrepareToolInvocationPart, ChatResponseCommandButtonPart, ChatResponseFileTreePart, ChatResponseCodeblockUriPart, ChatResponseMarkdownPart, ChatRequestEditorData, ChatRequestNotebookData, LanguageModelError, ChatRequestTurn, ChatResponseTurn, ChatResultFeedbackKind, ThemeIcon } from './extHostTypes.js';
+import { ChatResponseTextEditPart, ChatResponseNotebookEditPart, ChatResponseMarkdownWithVulnerabilitiesPart, ChatResponseWarningPart as ChatResponseWarningPart$1, ChatResponseConfirmationPart, ChatResponseCodeCitationPart, ChatResponseMovePart, ChatResponseExtensionsPart, ChatResponseExternalEditPart, ChatResponseThinkingProgressPart, ChatResponsePullRequestPart, ChatResponseProgressPart2, ChatResponseReferencePart as ChatResponseReferencePart$1, ChatResponseAnchorPart, ChatPrepareToolInvocationPart, ChatResponseCommandButtonPart, ChatResponseFileTreePart, ChatResponseCodeblockUriPart, ChatResponseMarkdownPart, ChatRequestEditorData, ChatRequestNotebookData, LanguageModelError, ChatRequestTurn, ChatResponseTurn, ChatResultFeedbackKind, ThemeIcon } from './extHostTypes.js';
 import { MarkdownString } from './extHostTypes/markdownString.js';
 
 class ChatAgentResponseStream {
@@ -53,14 +53,15 @@ class ChatAgentResponseStream {
                 }
             }
             const sendQueue = [];
-            const notify = [];
+            let notify = [];
             function send(chunk, handle) {
                 const newLen = sendQueue.push(handle !== undefined ? [chunk, handle] : chunk);
                 if (newLen === 1) {
                     queueMicrotask(() => {
+                        const toNotify = notify;
+                        notify = [];
                         that._proxy.$handleProgressChunk(that._request.requestId, sendQueue).finally(() => {
-                            notify.forEach(f => f());
-                            notify.length = 0;
+                            toNotify.forEach(f => f());
                         });
                         sendQueue.length = 0;
                     });
@@ -227,6 +228,18 @@ class ChatAgentResponseStream {
                     _report(dto);
                     return this;
                 },
+                async externalEdit(target, callback) {
+                    throwIfDone(this.externalEdit);
+                    const resources = Array.isArray(target) ? target : [target];
+                    const operationId = taskHandlePool++;
+                    await send({ kind: 'externalEdits', start: true, resources }, operationId);
+                    try {
+                        return await callback();
+                    }
+                    finally {
+                        await send({ kind: 'externalEdits', start: false, resources }, operationId);
+                    }
+                },
                 confirmation(title, message, data, buttons) {
                     throwIfDone(this.confirmation);
                     checkProposedApiEnabled(that._extension, 'chatParticipantAdditions');
@@ -253,6 +266,7 @@ class ChatAgentResponseStream {
                         part instanceof ChatResponseCodeCitationPart ||
                         part instanceof ChatResponseMovePart ||
                         part instanceof ChatResponseExtensionsPart ||
+                        part instanceof ChatResponseExternalEditPart ||
                         part instanceof ChatResponseThinkingProgressPart ||
                         part instanceof ChatResponsePullRequestPart ||
                         part instanceof ChatResponseProgressPart2) {
@@ -291,6 +305,11 @@ class ChatAgentResponseStream {
                         _report(dto);
                         return this;
                     }
+                    else if (part instanceof ChatResponseExternalEditPart) {
+                        const p = this.externalEdit(part.uris, part.callback);
+                        p.then(() => part.didGetApplied());
+                        return this;
+                    }
                     else {
                         const dto = ChatResponsePart.from(part, that._commandsConverter, that._sessionDisposables);
                         _report(dto);
@@ -457,13 +476,17 @@ class ExtHostChatAgents2 extends Disposable {
             if (context.chatSessionContext) {
                 chatSessionContext = {
                     chatSessionItem: {
-                        id: context.chatSessionContext.chatSessionId,
+                        resource: URI.revive(context.chatSessionContext.chatSessionResource),
                         label: context.chatSessionContext.isUntitled ? 'Untitled Session' : 'Session',
                     },
                     isUntitled: context.chatSessionContext.isUntitled,
                 };
             }
-            const chatContext = { history, chatSessionContext };
+            const chatContext = {
+                history,
+                chatSessionContext,
+                chatSummary: context.chatSummary
+            };
             const task = agent.invoke(extRequest, chatContext, stream.apiObject, token);
             return await raceCancellationWithTimeout(1000, Promise.resolve(task).then((result) => {
                 if (result?.metadata) {

package/vscode/src/vs/workbench/api/common/extHostChatContext.d.ts

@@ -0,0 +1,22 @@
+import type * as vscode from "vscode";
+import { CancellationToken } from "../../../base/common/cancellation.js";
+import { UriComponents } from "../../../base/common/uri.js";
+import { ExtHostChatContextShape } from "./extHost.protocol.js";
+import { IExtHostRpcService } from "./extHostRpcService.js";
+import { IChatContextItem } from "../../services/chat/common/chatContext.js";
+export declare class ExtHostChatContext implements ExtHostChatContextShape {
+    _serviceBrand: undefined;
+    private _proxy;
+    private _handlePool;
+    private _providers;
+    private _itemPool;
+    private _items;
+    constructor(extHostRpc: IExtHostRpcService);
+    $provideChatContext(handle: number, token: CancellationToken): Promise<IChatContextItem[]>;
+    $provideChatContextForResource(handle: number, options: {
+        resource: UriComponents;
+    }, token: CancellationToken): Promise<IChatContextItem | undefined>;
+    $resolveChatContext(handle: number, context: IChatContextItem, token: CancellationToken): Promise<IChatContextItem>;
+    registerChatContextProvider(selector: vscode.DocumentSelector, id: string, provider: vscode.ChatContextProvider): vscode.Disposable;
+    private _getProvider;
+}

package/vscode/src/vs/workbench/api/common/extHostChatContext.js

@@ -0,0 +1,99 @@
+
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { URI } from '../../../base/common/uri.js';
+import { MainContext } from './extHost.protocol.js';
+import { DocumentSelector } from './extHostTypeConverters.js';
+import { IExtHostRpcService } from './extHostRpcService.js';
+
+let ExtHostChatContext = class ExtHostChatContext {
+    constructor(extHostRpc) {
+        this._handlePool = 0;
+        this._providers = ( new Map());
+        this._itemPool = 0;
+        this._items = ( new Map());
+        this._proxy = ( extHostRpc.getProxy(MainContext.MainThreadChatContext));
+    }
+    async $provideChatContext(handle, token) {
+        this._items.delete(handle);
+        const provider = this._getProvider(handle);
+        if (!provider.provideChatContextExplicit) {
+            throw ( new Error('provideChatContext not implemented'));
+        }
+        const result = (await provider.provideChatContextExplicit(token)) ?? [];
+        const items = [];
+        for (const item of result) {
+            const itemHandle = this._itemPool++;
+            if (!( this._items.has(handle))) {
+                this._items.set(handle, ( new Map()));
+            }
+            this._items.get(handle).set(itemHandle, item);
+            items.push({
+                handle: itemHandle,
+                icon: item.icon,
+                label: item.label,
+                modelDescription: item.modelDescription,
+                value: item.value
+            });
+        }
+        return items;
+    }
+    async $provideChatContextForResource(handle, options, token) {
+        const provider = this._getProvider(handle);
+        if (!provider.provideChatContextForResource) {
+            throw ( new Error('provideChatContextForResource not implemented'));
+        }
+        let result = await provider.provideChatContextForResource({ resource: URI.revive(options.resource) }, token);
+        if (result && (result.value === undefined)) {
+            result = await provider.resolveChatContext(result, token);
+        }
+        const item = result ? {
+            handle: this._itemPool++,
+            icon: result.icon,
+            label: result.label,
+            modelDescription: result.modelDescription,
+            value: result.value
+        } : undefined;
+        return item;
+    }
+    async $resolveChatContext(handle, context, token) {
+        const provider = this._getProvider(handle);
+        if (!provider.resolveChatContext) {
+            throw ( new Error('resolveChatContext not implemented'));
+        }
+        const extItem = this._items.get(handle)?.get(context.handle);
+        if (!extItem) {
+            throw ( new Error('Chat context item not found'));
+        }
+        const extResult = await provider.resolveChatContext(extItem, token);
+        const result = extResult ?? context;
+        return {
+            handle: context.handle,
+            icon: result.icon,
+            label: result.label,
+            modelDescription: result.modelDescription,
+            value: result.value
+        };
+    }
+    registerChatContextProvider(selector, id, provider) {
+        const handle = this._handlePool++;
+        this._providers.set(handle, provider);
+        this._proxy.$registerChatContextProvider(handle, `${id}`, DocumentSelector.from(selector), {}, { supportsResource: !!provider.provideChatContextForResource, supportsResolve: !!provider.resolveChatContext });
+        return {
+            dispose: () => {
+                this._providers.delete(handle);
+                this._proxy.$unregisterChatContextProvider(handle);
+            }
+        };
+    }
+    _getProvider(handle) {
+        if (!( this._providers.has(handle))) {
+            throw ( new Error('Chat context provider not found'));
+        }
+        return this._providers.get(handle);
+    }
+};
+ExtHostChatContext = ( __decorate([
+    ( __param(0, IExtHostRpcService))
+], ExtHostChatContext));
+
+export { ExtHostChatContext };

package/vscode/src/vs/workbench/api/common/extHostChatSessions.d.ts

@@ -1,11 +1,12 @@
 import type * as vscode from "vscode";
 import { CancellationToken } from "../../../base/common/cancellation.js";
 import { Disposable } from "../../../base/common/lifecycle.js";
+import { UriComponents } from "../../../base/common/uri.js";
 import { IExtensionDescription } from "../../../platform/extensions/common/extensions.js";
 import { ILogService } from "../../../platform/log/common/log.service.js";
-import { IChatAgentRequest, IChatAgentResult } from "@codingame/monaco-vscode-b994942c-360d-5b68-8a33-77d4bde6b714-common/vscode/vs/workbench/contrib/chat/common/chatAgents";
+import { IChatAgentRequest, IChatAgentResult } from "@codingame/monaco-vscode-aac7027b-326c-513a-95a9-e4eedd151b38-common/vscode/vs/workbench/contrib/chat/common/chatAgents";
 import { IChatSessionItem } from "../../contrib/chat/common/chatSessionsService.js";
-import { ChatSessionDto, ExtHostChatSessionsShape } from "./extHost.protocol.js";
+import { ChatSessionDto, ExtHostChatSessionsShape, IChatSessionProviderOptions } from "./extHost.protocol.js";
 import { ExtHostCommands } from "./extHostCommands.js";
 import { ExtHostLanguageModels } from "./extHostLanguageModels.js";
 import { IExtHostRpcService } from "./extHostRpcService.js";
@@ -20,11 +21,19 @@ export declare class ExtHostChatSessions extends Disposable implements ExtHostCh
     private readonly _chatSessionContentProviders;
     private _nextChatSessionItemProviderHandle;
     private _nextChatSessionContentProviderHandle;
-    private readonly _sessionMap;
+    /**
+     * Map of uri -> chat session items
+     *
+     * TODO: this isn't cleared/updated properly
+     */
+    private readonly _sessionItems;
+    /**
+     * Map of uri -> chat sessions infos
+     */
+    private readonly _extHostChatSessions;
     constructor(commands: ExtHostCommands, _languageModels: ExtHostLanguageModels, _extHostRpc: IExtHostRpcService, _logService: ILogService);
     registerChatSessionItemProvider(extension: IExtensionDescription, chatSessionType: string, provider: vscode.ChatSessionItemProvider): vscode.Disposable;
-    registerChatSessionContentProvider(extension: IExtensionDescription, chatSessionType: string, chatParticipant: vscode.ChatParticipant, provider: vscode.ChatSessionContentProvider, capabilities?: vscode.ChatSessionCapabilities): vscode.Disposable;
-    showChatSession(_extension: IExtensionDescription, chatSessionType: string, sessionId: string, options: vscode.ChatSessionShowOptions | undefined): Promise<void>;
+    registerChatSessionContentProvider(extension: IExtensionDescription, chatSessionScheme: string, chatParticipant: vscode.ChatParticipant, provider: vscode.ChatSessionContentProvider, capabilities?: vscode.ChatSessionCapabilities): vscode.Disposable;
     private convertChatSessionStatus;
     private convertChatSessionItem;
     $provideNewChatSessionItem(handle: number, options: {
@@ -32,10 +41,17 @@ export declare class ExtHostChatSessions extends Disposable implements ExtHostCh
         metadata?: any;
     }, token: CancellationToken): Promise<IChatSessionItem>;
     $provideChatSessionItems(handle: number, token: vscode.CancellationToken): Promise<IChatSessionItem[]>;
-    private readonly _extHostChatSessions;
-    $provideChatSessionContent(handle: number, id: string, token: CancellationToken): Promise<ChatSessionDto>;
-    $interruptChatSessionActiveResponse(providerHandle: number, sessionId: string, requestId: string): Promise<void>;
-    $disposeChatSessionContent(providerHandle: number, sessionId: string): Promise<void>;
-    $invokeChatSessionRequestHandler(handle: number, id: string, request: IChatAgentRequest, history: any[], token: CancellationToken): Promise<IChatAgentResult>;
+    $provideChatSessionContent(handle: number, sessionResourceComponents: UriComponents, token: CancellationToken): Promise<ChatSessionDto>;
+    $provideHandleOptionsChange(handle: number, sessionResourceComponents: UriComponents, updates: ReadonlyArray<{
+        optionId: string;
+        value: string | undefined;
+    }>, token: CancellationToken): Promise<void>;
+    $provideChatSessionProviderOptions(handle: number, token: CancellationToken): Promise<IChatSessionProviderOptions | undefined>;
+    $interruptChatSessionActiveResponse(providerHandle: number, sessionResource: UriComponents, requestId: string): Promise<void>;
+    $disposeChatSessionContent(providerHandle: number, sessionResource: UriComponents): Promise<void>;
+    $invokeChatSessionRequestHandler(handle: number, sessionResource: UriComponents, request: IChatAgentRequest, history: any[], token: CancellationToken): Promise<IChatAgentResult>;
     private getModelForRequest;
+    private convertRequestTurn;
+    private convertReferenceToVariable;
+    private convertResponseTurn;
 }

package/vscode/src/vs/workbench/api/common/extHostChatSessions.js

@@ -2,16 +2,19 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
 import { coalesce } from '../../../base/common/arrays.js';
 import { CancellationTokenSource } from '../../../base/common/cancellation.js';
+import { CancellationError } from '../../../base/common/errors.js';
 import { Disposable, DisposableStore } from '../../../base/common/lifecycle.js';
+import { ResourceMap } from '../../../base/common/map.js';
 import { revive } from '../../../base/common/marshalling.js';
 import { MarshalledId } from '../../../base/common/marshallingIds.js';
+import { URI } from '../../../base/common/uri.js';
 import { ILogService } from '../../../platform/log/common/log.service.js';
 import { ChatSessionStatus } from '../../contrib/chat/common/chatSessionsService.js';
 import { ChatAgentLocation } from '../../contrib/chat/common/constants.js';
 import { MainContext } from './extHost.protocol.js';
 import { ChatAgentResponseStream } from './extHostChatAgents2.js';
 import { IExtHostRpcService } from './extHostRpcService.js';
-import { ViewColumn, MarkdownString, ChatAgentRequest, ChatResponsePart } from './extHostTypeConverters.js';
+import { MarkdownString, ChatAgentRequest, Location, ChatResponsePart } from './extHostTypeConverters.js';
 import { Disposable as Disposable$1, ChatRequestTurn } from './extHostTypes.js';
 
 var ExtHostChatSessions_1;
@@ -50,14 +53,14 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
         this._chatSessionContentProviders = ( new Map());
         this._nextChatSessionItemProviderHandle = 0;
         this._nextChatSessionContentProviderHandle = 0;
-        this._sessionMap = ( new Map());
-        this._extHostChatSessions = ( new Map());
+        this._sessionItems = ( new ResourceMap());
+        this._extHostChatSessions = ( new ResourceMap());
         this._proxy = ( this._extHostRpc.getProxy(MainContext.MainThreadChatSessions));
         commands.registerArgumentProcessor({
             processArgument: (arg) => {
                 if (arg && arg.$mid === MarshalledId.ChatSessionContext) {
-                    const id = arg.session.id;
-                    const sessionContent = this._sessionMap.get(id);
+                    const id = arg.session.resource || arg.sessionId;
+                    const sessionContent = this._sessionItems.get(id);
                     if (sessionContent) {
                         return sessionContent;
                     }
@@ -73,7 +76,7 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
     registerChatSessionItemProvider(extension, chatSessionType, provider) {
         const handle = this._nextChatSessionItemProviderHandle++;
         const disposables = ( new DisposableStore());
-        this._chatSessionItemProviders.set(handle, { provider, extension, disposable: disposables });
+        this._chatSessionItemProviders.set(handle, { provider, extension, disposable: disposables, sessionType: chatSessionType });
         this._proxy.$registerChatSessionItemProvider(handle, chatSessionType);
         if (provider.onDidChangeChatSessionItems) {
             disposables.add(provider.onDidChangeChatSessionItems(() => {
@@ -83,7 +86,7 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
         if (provider.onDidCommitChatSessionItem) {
             disposables.add(provider.onDidCommitChatSessionItem((e) => {
                 const { original, modified } = e;
-                this._proxy.$onDidCommitChatSessionItem(handle, original.id, modified.id);
+                this._proxy.$onDidCommitChatSessionItem(handle, original.resource, modified.resource);
             }));
         }
         return {
@@ -94,20 +97,17 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
             }
         };
     }
-    registerChatSessionContentProvider(extension, chatSessionType, chatParticipant, provider, capabilities) {
+    registerChatSessionContentProvider(extension, chatSessionScheme, chatParticipant, provider, capabilities) {
         const handle = this._nextChatSessionContentProviderHandle++;
         const disposables = ( new DisposableStore());
         this._chatSessionContentProviders.set(handle, { provider, extension, capabilities, disposable: disposables });
-        this._proxy.$registerChatSessionContentProvider(handle, chatSessionType);
+        this._proxy.$registerChatSessionContentProvider(handle, chatSessionScheme);
         return new Disposable$1(() => {
             this._chatSessionContentProviders.delete(handle);
             disposables.dispose();
             this._proxy.$unregisterChatSessionContentProvider(handle);
         });
     }
-    async showChatSession(_extension, chatSessionType, sessionId, options) {
-        await this._proxy.$showChatSession(chatSessionType, sessionId, ViewColumn.from(options?.viewColumn));
-    }
     convertChatSessionStatus(status) {
         if (status === undefined) {
             return undefined;
@@ -123,9 +123,10 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
                 return undefined;
         }
     }
-    convertChatSessionItem(sessionContent) {
+    convertChatSessionItem(sessionType, sessionContent) {
         return {
-            id: sessionContent.id,
+            id: ( sessionContent.resource.toString()),
+            resource: sessionContent.resource,
             label: sessionContent.label,
             description: sessionContent.description ? MarkdownString.from(sessionContent.description) : undefined,
             status: this.convertChatSessionStatus(sessionContent.status),
@@ -155,11 +156,11 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
                 metadata: options.metadata
             };
             const chatSessionItem = await entry.provider.provideNewChatSessionItem(vscodeOptions, token);
-            if (!chatSessionItem || !chatSessionItem.id) {
+            if (!chatSessionItem) {
                 throw ( new Error('Provider did not create session'));
             }
-            this._sessionMap.set(chatSessionItem.id, chatSessionItem);
-            return this.convertChatSessionItem(chatSessionItem);
+            this._sessionItems.set(chatSessionItem.resource, chatSessionItem);
+            return this.convertChatSessionItem(entry.sessionType, chatSessionItem);
         }
         catch (error) {
             this._logService.error(`Error creating chat session: ${error}`);
@@ -178,21 +179,24 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
         }
         const response = [];
         for (const sessionContent of sessions) {
-            if (sessionContent.id) {
-                this._sessionMap.set(sessionContent.id, sessionContent);
-                response.push(this.convertChatSessionItem(sessionContent));
-            }
+            this._sessionItems.set(sessionContent.resource, sessionContent);
+            response.push(this.convertChatSessionItem(entry.sessionType, sessionContent));
         }
         return response;
     }
-    async $provideChatSessionContent(handle, id, token) {
+    async $provideChatSessionContent(handle, sessionResourceComponents, token) {
         const provider = this._chatSessionContentProviders.get(handle);
         if (!provider) {
             throw ( new Error(`No provider for handle ${handle}`));
         }
-        const session = await provider.provider.provideChatSessionContent(id, token);
+        const sessionResource = URI.revive(sessionResourceComponents);
+        const session = await provider.provider.provideChatSessionContent(sessionResource, token);
+        if (token.isCancellationRequested) {
+            throw ( new CancellationError());
+        }
         const sessionDisposables = ( new DisposableStore());
         const sessionId = ExtHostChatSessions_1._sessionHandlePool++;
+        const id = ( sessionResource.toString());
         const chatSession = ( new ExtHostChatSession(session, provider.extension, {
             sessionId: `${id}.${sessionId}`,
             requestId: 'ongoing',
@@ -202,61 +206,95 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
             location: ChatAgentLocation.Chat,
         }, {
             $handleProgressChunk: (requestId, chunks) => {
-                return this._proxy.$handleProgressChunk(handle, id, requestId, chunks);
+                return this._proxy.$handleProgressChunk(handle, sessionResource, requestId, chunks);
             },
             $handleAnchorResolve: (requestId, requestHandle, anchor) => {
-                this._proxy.$handleAnchorResolve(handle, id, requestId, requestHandle, anchor);
+                this._proxy.$handleAnchorResolve(handle, sessionResource, requestId, requestHandle, anchor);
             },
         }, this.commands.converter, sessionDisposables));
         const disposeCts = sessionDisposables.add(( new CancellationTokenSource()));
-        this._extHostChatSessions.set(`${handle}_${id}`, { sessionObj: chatSession, disposeCts });
+        this._extHostChatSessions.set(sessionResource, { sessionObj: chatSession, disposeCts });
         if (session.activeResponseCallback) {
             Promise.resolve(session.activeResponseCallback(chatSession.activeResponseStream.apiObject, disposeCts.token)).finally(() => {
-                this._proxy.$handleProgressComplete(handle, id, 'ongoing');
+                this._proxy.$handleProgressComplete(handle, sessionResource, 'ongoing');
             });
         }
         const { capabilities } = provider;
         return {
             id: sessionId + '',
+            resource: URI.revive(sessionResource),
             hasActiveResponseCallback: !!session.activeResponseCallback,
             hasRequestHandler: !!session.requestHandler,
             supportsInterruption: !!capabilities?.supportsInterruptions,
+            options: session.options,
             history: ( session.history.map(turn => {
                 if (turn instanceof ChatRequestTurn) {
-                    return { type: 'request', prompt: turn.prompt, participant: turn.participant };
+                    return this.convertRequestTurn(turn);
                 }
                 else {
-                    const responseTurn = turn;
-                    const parts = coalesce(( responseTurn.response.map(
-                        r => ChatResponsePart.from(r, this.commands.converter, sessionDisposables)
-                    )));
-                    return {
-                        type: 'response',
-                        parts,
-                        participant: responseTurn.participant
-                    };
+                    return this.convertResponseTurn(turn, sessionDisposables);
                 }
             }))
         };
     }
-    async $interruptChatSessionActiveResponse(providerHandle, sessionId, requestId) {
-        const key = `${providerHandle}_${sessionId}`;
-        const entry = this._extHostChatSessions.get(key);
+    async $provideHandleOptionsChange(handle, sessionResourceComponents, updates, token) {
+        const sessionResource = URI.revive(sessionResourceComponents);
+        const provider = this._chatSessionContentProviders.get(handle);
+        if (!provider) {
+            this._logService.warn(`No provider for handle ${handle}`);
+            return;
+        }
+        if (!provider.provider.provideHandleOptionsChange) {
+            this._logService.debug(`Provider for handle ${handle} does not implement provideHandleOptionsChange`);
+            return;
+        }
+        try {
+            await provider.provider.provideHandleOptionsChange(sessionResource, updates, token);
+        }
+        catch (error) {
+            this._logService.error(`Error calling provideHandleOptionsChange for handle ${handle}, sessionResource ${sessionResource}:`, error);
+        }
+    }
+    async $provideChatSessionProviderOptions(handle, token) {
+        const entry = this._chatSessionContentProviders.get(handle);
+        if (!entry) {
+            this._logService.warn(`No provider for handle ${handle} when requesting chat session options`);
+            return;
+        }
+        const provider = entry.provider;
+        if (!provider.provideChatSessionProviderOptions) {
+            return;
+        }
+        try {
+            const { optionGroups } = await provider.provideChatSessionProviderOptions(token);
+            if (!optionGroups) {
+                return;
+            }
+            return {
+                optionGroups,
+            };
+        }
+        catch (error) {
+            this._logService.error(`Error calling provideChatSessionProviderOptions for handle ${handle}:`, error);
+            return;
+        }
+    }
+    async $interruptChatSessionActiveResponse(providerHandle, sessionResource, requestId) {
+        const entry = this._extHostChatSessions.get(URI.revive(sessionResource));
         entry?.disposeCts.cancel();
     }
-    async $disposeChatSessionContent(providerHandle, sessionId) {
-        const key = `${providerHandle}_${sessionId}`;
-        const entry = this._extHostChatSessions.get(key);
+    async $disposeChatSessionContent(providerHandle, sessionResource) {
+        const entry = this._extHostChatSessions.get(URI.revive(sessionResource));
         if (!entry) {
-            this._logService.warn(`No chat session found for ID: ${key}`);
+            this._logService.warn(`No chat session found for resource: ${sessionResource}`);
             return;
         }
         entry.disposeCts.cancel();
         entry.sessionObj.sessionDisposables.dispose();
-        this._extHostChatSessions.delete(key);
+        this._extHostChatSessions.delete(URI.revive(sessionResource));
     }
-    async $invokeChatSessionRequestHandler(handle, id, request, history, token) {
-        const entry = this._extHostChatSessions.get(`${handle}_${id}`);
+    async $invokeChatSessionRequestHandler(handle, sessionResource, request, history, token) {
+        const entry = this._extHostChatSessions.get(URI.revive(sessionResource));
         if (!entry || !entry.sessionObj.session.requestHandler) {
             return {};
         }
@@ -278,6 +316,41 @@ let ExtHostChatSessions = class ExtHostChatSessions extends Disposable {
         }
         return model;
     }
+    convertRequestTurn(turn) {
+        const variables = ( turn.references.map(ref => this.convertReferenceToVariable(ref)));
+        return {
+            type: 'request',
+            prompt: turn.prompt,
+            participant: turn.participant,
+            command: turn.command,
+            variableData: variables.length > 0 ? { variables } : undefined
+        };
+    }
+    convertReferenceToVariable(ref) {
+        const value = ref.value && typeof ref.value === 'object' && 'uri' in ref.value && 'range' in ref.value
+            ? Location.from(ref.value)
+            : ref.value;
+        const range = ref.range ? { start: ref.range[0], endExclusive: ref.range[1] } : undefined;
+        const isFile = URI.isUri(value) || (value && typeof value === 'object' && 'uri' in value);
+        return {
+            id: ref.id,
+            name: ref.id,
+            value,
+            modelDescription: ref.modelDescription,
+            range,
+            kind: isFile ? 'file' : 'generic'
+        };
+    }
+    convertResponseTurn(turn, sessionDisposables) {
+        const parts = coalesce(( turn.response.map(
+            r => ChatResponsePart.from(r, this.commands.converter, sessionDisposables)
+        )));
+        return {
+            type: 'response',
+            parts,
+            participant: turn.participant
+        };
+    }
 };
 ExtHostChatSessions = ExtHostChatSessions_1 = ( __decorate([
     ( __param(2, IExtHostRpcService)),

package/vscode/src/vs/workbench/api/common/extHostCommands.d.ts

@@ -28,11 +28,11 @@ export declare class ExtHostCommands implements ExtHostCommandsShape {
     registerArgumentProcessor(processor: ArgumentProcessor): void;
     registerApiCommand(apiCommand: ApiCommand): extHostTypes.Disposable;
     registerCommand(global: boolean, id: string, callback: <T>(...args: any[]) => T | Thenable<T>, thisArg?: any, metadata?: ICommandMetadata, extension?: IExtensionDescription): extHostTypes.Disposable;
-    executeCommand<T>(id: string, ...args: any[]): Promise<T>;
+    executeCommand<T>(id: string, ...args: unknown[]): Promise<T>;
     private _doExecuteCommand;
     private _executeContributedCommand;
     private _reportTelemetry;
-    $executeContributedCommand(id: string, ...args: any[]): Promise<unknown>;
+    $executeContributedCommand(id: string, ...args: unknown[]): Promise<unknown>;
     getCommands(filterUnderscoreCommands?: boolean): Promise<string[]>;
     $getContributedCommandMetadata(): Promise<{
         [id: string]: string | ICommandMetadataDto;

package/vscode/src/vs/workbench/api/common/extHostCustomEditors.d.ts

@@ -6,7 +6,7 @@ import { ExtHostDocuments } from "./extHostDocuments.js";
 import { IExtensionStoragePaths } from "./extHostStoragePaths.js";
 import { ExtHostWebviews } from "./extHostWebview.js";
 import { ExtHostWebviewPanels } from "./extHostWebviewPanels.js";
-import { EditorGroupColumn } from "@codingame/monaco-vscode-a17e9d37-b6c1-5556-8402-5db73960fae3-common/vscode/vs/workbench/services/editor/common/editorGroupColumn";
+import { EditorGroupColumn } from "@codingame/monaco-vscode-3b5a5cd1-d4ff-500a-b609-57e0cd4afa0a-common/vscode/vs/workbench/services/editor/common/editorGroupColumn";
 import type * as vscode from "vscode";
 import * as extHostProtocol from "./extHost.protocol.js";
 export declare class ExtHostCustomEditors implements extHostProtocol.ExtHostCustomEditorsShape {

package/vscode/src/vs/workbench/api/common/extHostDebugService.d.ts

@@ -22,15 +22,15 @@ import { IExtHostWorkspace } from "./extHostWorkspace.js";
 export declare const IExtHostDebugService: import("../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IExtHostDebugService>;
 export interface IExtHostDebugService extends ExtHostDebugServiceShape {
     readonly _serviceBrand: undefined;
-    onDidStartDebugSession: Event<vscode.DebugSession>;
-    onDidTerminateDebugSession: Event<vscode.DebugSession>;
-    onDidChangeActiveDebugSession: Event<vscode.DebugSession | undefined>;
+    readonly onDidStartDebugSession: Event<vscode.DebugSession>;
+    readonly onDidTerminateDebugSession: Event<vscode.DebugSession>;
+    readonly onDidChangeActiveDebugSession: Event<vscode.DebugSession | undefined>;
     activeDebugSession: vscode.DebugSession | undefined;
     activeDebugConsole: vscode.DebugConsole;
-    onDidReceiveDebugSessionCustomEvent: Event<vscode.DebugSessionCustomEvent>;
-    onDidChangeBreakpoints: Event<vscode.BreakpointsChangeEvent>;
+    readonly onDidReceiveDebugSessionCustomEvent: Event<vscode.DebugSessionCustomEvent>;
+    readonly onDidChangeBreakpoints: Event<vscode.BreakpointsChangeEvent>;
     breakpoints: vscode.Breakpoint[];
-    onDidChangeActiveStackItem: Event<vscode.DebugThread | vscode.DebugStackFrame | undefined>;
+    readonly onDidChangeActiveStackItem: Event<vscode.DebugThread | vscode.DebugStackFrame | undefined>;
     activeStackItem: vscode.DebugThread | vscode.DebugStackFrame | undefined;
     addBreakpoints(breakpoints0: readonly vscode.Breakpoint[]): Promise<void>;
     removeBreakpoints(breakpoints0: readonly vscode.Breakpoint[]): Promise<void>;