@codingame/monaco-vscode-extensions-service-override 25.1.2 → 26.0.1

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

@@ -11,19 +11,46 @@ let MainThreadChatContext = class MainThreadChatContext extends Disposable {
         this._chatContextService = _chatContextService;
         this._providers = ( new Map());
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostChatContext));
+        this._chatContextService.setExecuteCommandCallback(itemHandle => this._proxy.$executeChatContextItemCommand(itemHandle));
     }
-    $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);
+    $registerChatWorkspaceContextProvider(handle, id) {
+        this._providers.set(handle, {
+            id
+        });
+        this._chatContextService.registerChatWorkspaceContextProvider(id, {
+            provideWorkspaceChatContext: token => {
+                return this._proxy.$provideWorkspaceChatContext(handle, token);
+            }
+        });
+    }
+    $registerChatExplicitContextProvider(handle, id) {
+        this._providers.set(handle, {
+            id
+        });
+        this._chatContextService.registerChatExplicitContextProvider(id, {
+            provideChatContext: token => {
+                return this._proxy.$provideExplicitChatContext(handle, token);
             },
-            resolveChatContext: support.supportsResolve ? (context, token) => {
-                return this._proxy.$resolveChatContext(handle, context, token);
-            } : undefined,
-            provideChatContextForResource: support.supportsResource ? (resource, withValue, token) => {
-                return this._proxy.$provideChatContextForResource(handle, { resource, withValue }, token);
-            } : undefined
+            resolveChatContext: (context, token) => {
+                return this._proxy.$resolveExplicitChatContext(handle, context, token);
+            }
+        });
+    }
+    $registerChatResourceContextProvider(handle, id, selector) {
+        this._providers.set(handle, {
+            id,
+            selector
+        });
+        this._chatContextService.registerChatResourceContextProvider(id, selector, {
+            provideChatContext: (resource, withValue, token) => {
+                return this._proxy.$provideResourceChatContext(handle, {
+                    resource,
+                    withValue
+                }, token);
+            },
+            resolveChatContext: (context, token) => {
+                return this._proxy.$resolveResourceChatContext(handle, context, token);
+            }
         });
     }
     $unregisterChatContextProvider(handle) {
@@ -41,10 +68,10 @@ let MainThreadChatContext = class MainThreadChatContext extends Disposable {
         }
         this._chatContextService.updateWorkspaceContextItems(provider.id, items);
     }
+    $executeChatContextItemCommand(itemHandle) {
+        return this._proxy.$executeChatContextItemCommand(itemHandle);
+    }
 };
-MainThreadChatContext = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadChatContext),
-    ( __param(1, IChatContextService))
-], MainThreadChatContext);
+MainThreadChatContext = __decorate([extHostNamedCustomer(MainContext.MainThreadChatContext), ( __param(1, IChatContextService))], MainThreadChatContext);
 
 export { MainThreadChatContext };

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

@@ -25,20 +25,21 @@ let MainThreadChatOutputRenderer = class MainThreadChatOutputRenderer extends Di
             renderOutputPart: async (mime, data, webview, token) => {
                 const webviewHandle = `chat-output-${++this._webviewHandlePool}`;
                 this._mainThreadWebview.addWebview(webviewHandle, webview, {
-                    serializeBuffersForPostMessage: true,
+                    serializeBuffersForPostMessage: true
                 });
-                this._proxy.$renderChatOutput(viewType, mime, VSBuffer.wrap(data), webviewHandle, token);
-            },
+                return this._proxy.$renderChatOutput(viewType, mime, VSBuffer.wrap(data), webviewHandle, token);
+            }
         }, {
-            extension: { id: extensionId, location: URI.revive(extensionLocation) }
+            extension: {
+                id: extensionId,
+                location: URI.revive(extensionLocation)
+            }
         });
     }
     $unregisterChatOutputRenderer(viewType) {
         this.registeredRenderers.get(viewType)?.dispose();
     }
 };
