@codingame/monaco-vscode-chat-service-override 37.1.0 → 37.3.0

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

@@ -0,0 +1,827 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { DeferredPromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, DisposableMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { revive } from '@codingame/monaco-vscode-api/vscode/vs/base/common/marshalling';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { escapeRegExpCharacters } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { getWordAtText } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/wordHelper';
+import { CompletionItemKind } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages';
+import { ILanguageFeaturesService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/languageFeatures.service';
+import { ExtensionIdentifier } from '@codingame/monaco-vscode-api/vscode/vs/platform/extensions/common/extensions';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { IUriIdentityService } from '@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
+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/participants/chatAgents.service';
+import { PromptsStorage } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService';
+import { IPromptsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service';
+import { PromptsType, isValidPromptType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import { ChatRequestAgentPart } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/requestParser/chatParserTypes';
+import { ChatRequestParser } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/requestParser/chatRequestParser';
+import { getDynamicVariablesForWidget, getSelectedToolAndToolSetsForWidget } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/attachments/chatVariables';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+import { ChatSessionOptionsMap } 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 { ChatModeKind, ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service';
+import { extHostNamedCustomer } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extHostCustomers';
+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 '@codingame/monaco-vscode-api/vscode/vs/workbench/api/browser/mainThreadNotebookDto';
+import { isUntitledChatSession, getChatSessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
+import { ICustomizationHarnessService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/customizationHarnessService.service';
+import { AICustomizationManagementSection } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/aiCustomizationWorkspaceService';
+import { IAgentPluginService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/plugins/agentPluginService.service';
+import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
+import { getAgentSessionProvider, AgentSessionProviders } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessions';
+import { addDynamicVariableActionId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/editor/chatDynamicVariablesConstant';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+class MainThreadChatTask {
+    get onDidAddProgress() {
+        return this._onDidAddProgress.event;
+    }
+    constructor(content) {
+        this.content = content;
+        this.kind = "progressTask";
+        this.deferred = ( new DeferredPromise());
+        this._onDidAddProgress = ( new Emitter());
+        this.progress = [];
+    }
+    task() {
+        return this.deferred.p;
+    }
+    isSettled() {
+        return this.deferred.isSettled;
+    }
+    complete(v) {
+        this.deferred.complete(v);
+    }
+    add(progress) {
+        this.progress.push(progress);
+        this._onDidAddProgress.fire(progress);
+    }
+    toJSON() {
+        return {
+            kind: "progressTaskSerialized",
+            content: this.content,
+            progress: this.progress
+        };
+    }
+}
+let MainThreadChatAgents2 = class MainThreadChatAgents2 extends Disposable {
+    constructor(
+        extHostContext,
+        _chatAgentService,
+        _chatSessionService,
+        _chatService,
+        _languageFeaturesService,
+        _chatWidgetService,
+        _instantiationService,
+        _logService,
+        _extensionService,
+        _uriIdentityService,
+        _promptsService,
+        _languageModelToolsService,
+        _customizationHarnessService,
+        _telemetryService,
+        _agentPluginService,
+        _environmentService
+    ) {
+        super();
+        this._chatAgentService = _chatAgentService;
+        this._chatSessionService = _chatSessionService;
+        this._chatService = _chatService;
+        this._languageFeaturesService = _languageFeaturesService;
+        this._chatWidgetService = _chatWidgetService;
+        this._instantiationService = _instantiationService;
+        this._logService = _logService;
+        this._extensionService = _extensionService;
+        this._uriIdentityService = _uriIdentityService;
+        this._promptsService = _promptsService;
+        this._languageModelToolsService = _languageModelToolsService;
+        this._customizationHarnessService = _customizationHarnessService;
+        this._telemetryService = _telemetryService;
+        this._agentPluginService = _agentPluginService;
+        this._environmentService = _environmentService;
+        this._agents = this._register(( new DisposableMap()));
+        this._agentCompletionProviders = this._register(( new DisposableMap()));
+        this._agentIdsToCompletionProviders = this._register(( new DisposableMap()));
+        this._chatParticipantDetectionProviders = this._register(( new DisposableMap()));
+        this._promptFileProviders = this._register(( new DisposableMap()));
+        this._promptFileProviderEmitters = this._register(( new DisposableMap()));
+        this._promptFileContentRegistrations = this._register(( new DisposableMap()));
+        this._customizationProviders = this._register(( new DisposableMap()));
+        this._customizationProviderEmitters = this._register(( new DisposableMap()));
+        this._pendingProgress = ( new Map());
+        this._activeTasks = ( new Map());
+        this._unresolvedAnchors = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostChatAgents2));
+        this._register(this._chatService.onDidDisposeSession(e => {
+            for (const resource of e.sessionResources) {
+                this._proxy.$releaseSession(resource);
+            }
+        }));
+        this._register(this._chatService.onDidPerformUserAction(e => {
+            if (typeof e.agentId === "string") {
+                for (const [handle, agent] of this._agents) {
+                    if (agent.id === e.agentId) {
+                        if (e.action.kind === "vote") {
+                            this._proxy.$acceptFeedback(handle, e.result ?? {}, e.action);
+                        } else {
+                            this._proxy.$acceptAction(handle, e.result || {}, e);
+                        }
+                        break;
+                    }
+                }
+            }
+        }));
+        this._register(this._chatService.onDidReceiveQuestionCarouselAnswer(e => {
+            this._proxy.$handleQuestionCarouselAnswer(e.requestId, e.resolveId, e.answers);
+        }));
+        this._register(this._chatWidgetService.onDidChangeFocusedSession(() => {
+            this._acceptActiveChatSession(this._chatWidgetService.lastFocusedWidget);
+        }));
+        this._acceptActiveChatSession(this._chatWidgetService.lastFocusedWidget);
+        this._register(this._promptsService.onDidChangeCustomAgents(() => {
+            this._proxy.$onDidChangeCustomAgents();
+        }));
+        this._register(this._promptsService.onDidChangeInstructions(() => {
+            this._proxy.$onDidChangeInstructions();
+        }));
+        this._register(this._promptsService.onDidChangeSkills(() => {
+            this._proxy.$onDidChangeSkills();
+        }));
+        this._register(this._promptsService.onDidChangeSlashCommands(() => {
+            this._proxy.$onDidChangeSlashCommands();
+        }));
+        this._register(this._promptsService.onDidChangeHooks(() => {
+            this._proxy.$onDidChangeHooks();
+        }));
+        this._register(autorun(reader => {
+            this._agentPluginService.plugins.read(reader);
+            this._proxy.$onDidChangePlugins();
+        }));
+    }
+    _acceptActiveChatSession(widget) {
+        const sessionResource = widget?.viewModel?.sessionResource;
+        const isLocal = sessionResource && getAgentSessionProvider(sessionResource) === AgentSessionProviders.Local;
+        this._proxy.$acceptActiveChatSession(isLocal ? sessionResource : undefined);
+    }
+    _toChatResourceSource(storage) {
+        switch (storage) {
+        case PromptsStorage.local:
+            return "local";
+        case PromptsStorage.user:
+            return "user";
+        case PromptsStorage.extension:
+            return "extension";
+        case PromptsStorage.plugin:
+            return "plugin";
+        case PromptsStorage.builtIn:
+            return "builtin";
+        }
+    }
+    _toCustomAgentDto(agent) {
+        return {
+            uri: agent.uri,
+            name: agent.name,
+            description: agent.description,
+            source: this._toChatResourceSource(agent.source.storage),
+            extensionId: agent.source.storage === PromptsStorage.extension ? agent.source.extensionId.value : undefined,
+            pluginUri: agent.source.storage === PromptsStorage.plugin ? agent.source.pluginUri : undefined,
+            sessionTypes: agent.sessionTypes,
+            argumentHint: agent.argumentHint,
+            tools: agent.tools,
+            model: agent.model,
+            userInvocable: agent.visibility.userInvocable,
+            disableModelInvocation: !agent.visibility.agentInvocable,
+            enabled: agent.enabled
+        };
+    }
+    _toInstructionDto(instruction) {
+        return {
+            uri: instruction.uri,
+            name: instruction.name,
+            description: instruction.description,
+            source: this._toChatResourceSource(instruction.storage),
+            extensionId: instruction.extension?.identifier.value,
+            pluginUri: instruction.pluginUri,
+            sessionTypes: instruction.sessionTypes,
+            pattern: instruction.pattern
+        };
+    }
+    _toSkillDto(skill) {
+        return {
+            uri: skill.uri,
+            name: skill.name,
+            description: skill.description,
+            source: this._toChatResourceSource(skill.storage),
+            extensionId: skill.extension?.identifier.value,
+            pluginUri: skill.pluginUri,
+            sessionTypes: skill.sessionTypes,
+            userInvocable: skill.userInvocable,
+            disableModelInvocation: skill.disableModelInvocation
+        };
+    }
+    _toSlashCommandDto(slashCommand) {
+        return {
+            uri: slashCommand.uri,
+            name: slashCommand.name,
+            description: slashCommand.description,
+            source: this._toChatResourceSource(slashCommand.storage),
+            extensionId: slashCommand.extension?.identifier.value,
+            pluginUri: slashCommand.pluginUri,
+            sessionTypes: slashCommand.sessionTypes,
+            argumentHint: slashCommand.argumentHint,
+            userInvocable: slashCommand.userInvocable
+        };
+    }
+    _toHookDto(hookFile) {
+        return {
+            uri: hookFile.uri,
+            sessionTypes: hookFile.sessionTypes,
+            source: this._toChatResourceSource(hookFile.storage),
+            extensionId: hookFile.extension?.identifier.value,
+            pluginUri: hookFile.pluginUri
+        };
+    }
+    _toPluginDto(plugin) {
+        return {
+            uri: plugin.uri
+        };
+    }
+    async $provideCustomAgents(token) {
+        const customAgents = await this._promptsService.getCustomAgents(token);
+        return customAgents.map(agent => this._toCustomAgentDto(agent));
+    }
+    async $provideInstructions(token) {
+        const instructions = await this._promptsService.getInstructionFiles(token);
+        return instructions.map(instruction => this._toInstructionDto(instruction));
+    }
+    async $provideSkills(token) {
+        const skills = (await this._promptsService.findAgentSkills(token)) ?? [];
+        return skills.map(skill => this._toSkillDto(skill));
+    }
+    async $provideSlashCommands(token) {
+        const slashCommands = await this._promptsService.getPromptSlashCommands(token);
+        return slashCommands.map(slashCommand => this._toSlashCommandDto(slashCommand));
+    }
+    async $provideHooks(token) {
+        const hookFiles = await this._promptsService.listPromptFiles(PromptsType.hook, token);
+        return hookFiles.map(hookFile => this._toHookDto(hookFile));
+    }
+    async $providePlugins(_token) {
+        const plugins = this._agentPluginService.plugins.get();
+        return plugins.map(plugin => this._toPluginDto(plugin));
+    }
+    $unregisterAgent(handle) {
+        this._agents.deleteAndDispose(handle);
+    }
+    async $transferActiveChatSession(toWorkspace) {
+        const widget = this._chatWidgetService.lastFocusedWidget;
+        const model = widget?.viewModel?.model;
+        if (!model) {
+            this._logService.error(`MainThreadChat#$transferActiveChatSession: No active chat session found`);
+            return;
+        }
+        await this._chatService.transferChatSession(model.sessionResource, URI.revive(toWorkspace));
+    }
+    async $registerAgent(handle, extension, id, metadata, dynamicProps) {
+        await this._extensionService.whenInstalledExtensionsRegistered();
+        const staticAgentRegistration = this._chatAgentService.getAgent(id, true);
+        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}"`
+                ));
+            }
+            throw ( new Error(`chatParticipant must be declared in package.json: ${id}`));
+        }
+        const impl = {
+            invoke: async (request, progress, history, token) => {
+                const chatSession = this._chatService.getSession(request.sessionResource);
+                this._pendingProgress.set(request.requestId, {
+                    progress,
+                    chatSession,
+                    isSubagent: !!request.subAgentInvocationId
+                });
+                try {
+                    const chatSessionResource = request.sessionResource;
+                    const chatSessionContext = {
+                        chatSessionResource,
+                        isUntitled: isUntitledChatSession(chatSessionResource),
+                        initialSessionOptions: ChatSessionOptionsMap.toStrValueArray(this._chatSessionService.getSessionOptions(chatSessionResource))
+                    };
+                    const rpcResult = await this._proxy.$invokeAgent(handle, request, {
+                        history,
+                        chatSessionContext
+                    }, token);
+                    if (rpcResult?.errorCallstack && !rpcResult.errorDetails?.isRateLimited && !rpcResult.errorDetails?.isQuotaExceeded && !rpcResult.errorDetails?.isExpectedError) {
+                        this._telemetryService.publicLogError2("chatAgentError", {
+                            callstack: rpcResult.errorCallstack,
+                            msg: rpcResult.errorDetails?.message ?? "",
+                            errorName: rpcResult.errorName ?? "",
+                            agent: id,
+                            agentExtensionId: extension.value
+                        });
+                    }
+                    if (rpcResult) {
+                        const {
+                            errorCallstack: _,
+                            errorName: _2,
+                            ...result
+                        } = rpcResult;
+                        return result;
+                    }
+                    return {};
+                } finally {
+                    this._pendingProgress.delete(request.requestId);
+                }
+            },
+            setRequestTools: (requestId, tools) => {
+                this._proxy.$setRequestTools(requestId, tools);
+            },
+            setYieldRequested: (requestId, value) => {
+                this._proxy.$setYieldRequested(requestId, value);
+            },
+            provideFollowups: async (request, result, history, token) => {
+                if (!this._agents.get(handle)?.hasFollowups) {
+                    return [];
+                }
+                return this._proxy.$provideFollowups(request, handle, result, {
+                    history
+                }, token);
+            },
+            provideChatTitle: (history, token) => {
+                return this._proxy.$provideChatTitle(handle, history, token);
+            },
+            provideChatSummary: (history, token) => {
+                return this._proxy.$provideChatSummary(handle, history, token);
+            }
+        };
+        if (chatSessionRegistration?.alternativeIds?.includes(id)) {
+            return;
+        }
+        let disposable;
+        if (!staticAgentRegistration && dynamicProps) {
+            const extensionDescription = this._extensionService.extensions.find(e => ExtensionIdentifier.equals(e.identifier, extension));
+            disposable = this._chatAgentService.registerDynamicAgent({
+                id,
+                name: dynamicProps.name,
+                description: dynamicProps.description,
+                extensionId: extension,
+                extensionVersion: extensionDescription?.version,
+                extensionDisplayName: extensionDescription?.displayName ?? extension.value,
+                extensionPublisherId: extensionDescription?.publisher ?? "",
+                publisherDisplayName: dynamicProps.publisherName,
+                fullName: dynamicProps.fullName,
+                metadata: revive(metadata),
+                slashCommands: [],
+                disambiguation: [],
+                locations: [ChatAgentLocation.Chat],
+                modes: [ChatModeKind.Ask, ChatModeKind.Agent, ChatModeKind.Edit]
+            }, impl);
+        } else {
+            disposable = this._chatAgentService.registerAgentImplementation(id, impl);
+        }
+        this._agents.set(handle, {
+            id: id,
+            extensionId: extension,
+            dispose: () => disposable.dispose(),
+            hasFollowups: metadata.hasFollowups
+        });
+    }
+    async $updateAgent(handle, metadataUpdate) {
+        await this._extensionService.whenInstalledExtensionsRegistered();
+        const data = this._agents.get(handle);
+        if (!data) {
+            this._logService.error(
+                `MainThreadChatAgents2#$updateAgent: No agent with handle ${handle} registered`
+            );
+            return;
+        }
+        data.hasFollowups = metadataUpdate.hasFollowups;
+        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,
+            isSubagent
+        } = pendingProgress;
+        const chatProgressParts = [];
+        const response = chatSession?.getRequests().find(req => req.id === requestId)?.response;
+        for (const item of chunks) {
+            const [progress, responsePartHandle] = Array.isArray(item) ? item : [item];
+            if (progress.kind === "externalEdits") {
+                if (chatSession?.editingSession && responsePartHandle !== undefined && response) {
+                    const parts = progress.start ? await chatSession.editingSession.startExternalEdits(
+                        response,
+                        responsePartHandle,
+                        revive(progress.resources),
+                        progress.undoStopId
+                    ) : await chatSession.editingSession.stopExternalEdits(response, responsePartHandle);
+                    chatProgressParts.push(...parts);
+                }
+                continue;
+            }
+            if (progress.kind === "beginToolInvocation") {
+                this._languageModelToolsService.beginToolCall({
+                    toolCallId: progress.toolCallId,
+                    toolId: progress.toolName,
+                    chatRequestId: requestId,
+                    sessionResource: chatSession?.sessionResource,
+                    subagentInvocationId: progress.subagentInvocationId
+                });
+                continue;
+            }
+            if (progress.kind === "updateToolInvocation") {
+                this._languageModelToolsService.updateToolStream(
+                    progress.toolCallId,
+                    progress.streamData?.partialInput,
+                    CancellationToken.None
+                );
+                continue;
+            }
+            if (progress.kind === "usage") {
+                if (isSubagent) {
+                    chatProgressParts.push({
+                        kind: "usage",
+                        promptTokens: progress.promptTokens,
+                        completionTokens: progress.completionTokens,
+                        outputBuffer: progress.outputBuffer,
+                        copilotCredits: progress.copilotCredits,
+                        promptTokenDetails: progress.promptTokenDetails
+                    });
+                } else if (response) {
+                    response.setUsage({
+                        kind: "usage",
+                        promptTokens: progress.promptTokens,
+                        completionTokens: progress.completionTokens,
+                        outputBuffer: progress.outputBuffer,
+                        copilotCredits: progress.copilotCredits,
+                        promptTokenDetails: progress.promptTokenDetails
+                    });
+                } else {
+                    this._logService.warn(
+                        `MainThreadChatAgents2#$handleProgressChunk: No response model for usage of non-subagent request ${requestId}; dropping usage.`
+                    );
+                }
+                continue;
+            }
+            const revivedProgress = progress.kind === "notebookEdit" ? ChatNotebookEdit.fromChatEdit(progress) : revive(progress);
+            if (revivedProgress.kind === "notebookEdit" || revivedProgress.kind === "textEdit" || revivedProgress.kind === "codeblockUri") {
+                revivedProgress.uri = this._uriIdentityService.asCanonicalUri(revivedProgress.uri);
+            }
+            if (responsePartHandle !== undefined) {
+                if (revivedProgress.kind === "progressTask") {
+                    const handle = responsePartHandle;
+                    const responsePartId = `${requestId}_${handle}`;
+                    const task = ( new MainThreadChatTask(revivedProgress.content));
+                    this._activeTasks.set(responsePartId, task);
+                    chatProgressParts.push(task);
+                } else if (responsePartHandle !== undefined) {
+                    const responsePartId = `${requestId}_${responsePartHandle}`;
+                    const task = this._activeTasks.get(responsePartId);
+                    switch (revivedProgress.kind) {
+                    case "progressTaskResult":
+                        if (task && revivedProgress.content) {
+                            task.complete(revivedProgress.content.value);
+                            this._activeTasks.delete(responsePartId);
+                        } else {
+                            task?.complete(undefined);
+                        }
+                        break;
+                    case "warning":
+                    case "reference":
+                        task?.add(revivedProgress);
+                        break;
+                    }
+                }
+                continue;
+            }
+            if (revivedProgress.kind === "inlineReference" && revivedProgress.resolveId && response) {
+                if (!( this._unresolvedAnchors.has(requestId))) {
+                    this._unresolvedAnchors.set(requestId, ( new Map()));
+                }
+                this._unresolvedAnchors.get(requestId)?.set(revivedProgress.resolveId, {
+                    response
+                });
+            }
+            chatProgressParts.push(revivedProgress);
+        }
+        progress(chatProgressParts);
+    }
+    $handleAnchorResolve(requestId, handle, resolveAnchor) {
+        const unresolvedAnchorsForRequest = this._unresolvedAnchors.get(requestId);
+        if (!unresolvedAnchorsForRequest) {
+            return;
+        }
+        const unresolvedAnchor = unresolvedAnchorsForRequest.get(handle);
+        if (!unresolvedAnchor) {
+            return;
+        }
+        unresolvedAnchorsForRequest.delete(handle);
+        if (unresolvedAnchorsForRequest.size === 0) {
+            this._unresolvedAnchors.delete(requestId);
+        }
+        if (resolveAnchor) {
+            const revivedAnchor = revive(resolveAnchor);
+            unresolvedAnchor.response.resolveInlineReference(handle, revivedAnchor);
+        }
+    }
+    $registerAgentCompletionsProvider(handle, id, triggerCharacters) {
+        const provide = async (query, token) => {
+            const completions = await this._proxy.$invokeCompletionProvider(handle, query, token);
+            return completions.map(c => ({
+                ...c,
+                icon: c.icon ? ThemeIcon.fromId(c.icon) : undefined
+            }));
+        };
+        this._agentIdsToCompletionProviders.set(id, this._chatAgentService.registerAgentCompletionProvider(id, provide));
+        this._agentCompletionProviders.set(handle, this._languageFeaturesService.completionProvider.register({
+            scheme: Schemas.vscodeChatInput,
+            hasAccessToAllModels: true
+        }, {
+            _debugDisplayName: "chatAgentCompletions:" + handle,
+            triggerCharacters,
+            provideCompletionItems: async (model, position, _context, token) => {
+                const widget = this._chatWidgetService.getWidgetByInputUri(model.uri);
+                if (!widget || !widget.viewModel) {
+                    return;
+                }
+                const triggerCharsPart = triggerCharacters.map(c => escapeRegExpCharacters(c)).join("");
+                const wordRegex = ( new RegExp(`[${triggerCharsPart}]\\S*`, "g"));
+                const query = getWordAtText(position.column, wordRegex, model.getLineContent(position.lineNumber), 0)?.word ?? "";
+                if (query && !( triggerCharacters.some(c => query.startsWith(c)))) {
+                    return;
+                }
+                const context = {
+                    sessionType: getChatSessionType(widget.viewModel.model.sessionResource)
+                };
+                const parsedRequest = this._instantiationService.createInstance(ChatRequestParser).parseChatRequestWithReferences(
+                    getDynamicVariablesForWidget(widget),
+                    getSelectedToolAndToolSetsForWidget(widget),
+                    model.getValue(),
+                    ChatAgentLocation.Chat,
+                    context
+                ).parts;
+                const agentPart = parsedRequest.find(part => part instanceof ChatRequestAgentPart);
+                const thisAgentId = this._agents.get(handle)?.id;
+                if (agentPart?.agent.id !== thisAgentId) {
+                    return;
+                }
+                const range = computeCompletionRanges(model, position, wordRegex);
+                if (!range) {
+                    return null;
+                }
+                const result = await provide(query, token);
+                const variableItems = result.map(v => {
+                    const insertText = v.insertText ?? (typeof v.label === "string" ? v.label : v.label.label);
+                    const rangeAfterInsert = ( new Range(
+                        range.insert.startLineNumber,
+                        range.insert.startColumn,
+                        range.insert.endLineNumber,
+                        range.insert.startColumn + insertText.length
+                    ));
+                    return {
+                        label: v.label,
+                        range,
+                        insertText: insertText + " ",
+                        kind: CompletionItemKind.Text,
+                        detail: v.detail,
+                        documentation: v.documentation,
+                        command: {
+                            id: addDynamicVariableActionId,
+                            title: "",
+                            arguments: [{
+                                id: v.id,
+                                widget,
+                                range: rangeAfterInsert,
+                                variableData: revive(v.value),
+                                command: v.command
+                            }]
+                        }
+                    };
+                });
+                return {
+                    suggestions: variableItems
+                };
+            }
+        }));
+    }
+    $unregisterAgentCompletionsProvider(handle, id) {
+        this._agentCompletionProviders.deleteAndDispose(handle);
+        this._agentIdsToCompletionProviders.deleteAndDispose(id);
+    }
+    $registerChatParticipantDetectionProvider(handle) {
+        this._chatParticipantDetectionProviders.set(
+            handle,
+            this._chatAgentService.registerChatParticipantDetectionProvider(handle, {
+                provideParticipantDetection: async (request, history, options, token) => {
+                    return await this._proxy.$detectChatParticipant(handle, request, {
+                        history
+                    }, options, token);
+                }
+            })
+        );
+    }
+    $unregisterChatParticipantDetectionProvider(handle) {
+        this._chatParticipantDetectionProviders.deleteAndDispose(handle);
+    }
+    async $registerPromptFileProvider(handle, type, extensionId) {
+        const extension = await this._extensionService.getExtension(extensionId.value);
+        if (!extension) {
+            this._logService.error(
+                `[MainThreadChatAgents2] Could not find extension for prompt file provider: ${extensionId.value}`
+            );
+            return;
+        }
+        if (!isValidPromptType(type)) {
+            this._logService.error(`[MainThreadChatAgents2] Invalid contribution type: ${type}`);
+            return;
+        }
+        const emitter = ( new Emitter());
+        this._promptFileProviderEmitters.set(handle, emitter);
+        const contentRegistrations = ( new DisposableMap());
+        this._promptFileContentRegistrations.set(handle, contentRegistrations);
+        const disposable = this._promptsService.registerPromptFileProvider(extension, type, {
+            onDidChangePromptFiles: emitter.event,
+            providePromptFiles: async (context, token) => {
+                const contributions = await this._proxy.$providePromptFiles(handle, type, context, token);
+                if (!contributions) {
+                    return undefined;
+                }
+                return contributions.map(c => {
+                    return {
+                        name: c.name,
+                        description: c.description,
+                        sessionTypes: c.sessionTypes,
+                        when: c.when,
+                        uri: URI.revive(c.uri)
+                    };
+                });
+            }
+        });
+        this._promptFileProviders.set(handle, disposable);
+    }
+    $unregisterPromptFileProvider(handle) {
+        this._promptFileProviders.deleteAndDispose(handle);
+        this._promptFileProviderEmitters.deleteAndDispose(handle);
+        this._promptFileContentRegistrations.deleteAndDispose(handle);
+    }
+    $onDidChangePromptFiles(handle) {
+        const emitter = this._promptFileProviderEmitters.get(handle);
+        if (emitter) {
+            emitter.fire();
+        }
+    }
+    async $registerChatSessionCustomizationProvider(handle, chatSessionType, metadata, extensionId) {
+        if (this._environmentService.isSessionsWindow && !this._chatSessionService.getContentProviderSchemes().includes(chatSessionType)) {
+            return;
+        }
+        const extension = await this._extensionService.getExtension(extensionId.value);
+        if (!extension) {
+            this._logService.error(
+                `[MainThreadChatAgents2] Could not find extension for customization provider: ${extensionId.value}`
+            );
+            return;
+        }
+        const emitter = ( new Emitter());
+        this._customizationProviderEmitters.set(handle, emitter);
+        const itemProvider = {
+            onDidChange: emitter.event,
+            provideChatSessionCustomizations: async (sessionResource, token) => {
+                const items = await this._proxy.$provideChatSessionCustomizations(handle, sessionResource, token);
+                if (!items) {
+                    return undefined;
+                }
+                return items.map(item => ({
+                    uri: URI.revive(item.uri),
+                    type: item.type,
+                    name: item.name,
+                    source: item.source,
+                    description: item.description,
+                    groupKey: item.groupKey,
+                    badge: item.badge,
+                    badgeTooltip: item.badgeTooltip,
+                    extensionId: item.extensionId,
+                    pluginUri: item.pluginUri ? URI.revive(item.pluginUri) : undefined,
+                    pluginLabel: item.pluginLabel,
+                    userInvocable: item.userInvocable
+                }));
+            },
+            provideSourceFolders: async (sessionResource, type, token) => {
+                const folders = await this._proxy.$provideSourceFolders(handle, sessionResource, type, token);
+                if (!folders) {
+                    return undefined;
+                }
+                return folders.map(folder => ({
+                    uri: URI.revive(folder.uri),
+                    label: folder.label,
+                    source: folder.source,
+                    destinationGroupId: folder.destinationGroupId
+                }));
+            }
+        };
+        const typeToSection = {
+            "agent": AICustomizationManagementSection.Agents,
+            "skill": AICustomizationManagementSection.Skills,
+            "instructions": AICustomizationManagementSection.Instructions,
+            "prompt": AICustomizationManagementSection.Prompts,
+            "hook": AICustomizationManagementSection.Hooks,
+            "plugins": AICustomizationManagementSection.Plugins
+        };
+        let hiddenSections;
+        if (metadata.supportedTypes) {
+            const supportedSections = ( new Set());
+            for (const t of metadata.supportedTypes) {
+                const section = typeToSection[t];
+                if (section) {
+                    supportedSections.add(section);
+                }
+            }
+            hiddenSections = ( Object.values(typeToSection)).filter(section => !( supportedSections.has(section)));
+        }
+        const descriptor = {
+            id: chatSessionType,
+            label: metadata.label,
+            icon: metadata.iconId ? ThemeIcon.fromId(metadata.iconId) : ThemeIcon.fromId(Codicon.extensions.id),
+            hiddenSections,
+            itemProvider
+        };
+        const registration = this._customizationHarnessService.registerExternalHarness(descriptor);
+        this._customizationProviders.set(handle, registration);
+    }
+    $unregisterChatSessionCustomizationProvider(handle) {
+        this._customizationProviders.deleteAndDispose(handle);
+        this._customizationProviderEmitters.deleteAndDispose(handle);
+    }
+    $onDidChangeCustomizations(handle) {
+        const emitter = this._customizationProviderEmitters.get(handle);
+        if (emitter) {
+            emitter.fire();
+        }
+    }
+};
+MainThreadChatAgents2 = __decorate([extHostNamedCustomer(MainContext.MainThreadChatAgents2), ( __param(1, IChatAgentService)), ( __param(2, IChatSessionsService)), ( __param(3, IChatService)), ( __param(4, ILanguageFeaturesService)), ( __param(5, IChatWidgetService)), ( __param(6, IInstantiationService)), ( __param(7, ILogService)), ( __param(8, IExtensionService)), ( __param(9, IUriIdentityService)), ( __param(10, IPromptsService)), ( __param(11, ILanguageModelToolsService)), ( __param(12, ICustomizationHarnessService)), ( __param(13, ITelemetryService)), ( __param(14, IAgentPluginService)), ( __param(15, IWorkbenchEnvironmentService))], MainThreadChatAgents2);
+function computeCompletionRanges(model, position, reg) {
+    const varWord = getWordAtText(position.column, reg, model.getLineContent(position.lineNumber), 0);
+    if (!varWord && model.getWordUntilPosition(position).word) {
+        return;
+    }
+    let insert;
+    let replace;
+    if (!varWord) {
+        insert = replace = Range.fromPositions(position);
+    } else {
+        insert = ( new Range(
+            position.lineNumber,
+            varWord.startColumn,
+            position.lineNumber,
+            position.column
+        ));
+        replace = ( new Range(
+            position.lineNumber,
+            varWord.startColumn,
+            position.lineNumber,
+            varWord.endColumn
+        ));
+    }
+    return {
+        insert,
+        replace
+    };
+}
+var ChatNotebookEdit;
+(function(ChatNotebookEdit) {
+    function fromChatEdit(part) {
+        return {
+            kind: "notebookEdit",
+            uri: URI.revive(part.uri),
+            done: part.done,
+            edits: part.edits.map(NotebookDto.fromCellEditOperationDto)
+        };
+    }
+    ChatNotebookEdit.fromChatEdit = fromChatEdit;
+})(ChatNotebookEdit || (ChatNotebookEdit = {}));
+
+export { MainThreadChatAgents2, MainThreadChatTask };