@codingame/monaco-vscode-chat-service-override 23.2.2 → 24.1.0

package/vscode/src/vs/workbench/contrib/chat/browser/chatSetup/chatSetupProviders.js

@@ -0,0 +1,667 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { timeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { toErrorMessage } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errorMessage';
+import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { localize2, localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+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 product from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/product';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { IWorkspaceTrustManagementService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service';
+import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
+import { nullExtensionDescription } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions';
+import { ToolDataSource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService';
+import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.service';
+import { IChatAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents.service';
+import { ChatEntitlement, ChatEntitlementRequests } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService';
+import { IChatEntitlementService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service';
+import { ChatRequestModel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModel';
+import { ChatMode } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes';
+import { ChatRequestToolPart, ChatRequestAgentPart } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatParserTypes';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
+import { ChatConfiguration, ChatAgentLocation, ChatModeKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ILanguageModelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service';
+import { CHAT_SETUP_ACTION_ID, CHAT_OPEN_ACTION_ID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { ILanguageFeaturesService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/languageFeatures.service';
+import { Selection } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/selection';
+import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { CodeActionKind } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/codeAction/common/types';
+import { ACTION_START } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
+import { MarkerSeverity } from '@codingame/monaco-vscode-api/vscode/vs/platform/markers/common/markers';
+import { IMarkerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/markers/common/markers.service';
+import { ChatSetupStep, ChatSetupAnonymous } from './chatSetup.js';
+import { ChatSetup } from './chatSetupRunner.js';
+
+var SetupAgent_1, AINewSymbolNamesProvider_1, ChatCodeActionsProvider_1;
+const defaultChat = {
+    extensionId: product.defaultChatAgent?.extensionId ?? '',
+    chatExtensionId: product.defaultChatAgent?.chatExtensionId ?? '',
+    provider: product.defaultChatAgent?.provider ?? { default: { id: '', name: '' }, enterprise: { id: '', name: '' }, apple: { id: '', name: '' }, google: { id: '', name: '' } },
+};
+const ToolsAgentContextKey = ( ContextKeyExpr.and(( ContextKeyExpr.equals(`config.${ChatConfiguration.AgentEnabled}`, true)),
+ContextKeyExpr.not(`previewFeaturesDisabled`)));
+let SetupAgent = class SetupAgent extends Disposable {
+    static { SetupAgent_1 = this; }
+    static registerDefaultAgents(instantiationService, location, mode, context, controller) {
+        return instantiationService.invokeFunction(accessor => {
+            const chatAgentService = accessor.get(IChatAgentService);
+            let id;
+            let description = ChatMode.Ask.description.get();
+            switch (location) {
+                case ChatAgentLocation.Chat:
+                    if (mode === ChatModeKind.Ask) {
+                        id = 'setup.chat';
+                    }
+                    else if (mode === ChatModeKind.Edit) {
+                        id = 'setup.edits';
+                        description = ChatMode.Edit.description.get();
+                    }
+                    else {
+                        id = 'setup.agent';
+                        description = ChatMode.Agent.description.get();
+                    }
+                    break;
+                case ChatAgentLocation.Terminal:
+                    id = 'setup.terminal';
+                    break;
+                case ChatAgentLocation.EditorInline:
+                    id = 'setup.editor';
+                    break;
+                case ChatAgentLocation.Notebook:
+                    id = 'setup.notebook';
+                    break;
+            }
+            return SetupAgent_1.doRegisterAgent(instantiationService, chatAgentService, id, `${defaultChat.provider.default.name} Copilot` , true, description, location, mode, context, controller);
+        });
+    }
+    static registerBuiltInAgents(instantiationService, context, controller) {
+        return instantiationService.invokeFunction(accessor => {
+            const chatAgentService = accessor.get(IChatAgentService);
+            const disposables = ( new DisposableStore());
+            const { disposable: vscodeDisposable } = SetupAgent_1.doRegisterAgent(instantiationService, chatAgentService, 'setup.vscode', 'vscode', false, ( localize2(5545, "Ask questions about VS Code")).value, ChatAgentLocation.Chat, undefined, context, controller);
+            disposables.add(vscodeDisposable);
+            const { disposable: workspaceDisposable } = SetupAgent_1.doRegisterAgent(instantiationService, chatAgentService, 'setup.workspace', 'workspace', false, ( localize2(5546, "Ask about your workspace")).value, ChatAgentLocation.Chat, undefined, context, controller);
+            disposables.add(workspaceDisposable);
+            const { disposable: terminalDisposable } = SetupAgent_1.doRegisterAgent(instantiationService, chatAgentService, 'setup.terminal.agent', 'terminal', false, ( localize2(5547, "Ask how to do something in the terminal")).value, ChatAgentLocation.Chat, undefined, context, controller);
+            disposables.add(terminalDisposable);
+            disposables.add(SetupTool.registerTool(instantiationService, {
+                id: 'setup_tools_createNewWorkspace',
+                source: ToolDataSource.Internal,
+                icon: Codicon.newFolder,
+                displayName: ( localize(5548, "New Workspace")),
+                modelDescription: 'Scaffold a new workspace in VS Code',
+                userDescription: ( localize(5549, "Scaffold a new workspace in VS Code")),
+                canBeReferencedInPrompt: true,
+                toolReferenceName: 'new',
+                when: ContextKeyExpr.true(),
+            }));
+            return disposables;
+        });
+    }
+    static doRegisterAgent(instantiationService, chatAgentService, id, name, isDefault, description, location, mode, context, controller) {
+        const disposables = ( new DisposableStore());
+        disposables.add(chatAgentService.registerAgent(id, {
+            id,
+            name,
+            isDefault,
+            isCore: true,
+            modes: mode ? [mode] : [ChatModeKind.Ask],
+            when: mode === ChatModeKind.Agent ? ToolsAgentContextKey?.serialize() : undefined,
+            slashCommands: [],
+            disambiguation: [],
+            locations: [location],
+            metadata: { helpTextPrefix: SetupAgent_1.SETUP_NEEDED_MESSAGE },
+            description,
+            extensionId: nullExtensionDescription.identifier,
+            extensionVersion: undefined,
+            extensionDisplayName: nullExtensionDescription.name,
+            extensionPublisherId: nullExtensionDescription.publisher
+        }));
+        const agent = disposables.add(instantiationService.createInstance(SetupAgent_1, context, controller, location));
+        disposables.add(chatAgentService.registerAgentImplementation(id, agent));
+        if (mode === ChatModeKind.Agent) {
+            chatAgentService.updateAgent(id, { themeIcon: Codicon.tools });
+        }
+        return { agent, disposable: disposables };
+    }
+    static { this.SETUP_NEEDED_MESSAGE = ( new MarkdownString(( localize(5550, "You need to set up GitHub Copilot and be signed in to use Chat.")))); }
+    static { this.TRUST_NEEDED_MESSAGE = ( new MarkdownString(( localize(5551, "You need to trust this workspace to use Chat.")))); }
+    constructor(context, controller, location, instantiationService, logService, configurationService, telemetryService, environmentService, workspaceTrustManagementService, chatEntitlementService) {
+        super();
+        this.context = context;
+        this.controller = controller;
+        this.location = location;
+        this.instantiationService = instantiationService;
+        this.logService = logService;
+        this.configurationService = configurationService;
+        this.telemetryService = telemetryService;
+        this.environmentService = environmentService;
+        this.workspaceTrustManagementService = workspaceTrustManagementService;
+        this.chatEntitlementService = chatEntitlementService;
+        this._onUnresolvableError = this._register(( new Emitter()));
+        this.onUnresolvableError = this._onUnresolvableError.event;
+        this.pendingForwardedRequests = ( new ResourceMap());
+    }
+    async invoke(request, progress) {
+        return this.instantiationService.invokeFunction(async (accessor ) => {
+            const chatService = accessor.get(IChatService);
+            const languageModelsService = accessor.get(ILanguageModelsService);
+            const chatWidgetService = accessor.get(IChatWidgetService);
+            const chatAgentService = accessor.get(IChatAgentService);
+            const languageModelToolsService = accessor.get(ILanguageModelToolsService);
+            return this.doInvoke(request, part => progress([part]), chatService, languageModelsService, chatWidgetService, chatAgentService, languageModelToolsService);
+        });
+    }
+    async doInvoke(request, progress, chatService, languageModelsService, chatWidgetService, chatAgentService, languageModelToolsService) {
+        if (!this.context.state.installed ||
+            this.context.state.disabled ||
+            this.context.state.untrusted ||
+            this.context.state.entitlement === ChatEntitlement.Available ||
+            ((
+        this.context.state.entitlement === ChatEntitlement.Unknown && !this.chatEntitlementService.anonymous)
+            )) {
+            return this.doInvokeWithSetup(request, progress, chatService, languageModelsService, chatWidgetService, chatAgentService, languageModelToolsService);
+        }
+        return this.doInvokeWithoutSetup(request, progress, chatService, languageModelsService, chatWidgetService, chatAgentService, languageModelToolsService);
+    }
+    async doInvokeWithoutSetup(request, progress, chatService, languageModelsService, chatWidgetService, chatAgentService, languageModelToolsService) {
+        const requestModel = chatWidgetService.getWidgetBySessionResource(request.sessionResource)?.viewModel?.model.getRequests().at(-1);
+        if (!requestModel) {
+            this.logService.error('[chat setup] Request model not found, cannot redispatch request.');
+            return {};
+        }
+        progress({
+            kind: 'progressMessage',
+            content: ( new MarkdownString(( localize(5552, "Getting chat ready...")))),
+        });
+        await this.forwardRequestToChat(requestModel, progress, chatService, languageModelsService, chatAgentService, chatWidgetService, languageModelToolsService);
+        return {};
+    }
+    async forwardRequestToChat(requestModel, progress, chatService, languageModelsService, chatAgentService, chatWidgetService, languageModelToolsService) {
+        try {
+            await this.doForwardRequestToChat(requestModel, progress, chatService, languageModelsService, chatAgentService, chatWidgetService, languageModelToolsService);
+        }
+        catch (error) {
+            this.logService.error('[chat setup] Failed to forward request to chat', error);
+            progress({
+                kind: 'warning',
+                content: ( new MarkdownString(( localize(5553, "Failed to get a response. Please try again."))))
+            });
+        }
+    }
+    async doForwardRequestToChat(requestModel, progress, chatService, languageModelsService, chatAgentService, chatWidgetService, languageModelToolsService) {
+        if (( this.pendingForwardedRequests.has(requestModel.session.sessionResource))) {
+            throw ( new Error('Request already in progress'));
+        }
+        const forwardRequest = this.doForwardRequestToChatWhenReady(requestModel, progress, chatService, languageModelsService, chatAgentService, chatWidgetService, languageModelToolsService);
+        this.pendingForwardedRequests.set(requestModel.session.sessionResource, forwardRequest);
+        try {
+            await forwardRequest;
+        }
+        finally {
+            this.pendingForwardedRequests.delete(requestModel.session.sessionResource);
+        }
+    }
+    async doForwardRequestToChatWhenReady(requestModel, progress, chatService, languageModelsService, chatAgentService, chatWidgetService, languageModelToolsService) {
+        const widget = chatWidgetService.getWidgetBySessionResource(requestModel.session.sessionResource);
+        const modeInfo = widget?.input.currentModeInfo;
+        let agentActivated = false;
+        let agentReady = false;
+        let languageModelReady = false;
+        let toolsModelReady = false;
+        const whenAgentActivated = this.whenAgentActivated(chatService).then(() => agentActivated = true);
+        const whenAgentReady = this.whenAgentReady(chatAgentService, modeInfo?.kind)?.then(() => agentReady = true);
+        const whenLanguageModelReady = this.whenLanguageModelReady(languageModelsService, requestModel.modelId)?.then(() => languageModelReady = true);
+        const whenToolsModelReady = this.whenToolsModelReady(languageModelToolsService, requestModel)?.then(() => toolsModelReady = true);
+        if (whenLanguageModelReady instanceof Promise || whenAgentReady instanceof Promise || whenToolsModelReady instanceof Promise) {
+            const timeoutHandle = setTimeout(() => {
+                progress({
+                    kind: 'progressMessage',
+                    content: ( new MarkdownString(( localize(5554, "Chat is almost ready...")))),
+                });
+            }, 10000);
+            try {
+                const ready = await Promise.race([
+                    timeout(this.environmentService.remoteAuthority ? 60000  : 20000).then(() => 'timedout'),
+                    Promise.allSettled([
+                        whenAgentActivated,
+                        whenAgentReady,
+                        whenLanguageModelReady,
+                        whenToolsModelReady
+                    ])
+                ]);
+                if (ready === 'timedout') {
+                    let warningMessage;
+                    if (this.chatEntitlementService.anonymous) {
+                        warningMessage = ( localize(
+                            5555,
+                            "Chat took too long to get ready. Please ensure that the extension `{0}` is installed and enabled.",
+                            defaultChat.chatExtensionId
+                        ));
+                    }
+                    else {
+                        warningMessage = ( localize(
+                            5556,
+                            "Chat took too long to get ready. Please ensure you are signed in to {0} and that the extension `{1}` is installed and enabled.",
+                            defaultChat.provider.default.name,
+                            defaultChat.chatExtensionId
+                        ));
+                    }
+                    this.logService.warn(warningMessage, {
+                        agentActivated,
+                        agentReady,
+                        languageModelReady,
+                        toolsModelReady
+                    });
+                    progress({
+                        kind: 'warning',
+                        content: ( new MarkdownString(warningMessage))
+                    });
+                    this._onUnresolvableError.fire();
+                    return;
+                }
+            }
+            finally {
+                clearTimeout(timeoutHandle);
+            }
+        }
+        await chatService.resendRequest(requestModel, {
+            ...widget?.getModeRequestOptions(),
+            modeInfo,
+            userSelectedModelId: widget?.input.currentLanguageModel
+        });
+    }
+    whenLanguageModelReady(languageModelsService, modelId) {
+        const hasModelForRequest = () => {
+            if (modelId) {
+                return !!languageModelsService.lookupLanguageModel(modelId);
+            }
+            for (const id of languageModelsService.getLanguageModelIds()) {
+                const model = languageModelsService.lookupLanguageModel(id);
+                if (model?.isDefault) {
+                    return true;
+                }
+            }
+            return false;
+        };
+        if (hasModelForRequest()) {
+            return;
+        }
+        return Event.toPromise(Event.filter(languageModelsService.onDidChangeLanguageModels, () => hasModelForRequest()));
+    }
+    whenToolsModelReady(languageModelToolsService, requestModel) {
+        const needsToolsModel = ( requestModel.message.parts.some(part => part instanceof ChatRequestToolPart));
+        if (!needsToolsModel) {
+            return;
+        }
+        for (const tool of languageModelToolsService.getTools()) {
+            if (tool.id.startsWith('copilot_')) {
+                return;
+            }
+        }
+        return Event.toPromise(Event.filter(languageModelToolsService.onDidChangeTools, () => {
+            for (const tool of languageModelToolsService.getTools()) {
+                if (tool.id.startsWith('copilot_')) {
+                    return true;
+                }
+            }
+            return false;
+        }));
+    }
+    whenAgentReady(chatAgentService, mode) {
+        const defaultAgent = chatAgentService.getDefaultAgent(this.location, mode);
+        if (defaultAgent && !defaultAgent.isCore) {
+            return;
+        }
+        return Event.toPromise(Event.filter(chatAgentService.onDidChangeAgents, () => {
+            const defaultAgent = chatAgentService.getDefaultAgent(this.location, mode);
+            return Boolean(defaultAgent && !defaultAgent.isCore);
+        }));
+    }
+    async whenAgentActivated(chatService) {
+        try {
+            await chatService.activateDefaultAgent(this.location);
+        }
+        catch (error) {
+            this.logService.error(error);
+        }
+    }
+    async doInvokeWithSetup(request, progress, chatService, languageModelsService, chatWidgetService, chatAgentService, languageModelToolsService) {
+        this.telemetryService.publicLog2('workbenchActionExecuted', { id: CHAT_SETUP_ACTION_ID, from: 'chat' });
+        const widget = chatWidgetService.getWidgetBySessionResource(request.sessionResource);
+        const requestModel = widget?.viewModel?.model.getRequests().at(-1);
+        const setupListener = Event.runAndSubscribe(this.controller.value.onDidChange, (() => {
+            switch (this.controller.value.step) {
+                case ChatSetupStep.SigningIn:
+                    progress({
+                        kind: 'progressMessage',
+                        content: ( new MarkdownString(( localize(
+                            5557,
+                            "Signing in to {0}...",
+                            ChatEntitlementRequests.providerId(this.configurationService) === defaultChat.provider.enterprise.id ? defaultChat.provider.enterprise.name : defaultChat.provider.default.name
+                        )))),
+                    });
+                    break;
+                case ChatSetupStep.Installing:
+                    progress({
+                        kind: 'progressMessage',
+                        content: ( new MarkdownString(( localize(5558, "Getting chat ready...")))),
+                    });
+                    break;
+            }
+        }));
+        let result = undefined;
+        try {
+            result = await ChatSetup.getInstance(this.instantiationService, this.context, this.controller).run({
+                disableChatViewReveal: true,
+                forceAnonymous: this.chatEntitlementService.anonymous ? ChatSetupAnonymous.EnabledWithoutDialog : undefined
+            });
+        }
+        catch (error) {
+            this.logService.error(`[chat setup] Error during setup: ${toErrorMessage(error)}`);
+        }
+        finally {
+            setupListener.dispose();
+        }
+        if (typeof result?.success === 'boolean') {
+            if (result.success) {
+                if (result.dialogSkipped) {
+                    await widget?.clear();
+                }
+                else if (requestModel) {
+                    let newRequest = this.replaceAgentInRequestModel(requestModel, chatAgentService);
+                    newRequest = this.replaceToolInRequestModel(newRequest);
+                    await this.forwardRequestToChat(newRequest, progress, chatService, languageModelsService, chatAgentService, chatWidgetService, languageModelToolsService);
+                }
+            }
+            else {
+                progress({
+                    kind: 'warning',
+                    content: ( new MarkdownString(( localize(5559, "Chat setup failed."))))
+                });
+            }
+        }
+        else {
+            progress({
+                kind: 'markdownContent',
+                content: this.workspaceTrustManagementService.isWorkspaceTrusted() ? SetupAgent_1.SETUP_NEEDED_MESSAGE : SetupAgent_1.TRUST_NEEDED_MESSAGE
+            });
+        }
+        return {};
+    }
+    replaceAgentInRequestModel(requestModel, chatAgentService) {
+        const agentPart = requestModel.message.parts.find((r) => r instanceof ChatRequestAgentPart);
+        if (!agentPart) {
+            return requestModel;
+        }
+        const agentId = agentPart.agent.id.replace(/setup\./, `${defaultChat.extensionId}.`.toLowerCase());
+        const githubAgent = chatAgentService.getAgent(agentId);
+        if (!githubAgent) {
+            return requestModel;
+        }
+        const newAgentPart = ( new ChatRequestAgentPart(agentPart.range, agentPart.editorRange, githubAgent));
+        return ( new ChatRequestModel({
+            session: requestModel.session,
+            message: {
+                parts: ( requestModel.message.parts.map(part => {
+                    if (part instanceof ChatRequestAgentPart) {
+                        return newAgentPart;
+                    }
+                    return part;
+                })),
+                text: requestModel.message.text
+            },
+            variableData: requestModel.variableData,
+            timestamp: Date.now(),
+            attempt: requestModel.attempt,
+            modeInfo: requestModel.modeInfo,
+            confirmation: requestModel.confirmation,
+            locationData: requestModel.locationData,
+            attachedContext: requestModel.attachedContext,
+            isCompleteAddedRequest: requestModel.isCompleteAddedRequest,
+        }));
+    }
+    replaceToolInRequestModel(requestModel) {
+        const toolPart = requestModel.message.parts.find((r) => r instanceof ChatRequestToolPart);
+        if (!toolPart) {
+            return requestModel;
+        }
+        const toolId = toolPart.toolId.replace(/setup.tools\./, `copilot_`.toLowerCase());
+        const newToolPart = ( new ChatRequestToolPart(
+            toolPart.range,
+            toolPart.editorRange,
+            toolPart.toolName,
+            toolId,
+            toolPart.displayName,
+            toolPart.icon
+        ));
+        const chatRequestToolEntry = {
+            id: toolId,
+            name: 'new',
+            range: toolPart.range,
+            kind: 'tool',
+            value: undefined
+        };
+        const variableData = {
+            variables: [chatRequestToolEntry]
+        };
+        return ( new ChatRequestModel({
+            session: requestModel.session,
+            message: {
+                parts: ( requestModel.message.parts.map(part => {
+                    if (part instanceof ChatRequestToolPart) {
+                        return newToolPart;
+                    }
+                    return part;
+                })),
+                text: requestModel.message.text
+            },
+            variableData: variableData,
+            timestamp: Date.now(),
+            attempt: requestModel.attempt,
+            modeInfo: requestModel.modeInfo,
+            confirmation: requestModel.confirmation,
+            locationData: requestModel.locationData,
+            attachedContext: [chatRequestToolEntry],
+            isCompleteAddedRequest: requestModel.isCompleteAddedRequest,
+        }));
+    }
+};
+SetupAgent = SetupAgent_1 = ( __decorate([
+    ( __param(3, IInstantiationService)),
+    ( __param(4, ILogService)),
+    ( __param(5, IConfigurationService)),
+    ( __param(6, ITelemetryService)),
+    ( __param(7, IWorkbenchEnvironmentService)),
+    ( __param(8, IWorkspaceTrustManagementService)),
+    ( __param(9, IChatEntitlementService))
+], SetupAgent));
+class SetupTool {
+    static registerTool(instantiationService, toolData) {
+        return instantiationService.invokeFunction(accessor => {
+            const toolService = accessor.get(ILanguageModelToolsService);
+            const tool = instantiationService.createInstance(SetupTool);
+            return toolService.registerTool(toolData, tool);
+        });
+    }
+    async invoke(invocation, countTokens, progress, token) {
+        const result = {
+            content: [
+                {
+                    kind: 'text',
+                    value: ''
+                }
+            ]
+        };
+        return result;
+    }
+    async prepareToolInvocation(parameters, token) {
+        return undefined;
+    }
+}
+let AINewSymbolNamesProvider = AINewSymbolNamesProvider_1 = class AINewSymbolNamesProvider {
+    static registerProvider(instantiationService, context, controller) {
+        return instantiationService.invokeFunction(accessor => {
+            const languageFeaturesService = accessor.get(ILanguageFeaturesService);
+            const provider = instantiationService.createInstance(AINewSymbolNamesProvider_1, context, controller);
+            return languageFeaturesService.newSymbolNamesProvider.register('*', provider);
+        });
+    }
+    constructor(context, controller, instantiationService, chatEntitlementService) {
+        this.context = context;
+        this.controller = controller;
+        this.instantiationService = instantiationService;
+        this.chatEntitlementService = chatEntitlementService;
+    }
+    async provideNewSymbolNames(model, range, triggerKind, token) {
+        await this.instantiationService.invokeFunction(accessor => {
+            return ChatSetup.getInstance(this.instantiationService, this.context, this.controller).run({
+                forceAnonymous: this.chatEntitlementService.anonymous ? ChatSetupAnonymous.EnabledWithDialog : undefined
+            });
+        });
+        return [];
+    }
+};
+AINewSymbolNamesProvider = AINewSymbolNamesProvider_1 = ( __decorate([
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IChatEntitlementService))
+], AINewSymbolNamesProvider));
+let ChatCodeActionsProvider = ChatCodeActionsProvider_1 = class ChatCodeActionsProvider {
+    static registerProvider(instantiationService) {
+        return instantiationService.invokeFunction(accessor => {
+            const languageFeaturesService = accessor.get(ILanguageFeaturesService);
+            const provider = instantiationService.createInstance(ChatCodeActionsProvider_1);
+            return languageFeaturesService.codeActionProvider.register('*', provider);
+        });
+    }
+    constructor(markerService) {
+        this.markerService = markerService;
+    }
+    async provideCodeActions(model, range) {
+        const actions = [];
+        let generateOrModifyTitle;
+        let generateOrModifyCommand;
+        if (range.isEmpty()) {
+            const textAtLine = model.getLineContent(range.startLineNumber);
+            if (/^\s*$/.test(textAtLine)) {
+                generateOrModifyTitle = ( localize(5560, "Generate"));
+                generateOrModifyCommand = AICodeActionsHelper.generate(range);
+            }
+        }
+        else {
+            const textInSelection = model.getValueInRange(range);
+            if (!/^\s*$/.test(textInSelection)) {
+                generateOrModifyTitle = ( localize(5561, "Modify"));
+                generateOrModifyCommand = AICodeActionsHelper.modify(range);
+            }
+        }
+        if (generateOrModifyTitle && generateOrModifyCommand) {
+            actions.push({
+                kind: CodeActionKind.RefactorRewrite.append('copilot').value,
+                isAI: true,
+                title: generateOrModifyTitle,
+                command: generateOrModifyCommand,
+            });
+        }
+        const markers = AICodeActionsHelper.warningOrErrorMarkersAtRange(this.markerService, model.uri, range);
+        if (markers.length > 0) {
+            actions.push({
+                kind: CodeActionKind.QuickFix.append('copilot').value,
+                isAI: true,
+                diagnostics: markers,
+                title: ( localize(5562, "Fix")),
+                command: AICodeActionsHelper.fixMarkers(markers, range)
+            });
+            actions.push({
+                kind: CodeActionKind.QuickFix.append('explain').append('copilot').value,
+                isAI: true,
+                diagnostics: markers,
+                title: ( localize(5563, "Explain")),
+                command: AICodeActionsHelper.explainMarkers(markers)
+            });
+        }
+        return {
+            actions,
+            dispose() { }
+        };
+    }
+};
+ChatCodeActionsProvider = ChatCodeActionsProvider_1 = ( __decorate([
+    ( __param(0, IMarkerService))
+], ChatCodeActionsProvider));
+class AICodeActionsHelper {
+    static warningOrErrorMarkersAtRange(markerService, resource, range) {
+        return markerService
+            .read({ resource, severities: MarkerSeverity.Error | MarkerSeverity.Warning })
+            .filter(marker => range.startLineNumber <= marker.endLineNumber && range.endLineNumber >= marker.startLineNumber);
+    }
+    static modify(range) {
+        return {
+            id: ACTION_START,
+            title: ( localize(5561, "Modify")),
+            arguments: [
+                {
+                    initialSelection: this.rangeToSelection(range),
+                    initialRange: range,
+                    position: range.getStartPosition()
+                }
+            ]
+        };
+    }
+    static generate(range) {
+        return {
+            id: ACTION_START,
+            title: ( localize(5560, "Generate")),
+            arguments: [
+                {
+                    initialSelection: this.rangeToSelection(range),
+                    initialRange: range,
+                    position: range.getStartPosition()
+                }
+            ]
+        };
+    }
+    static rangeToSelection(range) {
+        return ( new Selection(
+            range.startLineNumber,
+            range.startColumn,
+            range.endLineNumber,
+            range.endColumn
+        ));
+    }
+    static explainMarkers(markers) {
+        return {
+            id: CHAT_OPEN_ACTION_ID,
+            title: ( localize(5563, "Explain")),
+            arguments: [
+                {
+                    query: `@workspace /explain ${( markers.map(marker => marker.message)).join(', ')}`,
+                    isPartialQuery: true
+                }
+            ]
+        };
+    }
+    static fixMarkers(markers, range) {
+        return {
+            id: ACTION_START,
+            title: ( localize(5562, "Fix")),
+            arguments: [
+                {
+                    message: `/fix ${( markers.map(marker => marker.message)).join(', ')}`,
+                    initialSelection: this.rangeToSelection(range),
+                    initialRange: range,
+                    position: range.getStartPosition()
+                }
+            ]
+        };
+    }
+}
+
+export { AICodeActionsHelper, AINewSymbolNamesProvider, ChatCodeActionsProvider, SetupAgent, SetupTool };