@codingame/monaco-vscode-chat-service-override 1.85.1

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

@@ -0,0 +1,564 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { CancellationToken, CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { MarkdownString } from 'monaco-editor/esm/vs/base/common/htmlContent.js';
+import { Iterable } from 'monaco-editor/esm/vs/base/common/iterator.js';
+import { Disposable, DisposableMap, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { revive } from 'monaco-editor/esm/vs/base/common/marshalling.js';
+import { StopWatch } from 'monaco-editor/esm/vs/base/common/stopwatch.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { Progress } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { IChatAgentService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents';
+import { CONTEXT_PROVIDER_EXISTS } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
+import { ChatModel, ChatWelcomeMessageModel, ChatModelInitState } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatModel';
+import { ChatRequestAgentPart, ChatRequestAgentSubcommandPart, ChatRequestSlashCommandPart } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatParserTypes';
+import { ChatRequestParser } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatRequestParser';
+import { InteractiveSessionVoteDirection, InteractiveSessionCopyKind } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatService';
+import { IChatSlashCommandService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatSlashCommands';
+import { IChatVariablesService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatVariables';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+
+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) {
+        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._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._onDidSubmitAgent = this._register(( new Emitter()));
+        this.onDidSubmitAgent = this._onDidSubmitAgent.event;
+        this._onDidDisposeSession = this._register(( new Emitter()));
+        this.onDidDisposeSession = this._onDidDisposeSession.event;
+        this._onDidRegisterProvider = this._register(( new Emitter()));
+        this.onDidRegisterProvider = this._onDidRegisterProvider.event;
+        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.copyType === InteractiveSessionCopyKind.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.command.commandId);
+            const commandId = command ? action.action.command.commandId : '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 firstRequestMessage = item.requests[0]?.message;
+            return {
+                sessionId: item.sessionId,
+                title: (typeof firstRequestMessage === 'string' ? firstRequestMessage :
+                    firstRequestMessage?.text) ?? '',
+            };
+        }));
+    }
+    removeHistoryEntry(sessionId) {
+        delete this._persistedSessions[sessionId];
+    }
+    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 Error(`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 welcomeMessage = model.welcomeMessage ? undefined : (await provider.provideWelcomeMessage?.(token)) ?? undefined;
+            const welcomeModel = welcomeMessage && ( new ChatWelcomeMessageModel(model, ( welcomeMessage.map(item => typeof item === 'string' ? ( new MarkdownString(item)) : item)), (await provider.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) {
+        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;
+        }
+        return { responseCompletePromise: this._sendRequestAsync(model, sessionId, provider, request) };
+    }
+    async _sendRequestAsync(model, sessionId, provider, message) {
+        const parsedRequest = await this.instantiationService.createInstance(ChatRequestParser).parseChatRequest(sessionId, message);
+        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 {
+                if (agentPart && agentSlashCommandPart?.command) {
+                    this._onDidSubmitAgent.fire({ agent: agentPart.agent, slashCommand: agentSlashCommandPart.command, sessionId: model.sessionId });
+                }
+                let rawResponse;
+                let agentOrCommandFollowups = undefined;
+                const defaultAgent = this.chatAgentService.getDefaultAgent();
+                if (agentPart || (defaultAgent && !commandPart)) {
+                    const agent = (agentPart?.agent ?? defaultAgent);
+                    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() });
+                    }
+                    request = model.addRequest(parsedRequest, agent);
+                    const requestProps = {
+                        sessionId,
+                        requestId: request.id,
+                        message,
+                        variables: {},
+                        command: agentSlashCommandPart?.command.name ?? '',
+                    };
+                    if ('parts' in parsedRequest) {
+                        const varResult = await this.chatVariablesService.resolveVariables(parsedRequest, model, token);
+                        requestProps.variables = varResult.variables;
+                        requestProps.message = varResult.prompt;
+                    }
+                    const agentResult = await this.chatAgentService.invokeAgent(agent.id, requestProps, progressCallback, history, token);
+                    rawResponse = {
+                        session: model.session,
+                        errorDetails: agentResult.errorDetails,
+                        timings: agentResult.timings
+                    };
+                    agentOrCommandFollowups = agentResult?.followUp ? Promise.resolve(agentResult.followUp) :
+                        this.chatAgentService.getFollowups(agent.id, sessionId, CancellationToken.None);
+                }
+                else if (commandPart && this.chatSlashCommandService.hasCommand(commandPart.slashCommand.command)) {
+                    request = model.addRequest(parsedRequest);
+                    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 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);
+                    rawResponse = { session: model.session };
+                }
+                else {
+                    throw new Error(`Cannot handle request`);
+                }
+                if (token.isCancellationRequested) {
+                    return;
+                }
+                else {
+                    if (!rawResponse) {
+                        this.trace('sendRequest', `Provider returned no response for session ${model.sessionId}`);
+                        rawResponse = { session: model.session, errorDetails: { message: ( localizeWithPath(
+                            'vs/workbench/contrib/chat/common/chatServiceImpl',
+                            'emptyResponse',
+                            "Provider returned null response"
+                        )) } };
+                    }
+                    const result = rawResponse.errorDetails?.responseIsFiltered ? 'filtered' :
+                        rawResponse.errorDetails && gotProgress ? 'errorWithOutput' :
+                            rawResponse.errorDetails ? 'error' :
+                                'success';
+                    this.telemetryService.publicLog2('interactiveSessionProviderInvoked', {
+                        providerId: provider.id,
+                        timeToFirstProgress: rawResponse.timings?.firstProgress,
+                        totalTime: rawResponse.timings?.totalElapsed,
+                        result,
+                        requestType,
+                        agent: agentPart?.agent.id ?? '',
+                        slashCommand: agentSlashCommandPart ? agentSlashCommandPart.command.name : commandPart?.slashCommand.command,
+                        chatSessionId: model.sessionId
+                    });
+                    model.setResponse(request, rawResponse);
+                    this.trace('sendRequest', `Provider returned response for session ${model.sessionId}`);
+                    if (agentOrCommandFollowups) {
+                        agentOrCommandFollowups.then(followups => {
+                            model.setFollowups(request, followups);
+                            model.completeResponse(request, rawResponse?.errorDetails);
+                        });
+                    }
+                    else {
+                        model.completeResponse(request, rawResponse?.errorDetails);
+                    }
+                }
+            }
+            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);
+    }
+    async sendRequestToProvider(sessionId, message) {
+        this.trace('sendRequestToProvider', `sessionId: ${sessionId}`);
+        return await this.sendRequest(sessionId, message.message);
+    }
+    getProviders() {
+        return Array.from(( this._providers.keys()));
+    }
+    async addCompleteRequest(sessionId, message, 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' ?
+            await this.instantiationService.createInstance(ChatRequestParser).parseChatRequest(sessionId, message) :
+            message;
+        const request = model.addRequest(parsedRequest);
+        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, {
+            session: model.session,
+            errorDetails: response.errorDetails,
+        });
+        if (response.followups !== undefined) {
+            model.setFollowups(request, response.followups);
+        }
+        model.completeResponse(request, response.errorDetails);
+    }
+    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());
+        });
+    }
+    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,
+                displayName: provider.displayName
+            };
+        }));
+    }
+    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))
+], ChatService));
+
+export { ChatService };

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChat.contribution.js

@@ -0,0 +1,41 @@
+import { registerAction2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { registerEditorContribution } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
+import { InlineChatController } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatController';
+import { InlineAccessibilityHelpContribution, StartSessionAction, UnstashSessionAction, MakeRequestAction, StopRequestAction, ReRunRequestAction, DiscardAction, DiscardToClipboardAction, DiscardUndoToNewFileAction, CancelSessionAction, ArrowOutUpAction, ArrowOutDownAction, FocusInlineChat, PreviousFromHistory, NextFromHistory, ViewInChatAction, ExpandMessageAction, ContractMessageAction, ToggleInlineDiff, ToggleDiffForChange, FeebackHelpfulCommand, FeebackUnhelpfulCommand, ReportIssueForBugCommand, ApplyPreviewEdits, CopyRecordings } from './inlineChatActions.js';
+import { INLINE_CHAT_ID, INTERACTIVE_EDITOR_ACCESSIBILITY_HELP_ID, INLINE_CHAT_DECORATIONS_ID } from 'vscode/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { InlineChatNotebookContribution } from './inlineChatNotebook.js';
+import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
+import { InlineChatAccessibleViewContribution } from './inlineChatAccessibleView.js';
+import { InlineChatDecorationsContribution } from './inlineChatDecorations.js';
+
+registerEditorContribution(INLINE_CHAT_ID, InlineChatController, 0 );
+registerEditorContribution(INTERACTIVE_EDITOR_ACCESSIBILITY_HELP_ID, InlineAccessibilityHelpContribution, 3 );
+registerEditorContribution(INLINE_CHAT_DECORATIONS_ID, InlineChatDecorationsContribution, 1 );
+registerAction2(StartSessionAction);
+registerAction2(UnstashSessionAction);
+registerAction2(MakeRequestAction);
+registerAction2(StopRequestAction);
+registerAction2(ReRunRequestAction);
+registerAction2(DiscardAction);
+registerAction2(DiscardToClipboardAction);
+registerAction2(DiscardUndoToNewFileAction);
+registerAction2(CancelSessionAction);
+registerAction2(ArrowOutUpAction);
+registerAction2(ArrowOutDownAction);
+registerAction2(FocusInlineChat);
+registerAction2(PreviousFromHistory);
+registerAction2(NextFromHistory);
+registerAction2(ViewInChatAction);
+registerAction2(ExpandMessageAction);
+registerAction2(ContractMessageAction);
+registerAction2(ToggleInlineDiff);
+registerAction2(ToggleDiffForChange);
+registerAction2(FeebackHelpfulCommand);
+registerAction2(FeebackUnhelpfulCommand);
+registerAction2(ReportIssueForBugCommand);
+registerAction2(ApplyPreviewEdits);
+registerAction2(CopyRecordings);
+const workbenchContributionsRegistry = ( Registry.as(Extensions.Workbench));
+workbenchContributionsRegistry.registerWorkbenchContribution(InlineChatNotebookContribution, 3 );
+workbenchContributionsRegistry.registerWorkbenchContribution(InlineChatAccessibleViewContribution, 4 );

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatAccessibleView.js

@@ -0,0 +1,41 @@
+import { InlineChatController } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatController';
+import { CTX_INLINE_CHAT_FOCUSED, CTX_INLINE_CHAT_RESPONSE_FOCUSED } from 'vscode/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
+import { IAccessibleViewService } from 'vscode/vscode/vs/workbench/contrib/accessibility/browser/accessibleView';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
+import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { AccessibleViewAction } from 'vscode/vscode/vs/workbench/contrib/accessibility/browser/accessibleViewActions';
+
+class InlineChatAccessibleViewContribution extends Disposable {
+    constructor() {
+        super();
+        this._register(AccessibleViewAction.addImplementation(100, 'inlineChat', accessor => {
+            const accessibleViewService = accessor.get(IAccessibleViewService);
+            const codeEditorService = accessor.get(ICodeEditorService);
+            const editor = (codeEditorService.getActiveCodeEditor() || codeEditorService.getFocusedCodeEditor());
+            if (!editor) {
+                return false;
+            }
+            const controller = InlineChatController.get(editor);
+            if (!controller) {
+                return false;
+            }
+            const responseContent = controller?.getMessage();
+            if (!responseContent) {
+                return false;
+            }
+            accessibleViewService.show({
+                id: "inlineChat" ,
+                verbositySettingKey: "accessibility.verbosity.inlineChat" ,
+                provideContent() { return responseContent; },
+                onClose() {
+                    controller.focus();
+                },
+                options: { type: "view"  }
+            });
+            return true;
+        }, ( ContextKeyExpr.or(CTX_INLINE_CHAT_FOCUSED, CTX_INLINE_CHAT_RESPONSE_FOCUSED))));
+    }
+}
+
+export { InlineChatAccessibleViewContribution };