@codingame/monaco-vscode-api 4.1.0 → 4.1.2

package/vscode/src/vs/workbench/contrib/chat/common/chatServiceImpl.js

@@ -1,598 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Action } from '../../../../base/common/actions.js';
-import { CancellationToken, CancellationTokenSource } from '../../../../base/common/cancellation.js';
-import { ErrorNoTelemetry } from '../../../../base/common/errors.js';
-import { Emitter } from '../../../../base/common/event.js';
-import { MarkdownString } from '../../../../base/common/htmlContent.js';
-import { Iterable } from '../../../../base/common/iterator.js';
-import { Disposable, DisposableMap, toDisposable } from '../../../../base/common/lifecycle.js';
-import { revive } from '../../../../base/common/marshalling.js';
-import { StopWatch } from '../../../../base/common/stopwatch.js';
-import { URI } from '../../../../base/common/uri.js';
-import { localizeWithPath } from '../../../../nls.js';
-import { CommandsRegistry, ICommandService } from '../../../../platform/commands/common/commands.js';
-import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
-import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
-import { ILogService } from '../../../../platform/log/common/log.js';
-import { Severity, INotificationService } from '../../../../platform/notification/common/notification.js';
-import { Progress } from '../../../../platform/progress/common/progress.js';
-import { IStorageService } from '../../../../platform/storage/common/storage.js';
-import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.js';
-import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
-import { ChatAgentLocation, IChatAgentService } from './chatAgents.js';
-import { CONTEXT_PROVIDER_EXISTS } from './chatContextKeys.js';
-import { ChatModel, ChatWelcomeMessageModel, ChatModelInitState, getHistoryEntriesFromModel, updateRanges } from './chatModel.js';
-import { ChatRequestAgentPart, ChatRequestAgentSubcommandPart, ChatRequestSlashCommandPart, getPromptText } from './chatParserTypes.js';
-import { ChatRequestParser } from './chatRequestParser.js';
-import { InteractiveSessionVoteDirection, ChatCopyKind } from './chatService.js';
-import { IChatSlashCommandService } from './chatSlashCommands.js';
-import { IChatVariablesService } from './chatVariables.js';
-import { IExtensionService } from '../../../services/extensions/common/extensions.js';
-const serializedChatKey = 'interactive.sessions';
-const globalChatKey = 'chat.workspaceTransfer';
-const SESSION_TRANSFER_EXPIRATION_IN_MILLISECONDS = 1000 * 60;
-const maxPersistedSessions = 25;
-let ChatService = class ChatService extends Disposable {
-    get transferredSessionData() {
-        return this._transferredSessionData;
-    }
-    constructor(storageService, logService, extensionService, instantiationService, telemetryService, contextKeyService, workspaceContextService, chatSlashCommandService, chatVariablesService, chatAgentService, notificationService, commandService) {
-        super();
-        this.storageService = storageService;
-        this.logService = logService;
-        this.extensionService = extensionService;
-        this.instantiationService = instantiationService;
-        this.telemetryService = telemetryService;
-        this.contextKeyService = contextKeyService;
-        this.workspaceContextService = workspaceContextService;
-        this.chatSlashCommandService = chatSlashCommandService;
-        this.chatVariablesService = chatVariablesService;
-        this.chatAgentService = chatAgentService;
-        this.notificationService = notificationService;
-        this.commandService = commandService;
-        this._providers = ( new Map());
-        this._sessionModels = this._register(( new DisposableMap()));
-        this._pendingRequests = this._register(( new DisposableMap()));
-        this._onDidPerformUserAction = this._register(( new Emitter()));
-        this.onDidPerformUserAction = this._onDidPerformUserAction.event;
-        this._onDidDisposeSession = this._register(( new Emitter()));
-        this.onDidDisposeSession = this._onDidDisposeSession.event;
-        this._onDidRegisterProvider = this._register(( new Emitter()));
-        this.onDidRegisterProvider = this._onDidRegisterProvider.event;
-        this._onDidUnregisterProvider = this._register(( new Emitter()));
-        this.onDidUnregisterProvider = this._onDidUnregisterProvider.event;
-        this._sessionFollowupCancelTokens = this._register(( new DisposableMap()));
-        this._hasProvider = CONTEXT_PROVIDER_EXISTS.bindTo(this.contextKeyService);
-        const sessionData = storageService.get(serializedChatKey, 1 , '');
-        if (sessionData) {
-            this._persistedSessions = this.deserializeChats(sessionData);
-            const countsForLog = ( Object.keys(this._persistedSessions)).length;
-            if (countsForLog > 0) {
-                this.trace('constructor', `Restored ${countsForLog} persisted sessions`);
-            }
-        }
-        else {
-            this._persistedSessions = {};
-        }
-        const transferredData = this.getTransferredSessionData();
-        const transferredChat = transferredData?.chat;
-        if (transferredChat) {
-            this.trace('constructor', `Transferred session ${transferredChat.sessionId}`);
-            this._persistedSessions[transferredChat.sessionId] = transferredChat;
-            this._transferredSessionData = { sessionId: transferredChat.sessionId, inputValue: transferredData.inputValue };
-        }
-        this._register(storageService.onWillSaveState(() => this.saveState()));
-    }
-    saveState() {
-        let allSessions = Array.from(( this._sessionModels.values()))
-            .filter(session => session.getRequests().length > 0);
-        allSessions = allSessions.concat(( Object.values(this._persistedSessions))
-            .filter(session => !( this._sessionModels.has(session.sessionId)))
-            .filter(session => session.requests.length));
-        allSessions.sort((a, b) => (b.creationDate ?? 0) - (a.creationDate ?? 0));
-        allSessions = allSessions.slice(0, maxPersistedSessions);
-        if (allSessions.length) {
-            this.trace('onWillSaveState', `Persisting ${allSessions.length} sessions`);
-        }
-        const serialized = JSON.stringify(allSessions);
-        if (allSessions.length) {
-            this.trace('onWillSaveState', `Persisting ${serialized.length} chars`);
-        }
-        this.storageService.store(serializedChatKey, serialized, 1 , 1 );
-    }
-    notifyUserAction(action) {
-        if (action.action.kind === 'vote') {
-            this.telemetryService.publicLog2('interactiveSessionVote', {
-                providerId: action.providerId,
-                direction: action.action.direction === InteractiveSessionVoteDirection.Up ? 'up' : 'down'
-            });
-        }
-        else if (action.action.kind === 'copy') {
-            this.telemetryService.publicLog2('interactiveSessionCopy', {
-                providerId: action.providerId,
-                copyKind: action.action.copyKind === ChatCopyKind.Action ? 'action' : 'toolbar'
-            });
-        }
-        else if (action.action.kind === 'insert') {
-            this.telemetryService.publicLog2('interactiveSessionInsert', {
-                providerId: action.providerId,
-                newFile: !!action.action.newFile
-            });
-        }
-        else if (action.action.kind === 'command') {
-            const command = CommandsRegistry.getCommand(action.action.commandButton.command.id);
-            const commandId = command ? action.action.commandButton.command.id : 'INVALID';
-            this.telemetryService.publicLog2('interactiveSessionCommand', {
-                providerId: action.providerId,
-                commandId
-            });
-        }
-        else if (action.action.kind === 'runInTerminal') {
-            this.telemetryService.publicLog2('interactiveSessionRunInTerminal', {
-                providerId: action.providerId,
-                languageId: action.action.languageId ?? ''
-            });
-        }
-        this._onDidPerformUserAction.fire(action);
-    }
-    trace(method, message) {
-        this.logService.trace(`ChatService#${method}: ${message}`);
-    }
-    error(method, message) {
-        this.logService.error(`ChatService#${method} ${message}`);
-    }
-    deserializeChats(sessionData) {
-        try {
-            const arrayOfSessions = revive(JSON.parse(sessionData));
-            if (!Array.isArray(arrayOfSessions)) {
-                throw new Error('Expected array');
-            }
-            const sessions = arrayOfSessions.reduce((acc, session) => {
-                for (const request of session.requests) {
-                    if (Array.isArray(request.response)) {
-                        request.response = ( request.response.map((response) => {
-                            if (typeof response === 'string') {
-                                return ( new MarkdownString(response));
-                            }
-                            return response;
-                        }));
-                    }
-                    else if (typeof request.response === 'string') {
-                        request.response = [( new MarkdownString(request.response))];
-                    }
-                }
-                acc[session.sessionId] = session;
-                return acc;
-            }, {});
-            return sessions;
-        }
-        catch (err) {
-            this.error('deserializeChats', `Malformed session data: ${err}. [${sessionData.substring(0, 20)}${sessionData.length > 20 ? '...' : ''}]`);
-            return {};
-        }
-    }
-    getTransferredSessionData() {
-        const data = this.storageService.getObject(globalChatKey, 0 , []);
-        const workspaceUri = this.workspaceContextService.getWorkspace().folders[0]?.uri;
-        if (!workspaceUri) {
-            return;
-        }
-        const thisWorkspace = ( workspaceUri.toString());
-        const currentTime = Date.now();
-        const transferred = data.find(item => ( URI.revive(item.toWorkspace).toString()) === thisWorkspace && (currentTime - item.timestampInMilliseconds < SESSION_TRANSFER_EXPIRATION_IN_MILLISECONDS));
-        const filtered = data.filter(item => ( URI.revive(item.toWorkspace).toString()) !== thisWorkspace && (currentTime - item.timestampInMilliseconds < SESSION_TRANSFER_EXPIRATION_IN_MILLISECONDS));
-        this.storageService.store(globalChatKey, JSON.stringify(filtered), 0 , 1 );
-        return transferred;
-    }
-    getHistory() {
-        const sessions = ( Object.values(this._persistedSessions))
-            .filter(session => session.requests.length > 0);
-        sessions.sort((a, b) => (b.creationDate ?? 0) - (a.creationDate ?? 0));
-        return ( sessions
-            .filter(session => !( this._sessionModels.has(session.sessionId)))
-            .filter(session => !session.isImported)
-            .map(item => {
-            const title = ChatModel.getDefaultTitle(item.requests);
-            return {
-                sessionId: item.sessionId,
-                title
-            };
-        }));
-    }
-    removeHistoryEntry(sessionId) {
-        delete this._persistedSessions[sessionId];
-        this.saveState();
-    }
-    clearAllHistoryEntries() {
-        this._persistedSessions = {};
-        this.saveState();
-    }
-    startSession(providerId, token) {
-        this.trace('startSession', `providerId=${providerId}`);
-        return this._startSession(providerId, undefined, token);
-    }
-    _startSession(providerId, someSessionHistory, token) {
-        this.trace('_startSession', `providerId=${providerId}`);
-        const model = this.instantiationService.createInstance(ChatModel, providerId, someSessionHistory);
-        this._sessionModels.set(model.sessionId, model);
-        this.initializeSession(model, token);
-        return model;
-    }
-    reinitializeModel(model) {
-        this.trace('reinitializeModel', `Start reinit`);
-        this.initializeSession(model, CancellationToken.None);
-    }
-    async initializeSession(model, token) {
-        try {
-            this.trace('initializeSession', `Initialize session ${model.sessionId}`);
-            model.startInitialize();
-            await this.extensionService.activateByEvent(`onInteractiveSession:${model.providerId}`);
-            const provider = this._providers.get(model.providerId);
-            if (!provider) {
-                throw new ErrorNoTelemetry(`Unknown provider: ${model.providerId}`);
-            }
-            let session;
-            try {
-                session = (await provider.prepareSession(token)) ?? undefined;
-            }
-            catch (err) {
-                this.trace('initializeSession', `Provider initializeSession threw: ${err}`);
-            }
-            if (!session) {
-                throw new Error('Provider returned no session');
-            }
-            this.trace('startSession', `Provider returned session`);
-            const defaultAgent = this.chatAgentService.getDefaultAgent(ChatAgentLocation.Panel);
-            if (!defaultAgent) {
-                this.notificationService.notify({
-                    severity: Severity.Error,
-                    message: ( localizeWithPath(
-                        'vs/workbench/contrib/chat/common/chatServiceImpl',
-                        'chatFailErrorMessage',
-                        "Chat failed to load. Please ensure that the GitHub Copilot Chat extension is up to date."
-                    )),
-                    actions: {
-                        primary: [
-                            ( new Action('showExtension', ( localizeWithPath(
-                                'vs/workbench/contrib/chat/common/chatServiceImpl',
-                                'action.showExtension',
-                                "Show Extension"
-                            )), undefined, true, () => {
-                                return this.commandService.executeCommand('workbench.extensions.action.showExtensionsWithIds', ['GitHub.copilot-chat']);
-                            }))
-                        ]
-                    }
-                });
-                throw new ErrorNoTelemetry('No default agent');
-            }
-            const welcomeMessage = model.welcomeMessage ? undefined : (await defaultAgent.provideWelcomeMessage?.(token)) ?? undefined;
-            const welcomeModel = welcomeMessage && this.instantiationService.createInstance(ChatWelcomeMessageModel, ( welcomeMessage.map(item => typeof item === 'string' ? ( new MarkdownString(item)) : item)), (await defaultAgent.provideSampleQuestions?.(token)) ?? []);
-            model.initialize(session, welcomeModel);
-        }
-        catch (err) {
-            this.trace('startSession', `initializeSession failed: ${err}`);
-            model.setInitializationError(err);
-            this._sessionModels.deleteAndDispose(model.sessionId);
-            this._onDidDisposeSession.fire({ sessionId: model.sessionId, providerId: model.providerId, reason: 'initializationFailed' });
-        }
-    }
-    getSession(sessionId) {
-        return this._sessionModels.get(sessionId);
-    }
-    getSessionId(sessionProviderId) {
-        return Iterable.find(( this._sessionModels.values()), model => model.session?.id === sessionProviderId)?.sessionId;
-    }
-    getOrRestoreSession(sessionId) {
-        this.trace('getOrRestoreSession', `sessionId: ${sessionId}`);
-        const model = this._sessionModels.get(sessionId);
-        if (model) {
-            return model;
-        }
-        const sessionData = this._persistedSessions[sessionId];
-        if (!sessionData) {
-            return undefined;
-        }
-        if (sessionId === this.transferredSessionData?.sessionId) {
-            this._transferredSessionData = undefined;
-        }
-        return this._startSession(sessionData.providerId, sessionData, CancellationToken.None);
-    }
-    loadSessionFromContent(data) {
-        return this._startSession(data.providerId, data, CancellationToken.None);
-    }
-    async sendRequest(sessionId, request, implicitVariablesEnabled, location = ChatAgentLocation.Panel, parserContext) {
-        this.trace('sendRequest', `sessionId: ${sessionId}, message: ${request.substring(0, 20)}${request.length > 20 ? '[...]' : ''}}`);
-        if (!request.trim()) {
-            this.trace('sendRequest', 'Rejected empty message');
-            return;
-        }
-        const model = this._sessionModels.get(sessionId);
-        if (!model) {
-            throw new Error(`Unknown session: ${sessionId}`);
-        }
-        await model.waitForInitialization();
-        const provider = this._providers.get(model.providerId);
-        if (!provider) {
-            throw new Error(`Unknown provider: ${model.providerId}`);
-        }
-        if (( this._pendingRequests.has(sessionId))) {
-            this.trace('sendRequest', `Session ${sessionId} already has a pending request`);
-            return;
-        }
-        const defaultAgent = this.chatAgentService.getDefaultAgent(location);
-        const parsedRequest = this.instantiationService.createInstance(ChatRequestParser).parseChatRequest(sessionId, request, location, parserContext);
-        const agent = parsedRequest.parts.find((r) => r instanceof ChatRequestAgentPart)?.agent ?? defaultAgent;
-        const agentSlashCommandPart = parsedRequest.parts.find((r) => r instanceof ChatRequestAgentSubcommandPart);
-        return {
-            responseCompletePromise: this._sendRequestAsync(model, sessionId, provider, parsedRequest, implicitVariablesEnabled ?? false, defaultAgent, location),
-            agent,
-            slashCommand: agentSlashCommandPart?.command,
-        };
-    }
-    refreshFollowupsCancellationToken(sessionId) {
-        this._sessionFollowupCancelTokens.get(sessionId)?.cancel();
-        const newTokenSource = ( new CancellationTokenSource());
-        this._sessionFollowupCancelTokens.set(sessionId, newTokenSource);
-        return newTokenSource.token;
-    }
-    async _sendRequestAsync(model, sessionId, provider, parsedRequest, implicitVariablesEnabled, defaultAgent, location) {
-        const followupsCancelToken = this.refreshFollowupsCancellationToken(sessionId);
-        let request;
-        const agentPart = 'kind' in parsedRequest ? undefined : parsedRequest.parts.find((r) => r instanceof ChatRequestAgentPart);
-        const agentSlashCommandPart = 'kind' in parsedRequest ? undefined : parsedRequest.parts.find((r) => r instanceof ChatRequestAgentSubcommandPart);
-        const commandPart = 'kind' in parsedRequest ? undefined : parsedRequest.parts.find((r) => r instanceof ChatRequestSlashCommandPart);
-        let gotProgress = false;
-        const requestType = commandPart ? 'slashCommand' : 'string';
-        const source = ( new CancellationTokenSource());
-        const token = source.token;
-        const sendRequestInternal = async () => {
-            const progressCallback = (progress) => {
-                if (token.isCancellationRequested) {
-                    return;
-                }
-                gotProgress = true;
-                if (progress.kind === 'content' || progress.kind === 'markdownContent') {
-                    this.trace('sendRequest', `Provider returned progress for session ${model.sessionId}, ${typeof progress.content === 'string' ? progress.content.length : progress.content.value.length} chars`);
-                }
-                else {
-                    this.trace('sendRequest', `Provider returned progress: ${JSON.stringify(progress)}`);
-                }
-                model.acceptResponseProgress(request, progress);
-            };
-            const stopWatch = ( new StopWatch(false));
-            const listener = token.onCancellationRequested(() => {
-                this.trace('sendRequest', `Request for session ${model.sessionId} was cancelled`);
-                this.telemetryService.publicLog2('interactiveSessionProviderInvoked', {
-                    providerId: provider.id,
-                    timeToFirstProgress: undefined,
-                    totalTime: stopWatch.elapsed(),
-                    result: 'cancelled',
-                    requestType,
-                    agent: agentPart?.agent.id ?? '',
-                    slashCommand: agentSlashCommandPart ? agentSlashCommandPart.command.name : commandPart?.slashCommand.command,
-                    chatSessionId: model.sessionId
-                });
-                model.cancelRequest(request);
-            });
-            try {
-                let rawResult;
-                let agentOrCommandFollowups = undefined;
-                if (agentPart || (defaultAgent && !commandPart)) {
-                    const agent = (agentPart?.agent ?? defaultAgent);
-                    await this.extensionService.activateByEvent(`onChatParticipant:${agent.id}`);
-                    const history = getHistoryEntriesFromModel(model);
-                    const initVariableData = { variables: [] };
-                    request = model.addRequest(parsedRequest, initVariableData, agent, agentSlashCommandPart?.command);
-                    const variableData = await this.chatVariablesService.resolveVariables(parsedRequest, model, progressCallback, token);
-                    request.variableData = variableData;
-                    const promptTextResult = getPromptText(request.message);
-                    const updatedVariableData = updateRanges(variableData, promptTextResult.diff);
-                    if (implicitVariablesEnabled) {
-                        const implicitVariables = agent.defaultImplicitVariables;
-                        if (implicitVariables) {
-                            const resolvedImplicitVariables = await Promise.all(( implicitVariables.map(
-                                async (v) => ({ name: v, values: await this.chatVariablesService.resolveVariable(v, parsedRequest.text, model, progressCallback, token) })
-                            )));
-                            updatedVariableData.variables.push(...resolvedImplicitVariables);
-                        }
-                    }
-                    const requestProps = {
-                        sessionId,
-                        requestId: request.id,
-                        agentId: agent.id,
-                        message: promptTextResult.message,
-                        command: agentSlashCommandPart?.command.name,
-                        variables: updatedVariableData,
-                        location
-                    };
-                    const agentResult = await this.chatAgentService.invokeAgent(agent.id, requestProps, progressCallback, history, token);
-                    rawResult = agentResult;
-                    agentOrCommandFollowups = this.chatAgentService.getFollowups(agent.id, requestProps, agentResult, history, followupsCancelToken);
-                }
-                else if (commandPart && this.chatSlashCommandService.hasCommand(commandPart.slashCommand.command)) {
-                    request = model.addRequest(parsedRequest, { variables: [] });
-                    const history = [];
-                    for (const request of model.getRequests()) {
-                        if (!request.response) {
-                            continue;
-                        }
-                        history.push({ role: 1 , content: request.message.text });
-                        history.push({ role: 2 , content: request.response.response.asString() });
-                    }
-                    const message = parsedRequest.text;
-                    const commandResult = await this.chatSlashCommandService.executeCommand(commandPart.slashCommand.command, message.substring(commandPart.slashCommand.command.length + 1).trimStart(), ( new Progress(p => {
-                        progressCallback(p);
-                    })), history, token);
-                    agentOrCommandFollowups = Promise.resolve(commandResult?.followUp);
-                    rawResult = {};
-                }
-                else {
-                    throw new Error(`Cannot handle request`);
-                }
-                if (token.isCancellationRequested) {
-                    return;
-                }
-                else {
-                    if (!rawResult) {
-                        this.trace('sendRequest', `Provider returned no response for session ${model.sessionId}`);
-                        rawResult = { errorDetails: { message: ( localizeWithPath(
-                            'vs/workbench/contrib/chat/common/chatServiceImpl',
-                            'emptyResponse',
-                            "Provider returned null response"
-                        )) } };
-                    }
-                    const result = rawResult.errorDetails?.responseIsFiltered ? 'filtered' :
-                        rawResult.errorDetails && gotProgress ? 'errorWithOutput' :
-                            rawResult.errorDetails ? 'error' :
-                                'success';
-                    this.telemetryService.publicLog2('interactiveSessionProviderInvoked', {
-                        providerId: provider.id,
-                        timeToFirstProgress: rawResult.timings?.firstProgress,
-                        totalTime: rawResult.timings?.totalElapsed,
-                        result,
-                        requestType,
-                        agent: agentPart?.agent.id ?? '',
-                        slashCommand: agentSlashCommandPart ? agentSlashCommandPart.command.name : commandPart?.slashCommand.command,
-                        chatSessionId: model.sessionId
-                    });
-                    model.setResponse(request, rawResult);
-                    this.trace('sendRequest', `Provider returned response for session ${model.sessionId}`);
-                    model.completeResponse(request);
-                    if (agentOrCommandFollowups) {
-                        agentOrCommandFollowups.then(followups => {
-                            model.setFollowups(request, followups);
-                        });
-                    }
-                }
-            }
-            finally {
-                listener.dispose();
-            }
-        };
-        const rawResponsePromise = sendRequestInternal();
-        this._pendingRequests.set(model.sessionId, source);
-        rawResponsePromise.finally(() => {
-            this._pendingRequests.deleteAndDispose(model.sessionId);
-        });
-        return rawResponsePromise;
-    }
-    async removeRequest(sessionId, requestId) {
-        const model = this._sessionModels.get(sessionId);
-        if (!model) {
-            throw new Error(`Unknown session: ${sessionId}`);
-        }
-        await model.waitForInitialization();
-        const provider = this._providers.get(model.providerId);
-        if (!provider) {
-            throw new Error(`Unknown provider: ${model.providerId}`);
-        }
-        model.removeRequest(requestId);
-    }
-    getProviders() {
-        return Array.from(( this._providers.keys()));
-    }
-    async addCompleteRequest(sessionId, message, variableData, response) {
-        this.trace('addCompleteRequest', `message: ${message}`);
-        const model = this._sessionModels.get(sessionId);
-        if (!model) {
-            throw new Error(`Unknown session: ${sessionId}`);
-        }
-        await model.waitForInitialization();
-        const parsedRequest = typeof message === 'string' ?
-            this.instantiationService.createInstance(ChatRequestParser).parseChatRequest(sessionId, message) :
-            message;
-        const request = model.addRequest(parsedRequest, variableData || { variables: [] });
-        if (typeof response.message === 'string') {
-            model.acceptResponseProgress(request, { content: response.message, kind: 'content' });
-        }
-        else {
-            for (const part of response.message) {
-                model.acceptResponseProgress(request, part, true);
-            }
-        }
-        model.setResponse(request, response.result || {});
-        if (response.followups !== undefined) {
-            model.setFollowups(request, response.followups);
-        }
-        model.completeResponse(request);
-    }
-    cancelCurrentRequestForSession(sessionId) {
-        this.trace('cancelCurrentRequestForSession', `sessionId: ${sessionId}`);
-        this._pendingRequests.get(sessionId)?.cancel();
-        this._pendingRequests.deleteAndDispose(sessionId);
-    }
-    clearSession(sessionId) {
-        this.trace('clearSession', `sessionId: ${sessionId}`);
-        const model = this._sessionModels.get(sessionId);
-        if (!model) {
-            throw new Error(`Unknown session: ${sessionId}`);
-        }
-        this._persistedSessions[sessionId] = model.toJSON();
-        this._sessionModels.deleteAndDispose(sessionId);
-        this._pendingRequests.get(sessionId)?.cancel();
-        this._pendingRequests.deleteAndDispose(sessionId);
-        this._onDidDisposeSession.fire({ sessionId, providerId: model.providerId, reason: 'cleared' });
-    }
-    registerProvider(provider) {
-        this.trace('registerProvider', `Adding new chat provider`);
-        if (( this._providers.has(provider.id))) {
-            throw new Error(`Provider ${provider.id} already registered`);
-        }
-        this._providers.set(provider.id, provider);
-        this._hasProvider.set(true);
-        this._onDidRegisterProvider.fire({ providerId: provider.id });
-        Array.from(( this._sessionModels.values()))
-            .filter(model => model.providerId === provider.id)
-            .filter(model => model.initState === ChatModelInitState.Created)
-            .forEach(model => this.reinitializeModel(model));
-        return toDisposable(() => {
-            this.trace('registerProvider', `Disposing chat provider`);
-            this._providers.delete(provider.id);
-            this._hasProvider.set(this._providers.size > 0);
-            Array.from(( this._sessionModels.values()))
-                .filter(model => model.providerId === provider.id)
-                .forEach(model => model.deinitialize());
-            this._onDidUnregisterProvider.fire({ providerId: provider.id });
-        });
-    }
-    hasSessions(providerId) {
-        return !!( Object.values(this._persistedSessions)).find((session) => session.providerId === providerId);
-    }
-    getProviderInfos() {
-        return ( Array.from(( this._providers.values())).map(provider => {
-            return {
-                id: provider.id,
-            };
-        }));
-    }
-    transferChatSession(transferredSessionData, toWorkspace) {
-        const model = Iterable.find(( this._sessionModels.values()), model => model.sessionId === transferredSessionData.sessionId);
-        if (!model) {
-            throw new Error(`Failed to transfer session. Unknown session ID: ${transferredSessionData.sessionId}`);
-        }
-        const existingRaw = this.storageService.getObject(globalChatKey, 0 , []);
-        existingRaw.push({
-            chat: model.toJSON(),
-            timestampInMilliseconds: Date.now(),
-            toWorkspace: toWorkspace,
-            inputValue: transferredSessionData.inputValue,
-        });
-        this.storageService.store(globalChatKey, JSON.stringify(existingRaw), 0 , 1 );
-        this.trace('transferChatSession', `Transferred session ${model.sessionId} to workspace ${( toWorkspace.toString())}`);
-    }
-};
-ChatService = ( __decorate([
-    ( __param(0, IStorageService)),
-    ( __param(1, ILogService)),
-    ( __param(2, IExtensionService)),
-    ( __param(3, IInstantiationService)),
-    ( __param(4, ITelemetryService)),
-    ( __param(5, IContextKeyService)),
-    ( __param(6, IWorkspaceContextService)),
-    ( __param(7, IChatSlashCommandService)),
-    ( __param(8, IChatVariablesService)),
-    ( __param(9, IChatAgentService)),
-    ( __param(10, INotificationService)),
-    ( __param(11, ICommandService))
-], ChatService));
-export { ChatService };