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

package/vscode/src/vs/workbench/contrib/chat/browser/chatSetup/chatSetupController.d.ts

@@ -0,0 +1,53 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ICommandService } from "@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+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 { IProductService } from "@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service";
+import { IProgressService } from "@codingame/monaco-vscode-api/vscode/vs/platform/progress/common/progress.service";
+import { IQuickInputService } from "@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IActivityService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/activity/common/activity.service";
+import { IAuthenticationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/authentication/common/authentication.service";
+import { ILifecycleService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service";
+import { IExtensionsWorkbenchService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/extensions/common/extensions.service";
+import { ChatEntitlementContext, ChatEntitlementRequests } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService";
+import { ChatSetupAnonymous, ChatSetupStep, ChatSetupResultValue } from "./chatSetup.js";
+export interface IChatSetupControllerOptions {
+    readonly forceSignIn?: boolean;
+    readonly useSocialProvider?: string;
+    readonly useEnterpriseProvider?: boolean;
+    readonly additionalScopes?: readonly string[];
+    readonly forceAnonymous?: ChatSetupAnonymous;
+}
+export declare class ChatSetupController extends Disposable {
+    private readonly context;
+    private readonly requests;
+    private readonly telemetryService;
+    private readonly authenticationService;
+    private readonly extensionsWorkbenchService;
+    private readonly productService;
+    private readonly logService;
+    private readonly progressService;
+    private readonly activityService;
+    private readonly commandService;
+    private readonly dialogService;
+    private readonly configurationService;
+    private readonly lifecycleService;
+    private readonly quickInputService;
+    private readonly _onDidChange;
+    readonly onDidChange: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
+    private _step;
+    get step(): ChatSetupStep;
+    constructor(context: ChatEntitlementContext, requests: ChatEntitlementRequests, telemetryService: ITelemetryService, authenticationService: IAuthenticationService, extensionsWorkbenchService: IExtensionsWorkbenchService, productService: IProductService, logService: ILogService, progressService: IProgressService, activityService: IActivityService, commandService: ICommandService, dialogService: IDialogService, configurationService: IConfigurationService, lifecycleService: ILifecycleService, quickInputService: IQuickInputService);
+    private registerListeners;
+    private setStep;
+    setup(options?: IChatSetupControllerOptions): Promise<ChatSetupResultValue>;
+    private doSetup;
+    private signIn;
+    private install;
+    private doInstallWithRetry;
+    private doInstall;
+    setupWithProvider(options: IChatSetupControllerOptions): Promise<ChatSetupResultValue>;
+    private handleEnterpriseInstance;
+}

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

@@ -0,0 +1,359 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { toErrorMessage } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errorMessage';
+import { isCancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import Severity from '@codingame/monaco-vscode-api/vscode/vs/base/common/severity';
+import { StopWatch } from '@codingame/monaco-vscode-api/vscode/vs/base/common/stopwatch';
+import { isObject } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { ConfigurationTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { Extensions } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configurationRegistry';
+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 product from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/product';
+import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
+import { ProgressLocation } from '@codingame/monaco-vscode-api/vscode/vs/platform/progress/common/progress';
+import { IProgressService } from '@codingame/monaco-vscode-api/vscode/vs/platform/progress/common/progress.service';
+import { IQuickInputService } from '@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service';
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { ProgressBadge } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/activity/common/activity';
+import { IActivityService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/activity/common/activity.service';
+import { IAuthenticationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/authentication/common/authentication.service';
+import { ILifecycleService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
+import { IExtensionsWorkbenchService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/extensions/common/extensions.service';
+import { ChatEntitlementRequests, ChatEntitlement, isProUser } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService';
+import { CHAT_OPEN_ACTION_ID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
+import { ChatViewContainerId, ChatViewId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat';
+import { ChatSetupStep, refreshTokens } from './chatSetup.js';
+
+const defaultChat = {
+    chatExtensionId: product.defaultChatAgent?.chatExtensionId ?? '',
+    provider: product.defaultChatAgent?.provider ?? { default: { id: '', name: '' }, enterprise: { id: '', name: '' }, apple: { id: '', name: '' }, google: { id: '', name: '' } },
+    providerUriSetting: product.defaultChatAgent?.providerUriSetting ?? '',
+    completionsAdvancedSetting: product.defaultChatAgent?.completionsAdvancedSetting ?? '',
+};
+let ChatSetupController = class ChatSetupController extends Disposable {
+    get step() { return this._step; }
+    constructor(context, requests, telemetryService, authenticationService, extensionsWorkbenchService, productService, logService, progressService, activityService, commandService, dialogService, configurationService, lifecycleService, quickInputService) {
+        super();
+        this.context = context;
+        this.requests = requests;
+        this.telemetryService = telemetryService;
+        this.authenticationService = authenticationService;
+        this.extensionsWorkbenchService = extensionsWorkbenchService;
+        this.productService = productService;
+        this.logService = logService;
+        this.progressService = progressService;
+        this.activityService = activityService;
+        this.commandService = commandService;
+        this.dialogService = dialogService;
+        this.configurationService = configurationService;
+        this.lifecycleService = lifecycleService;
+        this.quickInputService = quickInputService;
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._step = ChatSetupStep.Initial;
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.context.onDidChange(() => this._onDidChange.fire()));
+    }
+    setStep(step) {
+        if (this._step === step) {
+            return;
+        }
+        this._step = step;
+        this._onDidChange.fire();
+    }
+    async setup(options = {}) {
+        const watch = ( new StopWatch(false));
+        const title = ( localize(5536, "Getting chat ready..."));
+        const badge = this.activityService.showViewContainerActivity(ChatViewContainerId, {
+            badge: ( new ProgressBadge(() => title)),
+        });
+        try {
+            return await this.progressService.withProgress({
+                location: ProgressLocation.Window,
+                command: CHAT_OPEN_ACTION_ID,
+                title,
+            }, () => this.doSetup(options, watch));
+        }
+        finally {
+            badge.dispose();
+        }
+    }
+    async doSetup(options, watch) {
+        this.context.suspend();
+        let success = false;
+        try {
+            const providerId = ChatEntitlementRequests.providerId(this.configurationService);
+            let session;
+            let entitlement;
+            let signIn;
+            if (options.forceSignIn) {
+                signIn = true;
+            }
+            else if (this.context.state.entitlement === ChatEntitlement.Unknown) {
+                if (options.forceAnonymous) {
+                    signIn = false;
+                }
+                else {
+                    signIn = true;
+                }
+            }
+            else {
+                signIn = false;
+            }
+            if (signIn) {
+                this.setStep(ChatSetupStep.SigningIn);
+                const result = await this.signIn(options);
+                if (!result.session) {
+                    this.doInstall();
+                    const provider = options.useSocialProvider ?? (options.useEnterpriseProvider ? defaultChat.provider.enterprise.id : defaultChat.provider.default.id);
+                    this.telemetryService.publicLog2('commandCenter.chatInstall', { installResult: 'failedNotSignedIn', installDuration: watch.elapsed(), signUpErrorCode: undefined, provider });
+                    return undefined;
+                }
+                session = result.session;
+                entitlement = result.entitlement;
+            }
+            this.setStep(ChatSetupStep.Installing);
+            success = await this.install(session, entitlement ?? this.context.state.entitlement, providerId, watch, options);
+        }
+        finally {
+            this.setStep(ChatSetupStep.Initial);
+            this.context.resume();
+        }
+        return success;
+    }
+    async signIn(options) {
+        let session;
+        let entitlements;
+        try {
+            ({ session, entitlements } = await this.requests.signIn(options));
+        }
+        catch (e) {
+            this.logService.error(`[chat setup] signIn: error ${e}`);
+        }
+        if (!session && !this.lifecycleService.willShutdown) {
+            const { confirmed } = await this.dialogService.confirm({
+                type: Severity.Error,
+                message: ( localize(
+                    5537,
+                    "Failed to sign in to {0}. Would you like to try again?",
+                    ChatEntitlementRequests.providerId(this.configurationService) === defaultChat.provider.enterprise.id ? defaultChat.provider.enterprise.name : defaultChat.provider.default.name
+                )),
+                detail: ( localize(5538, "You must be signed in to use AI features.")),
+                primaryButton: ( localize(5539, "Retry"))
+            });
+            if (confirmed) {
+                return this.signIn(options);
+            }
+        }
+        return { session, entitlement: entitlements?.entitlement };
+    }
+    async install(session, entitlement, providerId, watch, options) {
+        const wasRunning = this.context.state.installed && !this.context.state.disabled;
+        let signUpResult = undefined;
+        let provider;
+        if (options.forceAnonymous && entitlement === ChatEntitlement.Unknown) {
+            provider = 'anonymous';
+        }
+        else {
+            provider = options.useSocialProvider ?? (options.useEnterpriseProvider ? defaultChat.provider.enterprise.id : defaultChat.provider.default.id);
+        }
+        let sessions = session ? [session] : undefined;
+        try {
+            if (!options.forceAnonymous &&
+                entitlement !== ChatEntitlement.Free &&
+                !isProUser(entitlement) &&
+                entitlement !== ChatEntitlement.Unavailable
+            ) {
+                if (!sessions) {
+                    try {
+                        const existingSessions = await this.authenticationService.getSessions(providerId);
+                        sessions = existingSessions.length > 0 ? [...existingSessions] : undefined;
+                    }
+                    catch (error) {
+                    }
+                    if (!sessions || sessions.length === 0) {
+                        this.telemetryService.publicLog2('commandCenter.chatInstall', { installResult: 'failedNoSession', installDuration: watch.elapsed(), signUpErrorCode: undefined, provider });
+                        return false;
+                    }
+                }
+                signUpResult = await this.requests.signUpFree(sessions);
+                if (typeof signUpResult !== 'boolean' ) {
+                    this.telemetryService.publicLog2('commandCenter.chatInstall', { installResult: 'failedSignUp', installDuration: watch.elapsed(), signUpErrorCode: signUpResult.errorCode, provider });
+                }
+            }
+            await this.doInstallWithRetry();
+        }
+        catch (error) {
+            this.logService.error(`[chat setup] install: error ${error}`);
+            this.telemetryService.publicLog2('commandCenter.chatInstall', { installResult: isCancellationError(error) ? 'cancelled' : 'failedInstall', installDuration: watch.elapsed(), signUpErrorCode: undefined, provider });
+            return false;
+        }
+        if (typeof signUpResult === 'boolean'  || typeof signUpResult === 'undefined' ) {
+            this.telemetryService.publicLog2('commandCenter.chatInstall', { installResult: wasRunning && !signUpResult ? 'alreadyInstalled' : 'installed', installDuration: watch.elapsed(), signUpErrorCode: undefined, provider });
+        }
+        if (wasRunning) {
+            refreshTokens(this.commandService);
+        }
+        return true;
+    }
+    async doInstallWithRetry() {
+        let error;
+        try {
+            await this.doInstall();
+        }
+        catch (e) {
+            this.logService.error(`[chat setup] install: error ${error}`);
+            error = e;
+        }
+        if (error) {
+            if (!this.lifecycleService.willShutdown) {
+                const { confirmed } = await this.dialogService.confirm({
+                    type: Severity.Error,
+                    message: ( localize(
+                        5540,
+                        "An error occurred while setting up chat. Would you like to try again?"
+                    )),
+                    detail: error && !isCancellationError(error) ? toErrorMessage(error) : undefined,
+                    primaryButton: ( localize(5539, "Retry"))
+                });
+                if (confirmed) {
+                    return this.doInstallWithRetry();
+                }
+            }
+            throw error;
+        }
+    }
+    async doInstall() {
+        await this.extensionsWorkbenchService.install(defaultChat.chatExtensionId, {
+            enable: true,
+            isApplicationScoped: true,
+            isMachineScoped: false,
+            installEverywhere: true,
+            installPreReleaseVersion: this.productService.quality !== 'stable'
+        }, ChatViewId);
+    }
+    async setupWithProvider(options) {
+        const registry = ( Registry.as(Extensions.Configuration));
+        registry.registerConfiguration({
+            'id': 'copilot.setup',
+            'type': 'object',
+            'properties': {
+                [defaultChat.completionsAdvancedSetting]: {
+                    'type': 'object',
+                    'properties': {
+                        'authProvider': {
+                            'type': 'string'
+                        }
+                    }
+                },
+                [defaultChat.providerUriSetting]: {
+                    'type': 'string'
+                }
+            }
+        });
+        if (options.useEnterpriseProvider) {
+            const success = await this.handleEnterpriseInstance();
+            if (!success) {
+                this.telemetryService.publicLog2('commandCenter.chatInstall', { installResult: 'failedEnterpriseSetup', installDuration: 0, signUpErrorCode: undefined, provider: undefined });
+                return success;
+            }
+        }
+        let existingAdvancedSetting = this.configurationService.inspect(defaultChat.completionsAdvancedSetting).user?.value;
+        if (!isObject(existingAdvancedSetting)) {
+            existingAdvancedSetting = {};
+        }
+        if (options.useEnterpriseProvider) {
+            await this.configurationService.updateValue(`${defaultChat.completionsAdvancedSetting}`, {
+                ...existingAdvancedSetting,
+                'authProvider': defaultChat.provider.enterprise.id
+            }, ConfigurationTarget.USER);
+        }
+        else {
+            await this.configurationService.updateValue(`${defaultChat.completionsAdvancedSetting}`, ( Object.keys(existingAdvancedSetting)).length > 0 ? {
+                ...existingAdvancedSetting,
+                'authProvider': undefined
+            } : undefined, ConfigurationTarget.USER);
+        }
+        return this.setup({ ...options, forceSignIn: true });
+    }
+    async handleEnterpriseInstance() {
+        const domainRegEx = /^[a-zA-Z\-_]+$/;
+        const fullUriRegEx = /^(https:\/\/)?([a-zA-Z0-9-]+\.)*[a-zA-Z0-9-]+\.ghe\.com\/?$/;
+        const uri = this.configurationService.getValue(defaultChat.providerUriSetting);
+        if (typeof uri === 'string' && fullUriRegEx.test(uri)) {
+            return true;
+        }
+        let isSingleWord = false;
+        const result = await this.quickInputService.input({
+            prompt: ( localize(5541, "What is your {0} instance?", defaultChat.provider.enterprise.name)),
+            placeHolder: ( localize(5542, 'i.e. "octocat" or "https://octocat.ghe.com"...')),
+            ignoreFocusLost: true,
+            value: uri,
+            validateInput: async (value) => {
+                isSingleWord = false;
+                if (!value) {
+                    return undefined;
+                }
+                if (domainRegEx.test(value)) {
+                    isSingleWord = true;
+                    return {
+                        content: ( localize(5543, "Will resolve to {0}", `https://${value}.ghe.com`)),
+                        severity: Severity.Info
+                    };
+                }
+                if (!fullUriRegEx.test(value)) {
+                    return {
+                        content: ( localize(
+                            5544,
+                            'You must enter a valid {0} instance (i.e. "octocat" or "https://octocat.ghe.com")',
+                            defaultChat.provider.enterprise.name
+                        )),
+                        severity: Severity.Error
+                    };
+                }
+                return undefined;
+            }
+        });
+        if (!result) {
+            return undefined;
+        }
+        let resolvedUri = result;
+        if (isSingleWord) {
+            resolvedUri = `https://${resolvedUri}.ghe.com`;
+        }
+        else {
+            const normalizedUri = result.toLowerCase();
+            const hasHttps = normalizedUri.startsWith('https://');
+            if (!hasHttps) {
+                resolvedUri = `https://${result}`;
+            }
+        }
+        await this.configurationService.updateValue(defaultChat.providerUriSetting, resolvedUri, ConfigurationTarget.USER);
+        return true;
+    }
+};
+ChatSetupController = ( __decorate([
+    ( __param(2, ITelemetryService)),
+    ( __param(3, IAuthenticationService)),
+    ( __param(4, IExtensionsWorkbenchService)),
+    ( __param(5, IProductService)),
+    ( __param(6, ILogService)),
+    ( __param(7, IProgressService)),
+    ( __param(8, IActivityService)),
+    ( __param(9, ICommandService)),
+    ( __param(10, IDialogService)),
+    ( __param(11, IConfigurationService)),
+    ( __param(12, ILifecycleService)),
+    ( __param(13, IQuickInputService))
+], ChatSetupController));
+
+export { ChatSetupController };

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

@@ -0,0 +1,89 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Lazy } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lazy";
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+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 { 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 { CountTokensCallback, IPreparedToolInvocation, IToolData, IToolImpl, IToolInvocation, IToolResult, ToolProgress } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService";
+import { IChatAgentImplementation, IChatAgentRequest, IChatAgentResult } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents";
+import { ChatEntitlementContext } 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 { IChatProgress } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService";
+import { ChatAgentLocation, ChatModeKind } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants";
+import { CodeActionList, Command, NewSymbolName, NewSymbolNameTriggerKind } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages";
+import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
+import { IRange, Range } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
+import { Selection } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/selection";
+import { IMarker } 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 { ChatSetupController } from "./chatSetupController.js";
+export declare class SetupAgent extends Disposable implements IChatAgentImplementation {
+    private readonly context;
+    private readonly controller;
+    private readonly location;
+    private readonly instantiationService;
+    private readonly logService;
+    private readonly configurationService;
+    private readonly telemetryService;
+    private readonly environmentService;
+    private readonly workspaceTrustManagementService;
+    private readonly chatEntitlementService;
+    static registerDefaultAgents(instantiationService: IInstantiationService, location: ChatAgentLocation, mode: ChatModeKind | undefined, context: ChatEntitlementContext, controller: Lazy<ChatSetupController>): {
+        agent: SetupAgent;
+        disposable: IDisposable;
+    };
+    static registerBuiltInAgents(instantiationService: IInstantiationService, context: ChatEntitlementContext, controller: Lazy<ChatSetupController>): IDisposable;
+    private static doRegisterAgent;
+    private static readonly SETUP_NEEDED_MESSAGE;
+    private static readonly TRUST_NEEDED_MESSAGE;
+    private readonly _onUnresolvableError;
+    readonly onUnresolvableError: Event<void>;
+    private readonly pendingForwardedRequests;
+    constructor(context: ChatEntitlementContext, controller: Lazy<ChatSetupController>, location: ChatAgentLocation, instantiationService: IInstantiationService, logService: ILogService, configurationService: IConfigurationService, telemetryService: ITelemetryService, environmentService: IWorkbenchEnvironmentService, workspaceTrustManagementService: IWorkspaceTrustManagementService, chatEntitlementService: IChatEntitlementService);
+    invoke(request: IChatAgentRequest, progress: (parts: IChatProgress[]) => void): Promise<IChatAgentResult>;
+    private doInvoke;
+    private doInvokeWithoutSetup;
+    private forwardRequestToChat;
+    private doForwardRequestToChat;
+    private doForwardRequestToChatWhenReady;
+    private whenLanguageModelReady;
+    private whenToolsModelReady;
+    private whenAgentReady;
+    private whenAgentActivated;
+    private doInvokeWithSetup;
+    private replaceAgentInRequestModel;
+    private replaceToolInRequestModel;
+}
+export declare class SetupTool implements IToolImpl {
+    static registerTool(instantiationService: IInstantiationService, toolData: IToolData): IDisposable;
+    invoke(invocation: IToolInvocation, countTokens: CountTokensCallback, progress: ToolProgress, token: CancellationToken): Promise<IToolResult>;
+    prepareToolInvocation?(parameters: unknown, token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;
+}
+export declare class AINewSymbolNamesProvider {
+    private readonly context;
+    private readonly controller;
+    private readonly instantiationService;
+    private readonly chatEntitlementService;
+    static registerProvider(instantiationService: IInstantiationService, context: ChatEntitlementContext, controller: Lazy<ChatSetupController>): IDisposable;
+    constructor(context: ChatEntitlementContext, controller: Lazy<ChatSetupController>, instantiationService: IInstantiationService, chatEntitlementService: IChatEntitlementService);
+    provideNewSymbolNames(model: ITextModel, range: IRange, triggerKind: NewSymbolNameTriggerKind, token: CancellationToken): Promise<NewSymbolName[] | undefined>;
+}
+export declare class ChatCodeActionsProvider {
+    private readonly markerService;
+    static registerProvider(instantiationService: IInstantiationService): IDisposable;
+    constructor(markerService: IMarkerService);
+    provideCodeActions(model: ITextModel, range: Range | Selection): Promise<CodeActionList | undefined>;
+}
+export declare class AICodeActionsHelper {
+    static warningOrErrorMarkersAtRange(markerService: IMarkerService, resource: URI, range: Range | Selection): IMarker[];
+    static modify(range: Range): Command;
+    static generate(range: Range): Command;
+    private static rangeToSelection;
+    static explainMarkers(markers: IMarker[]): Command;
+    static fixMarkers(markers: IMarker[], range: Range): Command;
+}