-MainThreadChatOutputRenderer = ( __decorate([
-    ( __param(2, IChatOutputRendererService))
-], MainThreadChatOutputRenderer));
+MainThreadChatOutputRenderer = ( __decorate([( __param(2, IChatOutputRendererService))], MainThreadChatOutputRenderer));
 
 export { MainThreadChatOutputRenderer };

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

@@ -5,12 +5,13 @@ import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/
 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 { IAgentSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsService.service";
 import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
-import { IChatAgentRequest } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatAgents";
 import { IChatContentInlineReference, IChatProgress } 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 { IChatSession, IChatSessionHistoryItem, IChatSessionProviderOptionItem } 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 { IChatAgentRequest } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatAgents";
 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";
@@ -57,6 +58,7 @@ export declare class ObservableChatSession extends Disposable implements IChatSe
 }
 export declare class MainThreadChatSessions extends Disposable implements MainThreadChatSessionsShape {
     private readonly _extHostContext;
+    private readonly _agentSessionsService;
     private readonly _chatSessionsService;
     private readonly _chatService;
     private readonly _chatWidgetService;
@@ -70,7 +72,7 @@ export declare class MainThreadChatSessions extends Disposable implements MainTh
     private readonly _activeSessions;
     private readonly _sessionDisposables;
     private readonly _proxy;
-    constructor(_extHostContext: IExtHostContext, _chatSessionsService: IChatSessionsService, _chatService: IChatService, _chatWidgetService: IChatWidgetService, _dialogService: IDialogService, _editorService: IEditorService, editorGroupService: IEditorGroupsService, _logService: ILogService);
+    constructor(_extHostContext: IExtHostContext, _agentSessionsService: IAgentSessionsService, _chatSessionsService: IChatSessionsService, _chatService: IChatService, _chatWidgetService: IChatWidgetService, _dialogService: IDialogService, _editorService: IEditorService, editorGroupService: IEditorGroupsService, _logService: ILogService);
     private _getHandleForSessionType;
     $registerChatSessionItemProvider(handle: number, chatSessionType: string): void;
     $onDidChangeChatSessionItems(handle: number): void;

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

@@ -14,6 +14,7 @@ import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 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 { hasValidDiff } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsModel';
+import { IAgentSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsService.service';
 import { isIChatViewViewContext, ChatViewPaneTarget } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat';
 import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
 import { ChatEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widgetHosts/editor/chatEditorInput';
@@ -66,11 +67,14 @@ class ObservableChatSession extends Disposable {
     }
     async _doInitializeContent(token) {
         try {
-            const sessionContent = await raceCancellationError(this._proxy.$provideChatSessionContent(this._providerHandle, this.sessionResource, token), token);
+            const sessionContent = await raceCancellationError(
+                this._proxy.$provideChatSessionContent(this._providerHandle, this.sessionResource, token),
+                token
+            );
             this._options = sessionContent.options;
             this.history.length = 0;
-            this.history.push(...( sessionContent.history.map((turn) => {
-                if (turn.type === 'request') {
+            this.history.push(...( sessionContent.history.map(turn => {
+                if (turn.type === "request") {
                     const variables = turn.variableData?.variables.map(v => {
                         const entry = {
                             ...v,
@@ -79,17 +83,19 @@ class ObservableChatSession extends Disposable {
                         return entry;
                     });
                     return {
-                        type: 'request',
+                        type: "request",
                         prompt: turn.prompt,
                         participant: turn.participant,
                         command: turn.command,
-                        variableData: variables ? { variables } : undefined,
+                        variableData: variables ? {
+                            variables
+                        } : undefined,
                         id: turn.id
                     };
                 }
                 return {
-                    type: 'response',
-                    parts: ( turn.parts.map((part) => revive(part))),
+                    type: "response",
+                    parts: ( turn.parts.map(part => revive(part))),
                     participant: turn.participant
                 };
             })));
@@ -100,26 +106,30 @@ class ObservableChatSession extends Disposable {
                             this._proxy.$disposeChatSessionContent(this._providerHandle, this.sessionResource);
                             this._disposalPending = false;
                         }
-                        this._proxy.$interruptChatSessionActiveResponse(this._providerHandle, this.sessionResource, 'ongoing');
+                        this._proxy.$interruptChatSessionActiveResponse(this._providerHandle, this.sessionResource, "ongoing");
                         return true;
                     };
                     if (sessionContent.supportsInterruption) {
                         return confirmInterrupt();
                     }
                     return this._dialogService.confirm({
-                        message: ( localize(2498, 'Are you sure you want to interrupt the active session?'))
+                        message: ( localize(2501, "Are you sure you want to interrupt the active session?"))
                     }).then(confirmed => {
                         if (confirmed.confirmed) {
                             return confirmInterrupt();
-                        }
-                        else {
+                        } else {
                             this._addProgress([{
-                                    kind: 'progressMessage',
-                                    content: { value: '', isTrusted: false }
-                                }]);
+                                kind: "progressMessage",
+                                content: {
+                                    value: "",
+                                    isTrusted: false
+                                }
+                            }]);
                             this._interruptionWasCanceled = true;
                             if (this._disposalPending) {
-                                this._logService.info(`Canceling deferred disposal for session ${this.sessionResource} (user canceled interruption)`);
+                                this._logService.info(
+                                    `Canceling deferred disposal for session ${this.sessionResource} (user canceled interruption)`
+                                );
                                 this._disposalPending = false;
                             }
                             return false;
@@ -149,17 +159,18 @@ class ObservableChatSession extends Disposable {
                         if (!this._isCompleteObservable.get() && !this.interruptActiveResponseCallback) {
                             this._markComplete();
                         }
-                    }
-                    catch (error) {
+                    } catch (error) {
                         const errorProgress = {
-                            kind: 'progressMessage',
-                            content: { value: `Error: ${error instanceof Error ? error.message : String(error)}`, isTrusted: false }
+                            kind: "progressMessage",
+                            content: {
+                                value: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                                isTrusted: false
+                            }
                         };
                         this._addProgress([errorProgress]);
                         this._markComplete();
                         throw error;
-                    }
-                    finally {
+                    } finally {
                         progressDisposable.dispose();
                     }
                 };
@@ -169,15 +180,16 @@ class ObservableChatSession extends Disposable {
             const hasRequestHandler = sessionContent.hasRequestHandler;
             const hasAnyCapability = hasActiveResponse || hasRequestHandler;
             for (const [requestId, chunks] of this._pendingProgressChunks) {
-                this._logService.debug(`Processing ${chunks.length} pending progress chunks for session ${this.sessionResource}, requestId ${requestId}`);
+                this._logService.debug(
+                    `Processing ${chunks.length} pending progress chunks for session ${this.sessionResource}, requestId ${requestId}`
+                );
                 this._addProgress(chunks);
             }
             this._pendingProgressChunks.clear();
             if (!hasAnyCapability) {
                 this._isCompleteObservable.set(true, undefined);
             }
-        }
-        catch (error) {
+        } catch (error) {
             this._logService.error(`Failed to initialize chat session ${this.sessionResource}:`, error);
             throw error;
         }
@@ -186,7 +198,9 @@ class ObservableChatSession extends Disposable {
         if (!this._isInitialized) {
             const existing = this._pendingProgressChunks.get(requestId) || [];
             this._pendingProgressChunks.set(requestId, [...existing, ...progress]);
-            this._logService.debug(`Queuing ${progress.length} progress chunks for session ${this.sessionResource}, requestId ${requestId} (session not initialized)`);
+            this._logService.debug(
+                `Queuing ${progress.length} progress chunks for session ${this.sessionResource}, requestId ${requestId} (session not initialized)`
+            );
             return;
         }
         this._addProgress(progress);
@@ -196,8 +210,7 @@ class ObservableChatSession extends Disposable {
         if (this._isInitialized) {
             if (!this._interruptionWasCanceled) {
                 this._markComplete();
-            }
-            else {
+            } else {
                 this._interruptionWasCanceled = false;
             }
         }
@@ -217,17 +230,27 @@ class ObservableChatSession extends Disposable {
         this._pendingProgressChunks.clear();
         if (this.interruptActiveResponseCallback && !this._interruptionWasCanceled) {
             this._disposalPending = true;
-        }
-        else {
+        } else {
             this._proxy.$disposeChatSessionContent(this._providerHandle, this.sessionResource);
         }
         super.dispose();
     }
 }
 let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
-    constructor(_extHostContext, _chatSessionsService, _chatService, _chatWidgetService, _dialogService, _editorService, editorGroupService, _logService) {
+    constructor(
+        _extHostContext,
+        _agentSessionsService,
+        _chatSessionsService,
+        _chatService,
+        _chatWidgetService,
+        _dialogService,
+        _editorService,
+        editorGroupService,
+        _logService
+    ) {
         super();
         this._extHostContext = _extHostContext;
+        this._agentSessionsService = _agentSessionsService;
         this._chatSessionsService = _chatSessionsService;
         this._chatService = _chatService;
         this._chatWidgetService = _chatWidgetService;
@@ -241,12 +264,36 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
         this._activeSessions = ( new ResourceMap());
         this._sessionDisposables = ( new ResourceMap());
         this._proxy = ( this._extHostContext.getProxy(ExtHostContext.ExtHostChatSessions));
-        this._chatSessionsService.setOptionsChangeCallback(async (sessionResource, updates) => {
+        this._register(this._chatSessionsService.onRequestNotifyExtension((
+            {
+                sessionResource,
+                updates,
+                waitUntil
+            }
+        ) => {
             const handle = this._getHandleForSessionType(sessionResource.scheme);
+            this._logService.trace(
+                `[MainThreadChatSessions] onRequestNotifyExtension received: scheme '${sessionResource.scheme}', handle ${handle}, ${updates.length} update(s)`
+            );
             if (handle !== undefined) {
-                await this.notifyOptionsChange(handle, sessionResource, updates);
+                waitUntil(this.notifyOptionsChange(handle, sessionResource, updates));
+            } else {
+                this._logService.warn(
+                    `[MainThreadChatSessions] Cannot notify option change for scheme '${sessionResource.scheme}': no provider registered. Registered schemes: [${Array.from(( this._sessionTypeToHandle.keys())).join(", ")}]`
+                );
             }
-        });
+        }));
+        this._register(
+            this._agentSessionsService.model.onDidChangeSessionArchivedState(session => {
+                for (const [handle, {
+                    provider
+                }] of this._itemProvidersRegistrations) {
+                    if (provider.chatSessionType === session.providerType) {
+                        this._proxy.$onDidChangeChatSessionItemState(handle, session.resource, session.isArchived());
+                    }
+                }
+            })
+        );
     }
     _getHandleForSessionType(chatSessionType) {
         return this._sessionTypeToHandle.get(chatSessionType);
@@ -257,15 +304,17 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
         const provider = {
             chatSessionType,
             onDidChangeChatSessionItems: Event.debounce(changeEmitter.event, (_, e) => e, 200),
-            provideChatSessionItems: (token) => this._provideChatSessionItems(handle, token),
+            provideChatSessionItems: token => this._provideChatSessionItems(handle, token)
         };
         disposables.add(this._chatSessionsService.registerChatSessionItemProvider(provider));
         this._itemProvidersRegistrations.set(handle, {
             dispose: () => disposables.dispose(),
             provider,
-            onDidChangeItems: changeEmitter,
+            onDidChangeItems: changeEmitter
         });
-        disposables.add(this._chatSessionsService.registerChatModelChangeListeners(this._chatService, chatSessionType, () => changeEmitter.fire()));
+        disposables.add(
+            this._chatSessionsService.registerChatModelChangeListeners(this._chatService, chatSessionType, () => changeEmitter.fire())
+        );
     }
     $onDidChangeChatSessionItems(handle) {
         this._itemProvidersRegistrations.get(handle)?.onDidChangeItems.fire();
@@ -277,56 +326,63 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
     async $onDidCommitChatSessionItem(handle, originalComponents, modifiedCompoennts) {
         const originalResource = URI.revive(originalComponents);
         const modifiedResource = URI.revive(modifiedCompoennts);
-        this._logService.trace(`$onDidCommitChatSessionItem: handle(${handle}), original(${originalResource}), modified(${modifiedResource})`);
+        this._logService.trace(
+            `$onDidCommitChatSessionItem: handle(${handle}), original(${originalResource}), modified(${modifiedResource})`
+        );
         const chatSessionType = this._itemProvidersRegistrations.get(handle)?.provider.chatSessionType;
         if (!chatSessionType) {
             this._logService.error(`No chat session type found for provider handle ${handle}`);
             return;
         }
         const originalEditor = this._editorService.editors.find(editor => editor.resource?.toString() === ( originalResource.toString()));
-        const originalModel = this._chatService.getSession(originalResource);
+        const originalModel = this._chatService.getActiveSessionReference(originalResource);
         const contribution = this._chatSessionsService.getAllChatSessionContributions().find(c => c.type === chatSessionType);
-        const originalGroup = this.editorGroupService.groups.find(group => ( group.editors.some(editor => isEqual(editor.resource, originalResource))))
-            ?? this.editorGroupService.activeGroup;
-        const options = {
-            title: {
-                preferred: originalEditor?.getName() || undefined,
-                fallback: ( localize(2499, "{0}", contribution?.displayName)),
-            }
-        };
-        const newSession = await this._chatSessionsService.getOrCreateChatSession(URI.revive(modifiedResource), CancellationToken.None);
-        if (originalEditor) {
-            newSession.transferredState = originalEditor instanceof ChatEditorInput
-                ? { editingSession: originalEditor.transferOutEditingSession(), inputState: originalModel?.inputModel.toJSON() }
-                : undefined;
-            this._editorService.replaceEditors([{
+        try {
+            const originalGroup = this.editorGroupService.groups.find(group => ( group.editors.some(editor => isEqual(editor.resource, originalResource)))) ?? this.editorGroupService.activeGroup;
+            const options = {
+                title: {
+                    preferred: originalEditor?.getName() || undefined,
+                    fallback: ( localize(2502, "{0}", contribution?.displayName))
+                }
+            };
+            const newSession = await this._chatSessionsService.getOrCreateChatSession(URI.revive(modifiedResource), CancellationToken.None);
+            if (originalEditor) {
+                newSession.transferredState = originalEditor instanceof ChatEditorInput ? {
+                    editingSession: originalEditor.transferOutEditingSession(),
+                    inputState: originalModel?.object.inputModel.toJSON()
+                } : undefined;
+                await this._editorService.replaceEditors([{
                     editor: originalEditor,
                     replacement: {
                         resource: modifiedResource,
-                        options,
-                    },
+                        options
+                    }
                 }], originalGroup);
-            return;
-        }
-        if (originalModel) {
-            newSession.transferredState = {
-                editingSession: originalModel.editingSession,
-                inputState: originalModel.inputModel.toJSON()
-            };
-        }
-        const chatViewWidget = this._chatWidgetService.getWidgetBySessionResource(originalResource);
-        if (chatViewWidget && isIChatViewViewContext(chatViewWidget.viewContext)) {
-            await this._chatWidgetService.openSession(modifiedResource, ChatViewPaneTarget, { preserveFocus: true });
-        }
-        else {
-            const ref = await this._chatService.loadSessionForResource(modifiedResource, ChatAgentLocation.Chat, CancellationToken.None);
-            ref?.dispose();
+                return;
+            }
+            if (originalModel) {
+                newSession.transferredState = {
+                    editingSession: originalModel.object.editingSession,
+                    inputState: originalModel.object.inputModel.toJSON()
+                };
+            }
+            const chatViewWidget = this._chatWidgetService.getWidgetBySessionResource(originalResource);
+            if (chatViewWidget && isIChatViewViewContext(chatViewWidget.viewContext)) {
+                await this._chatWidgetService.openSession(modifiedResource, ChatViewPaneTarget, {
+                    preserveFocus: true
+                });
+            } else {
+                const ref = await this._chatService.loadSessionForResource(modifiedResource, ChatAgentLocation.Chat, CancellationToken.None);
+                ref?.dispose();
+            }
+        } finally {
+            originalModel?.dispose();
         }
     }
     async _provideChatSessionItems(handle, token) {
         try {
             const sessions = await this._proxy.$provideChatSessionItems(handle, token);
-            return Promise.all(( sessions.map(async (session) => {
+            return Promise.all(( sessions.map(async session => {
                 const uri = URI.revive(session.resource);
                 const model = this._chatService.getSession(uri);
                 if (model) {
@@ -349,11 +405,11 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
                     resource: uri,
                     iconPath: session.iconPath,
                     tooltip: session.tooltip ? this._reviveTooltip(session.tooltip) : undefined,
+                    archived: session.archived
                 };
             })));
-        }
-        catch (error) {
-            this._logService.error('Error providing chat sessions:', error);
+        } catch (error) {
+            this._logService.error("Error providing chat sessions:", error);
         }
         return [];
     }
@@ -408,10 +464,12 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
                 }
             }
             return session;
-        }
-        catch (error) {
+        } catch (error) {
             session.dispose();
-            this._logService.error(`Error providing chat session content for handle ${providerHandle} and resource ${( sessionResource.toString())}:`, error);
+            this._logService.error(
+                `Error providing chat session content for handle ${providerHandle} and resource ${( sessionResource.toString())}:`,
+                error
+            );
             throw error;
         }
     }
@@ -423,7 +481,10 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
             provideChatSessionContent: (resource, token) => this._provideChatSessionContent(handle, resource, token)
         };
         this._sessionTypeToHandle.set(chatSessionScheme, handle);
-        this._contentProvidersRegistrations.set(handle, this._chatSessionsService.registerChatSessionContentProvider(chatSessionScheme, provider));
+        this._contentProvidersRegistrations.set(
+            handle,
+            this._chatSessionsService.registerChatSessionContentProvider(chatSessionScheme, provider)
+        );
         this._refreshProviderOptions(handle, chatSessionScheme);
     }
     $unregisterChatSessionContentProvider(handle) {
@@ -445,7 +506,9 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
         const resource = URI.revive(sessionResource);
         const observableSession = this._activeSessions.get(resource);
         if (!observableSession) {
-            this._logService.warn(`No session found for progress chunks: handle ${handle}, sessionResource ${resource}, requestId ${requestId}`);
+            this._logService.warn(
+                `No session found for progress chunks: handle ${handle}, sessionResource ${resource}, requestId ${requestId}`
+            );
             return;
         }
         const chatProgressParts = ( chunks.map(chunk => {
@@ -458,13 +521,14 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
         const resource = URI.revive(sessionResource);
         const observableSession = this._activeSessions.get(resource);
         if (!observableSession) {
-            this._logService.warn(`No session found for progress completion: handle ${handle}, sessionResource ${resource}, requestId ${requestId}`);
+            this._logService.warn(
+                `No session found for progress completion: handle ${handle}, sessionResource ${resource}, requestId ${requestId}`
+            );
             return;
         }
         observableSession.handleProgressComplete(requestId);
     }
-    $handleAnchorResolve(handle, sesssionResource, requestId, requestHandle, anchor) {
-    }
+    $handleAnchorResolve(handle, sesssionResource, requestId, requestHandle, anchor) {}
     $onDidChangeChatSessionProviderOptions(handle) {
         let sessionType;
         for (const [type, h] of this._sessionTypeToHandle) {
@@ -474,7 +538,9 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
             }
         }
         if (!sessionType) {
-            this._logService.warn(`No session type found for chat session content provider handle ${handle} when refreshing provider options`);
+            this._logService.warn(
+                `No session type found for chat session content provider handle ${handle} when refreshing provider options`
+            );
             return;
         }
         this._refreshProviderOptions(handle, sessionType);
@@ -482,9 +548,15 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
     _refreshProviderOptions(handle, chatSessionScheme) {
         this._proxy.$provideChatSessionProviderOptions(handle, CancellationToken.None).then(options => {
             if (options?.optionGroups && options.optionGroups.length) {
-                this._chatSessionsService.setOptionGroupsForSessionType(chatSessionScheme, handle, options.optionGroups);
+                const groupsWithCallbacks = ( options.optionGroups.map(group => ({
+                    ...group,
+                    onSearch: group.searchable ? async (query, token) => {
+                        return await this._proxy.$invokeOptionGroupSearch(handle, group.id, query, token);
+                    } : undefined
+                })));
+                this._chatSessionsService.setOptionGroupsForSessionType(chatSessionScheme, handle, groupsWithCallbacks);
             }
-        }).catch(err => this._logService.error('Error fetching chat session options', err));
+        }).catch(err => this._logService.error("Error fetching chat session options", err));
     }
     dispose() {
         for (const session of ( this._activeSessions.values())) {
@@ -501,32 +573,31 @@ let MainThreadChatSessions = class MainThreadChatSessions extends Disposable {
         if (!tooltip) {
             return undefined;
         }
-        if (typeof tooltip === 'string') {
+        if (typeof tooltip === "string") {
             return tooltip;
         }
-        if (typeof tooltip === 'object' && 'value' in tooltip) {
+        if (typeof tooltip === "object" && "value" in tooltip) {
             return MarkdownString.lift(tooltip);
         }
         return undefined;
     }
     async notifyOptionsChange(handle, sessionResource, updates) {
+        this._logService.trace(
+            `[MainThreadChatSessions] notifyOptionsChange: starting proxy call for handle ${handle}, sessionResource ${sessionResource}`
+        );
         try {
             await this._proxy.$provideHandleOptionsChange(handle, sessionResource, updates, CancellationToken.None);
-        }
-        catch (error) {
-            this._logService.error(`Error notifying extension about options change for handle ${handle}, sessionResource ${sessionResource}:`, error);
+            this._logService.trace(
+                `[MainThreadChatSessions] notifyOptionsChange: proxy call completed for handle ${handle}, sessionResource ${sessionResource}`
+            );
+        } catch (error) {
+            this._logService.error(
+                `[MainThreadChatSessions] notifyOptionsChange: error for handle ${handle}, sessionResource ${sessionResource}:`,
+                error
+            );
         }
     }
 };
-MainThreadChatSessions = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadChatSessions),
-    ( __param(1, IChatSessionsService)),
-    ( __param(2, IChatService)),
-    ( __param(3, IChatWidgetService)),
-    ( __param(4, IDialogService)),
-    ( __param(5, IEditorService)),
-    ( __param(6, IEditorGroupsService)),
-    ( __param(7, ILogService))
-], MainThreadChatSessions);
+MainThreadChatSessions = __decorate([extHostNamedCustomer(MainContext.MainThreadChatSessions), ( __param(1, IAgentSessionsService)), ( __param(2, IChatSessionsService)), ( __param(3, IChatService)), ( __param(4, IChatWidgetService)), ( __param(5, IDialogService)), ( __param(6, IEditorService)), ( __param(7, IEditorGroupsService)), ( __param(8, ILogService))], MainThreadChatSessions);
 
 export { MainThreadChatSessions, ObservableChatSession };

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

@@ -15,16 +15,13 @@ let MainThreadChatStatus = class MainThreadChatStatus extends Disposable {
             id,
             label: entry.title,
             description: entry.description,
-            detail: entry.detail,
+            detail: entry.detail
         });
     }
     $disposeEntry(id) {
         this._chatStatusItemService.deleteEntry(id);
     }
 };
-MainThreadChatStatus = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadChatStatus),
-    ( __param(1, IChatStatusItemService))
-], MainThreadChatStatus);
+MainThreadChatStatus = __decorate([extHostNamedCustomer(MainContext.MainThreadChatStatus), ( __param(1, IChatStatusItemService))], MainThreadChatStatus);
 
 export { MainThreadChatStatus };