@codingame/monaco-vscode-api 23.3.0 → 24.1.0

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

@@ -0,0 +1,1449 @@
+
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { asArray } from '../../../../base/common/arrays.js';
+import { BugIndicatingError } from '../../../../base/common/errors.js';
+import { encodeHex, VSBuffer, decodeHex } from '../../../../base/common/buffer.js';
+import { Emitter } from '../../../../base/common/event.js';
+import { MarkdownString, isMarkdownString } from '../../../../base/common/htmlContent.js';
+import { Disposable, MutableDisposable } from '../../../../base/common/lifecycle.js';
+import { ResourceMap } from '../../../../base/common/map.js';
+import { revive } from '../../../../base/common/marshalling.js';
+import { Schemas } from '../../../../base/common/network.js';
+import { equals } from '../../../../base/common/objects.js';
+import '../../../../base/common/observableInternal/index.js';
+import { basename, isEqual } from '../../../../base/common/resources.js';
+import { URI, isUriComponents } from '../../../../base/common/uri.js';
+import { generateUuid } from '../../../../base/common/uuid.js';
+import { OffsetRange } from '../../../../editor/common/core/ranges/offsetRange.js';
+import { TextEdit } from '../../../../editor/common/languages.js';
+import { localize } from '../../../../nls.js';
+import { ILogService } from '../../../../platform/log/common/log.service.js';
+import { CellUri } from '../../notebook/common/notebookCommon.js';
+import { migrateLegacyTerminalToolSpecificData } from './chat.js';
+import { reviveSerializedAgent } from './chatAgents.js';
+import { IChatAgentService } from './chatAgents.service.js';
+import { editEntriesToMultiDiffData, ModifiedFileEntryState } from './chatEditingService.js';
+import { IChatEditingService } from './chatEditingService.service.js';
+import { reviveParsedChatRequest, ChatRequestTextPart } from './chatParserTypes.js';
+import { IChatToolInvocation, ChatResponseClearToPreviousToolInvocationReason, ResponseModelState, ElicitationState, isIUsedContext } from './chatService.js';
+import { IChatService } from './chatService.service.js';
+import { LocalChatSessionUri } from './chatUri.js';
+import { ChatAgentLocation, ChatModeKind } from './constants.js';
+import { observableFromEvent } from '../../../../base/common/observableInternal/observables/observableFromEvent.js';
+import { autorunSelfDisposable, autorun } from '../../../../base/common/observableInternal/reactions/autorun.js';
+import { observableValueOpts } from '../../../../base/common/observableInternal/observables/observableValueOpts.js';
+import { observableValue } from '../../../../base/common/observableInternal/observables/observableValue.js';
+import { observableSignalFromEvent } from '../../../../base/common/observableInternal/observables/observableSignalFromEvent.js';
+import { derived } from '../../../../base/common/observableInternal/observables/derived.js';
+
+var ChatModel_1;
+const CHAT_ATTACHABLE_IMAGE_MIME_TYPES = {
+    png: 'image/png',
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg',
+    gif: 'image/gif',
+    webp: 'image/webp',
+};
+function getAttachableImageExtension(mimeType) {
+    return Object.entries(CHAT_ATTACHABLE_IMAGE_MIME_TYPES).find(([_, value]) => value === mimeType)?.[0];
+}
+function isCellTextEditOperation(value) {
+    const candidate = value;
+    return !!candidate && !!candidate.edit && !!candidate.uri && URI.isUri(candidate.uri);
+}
+function isCellTextEditOperationArray(value) {
+    return ( value.some(isCellTextEditOperation));
+}
+const nonHistoryKinds = ( new Set(
+    ['toolInvocation', 'toolInvocationSerialized', 'undoStop', 'prepareToolInvocation']
+));
+function isChatProgressHistoryResponseContent(content) {
+    return !( nonHistoryKinds.has(content.kind));
+}
+function toChatHistoryContent(content) {
+    return content.filter(isChatProgressHistoryResponseContent);
+}
+const defaultChatResponseModelChangeReason = { reason: 'other' };
+class ChatRequestModel {
+    get session() {
+        return this._session;
+    }
+    get attempt() {
+        return this._attempt;
+    }
+    get variableData() {
+        return this._variableData;
+    }
+    set variableData(v) {
+        this._variableData = v;
+    }
+    get confirmation() {
+        return this._confirmation;
+    }
+    get locationData() {
+        return this._locationData;
+    }
+    get attachedContext() {
+        return this._attachedContext;
+    }
+    get editedFileEvents() {
+        return this._editedFileEvents;
+    }
+    constructor(params) {
+        this.shouldBeBlocked = false;
+        this._session = params.session;
+        this.message = params.message;
+        this._variableData = params.variableData;
+        this.timestamp = params.timestamp;
+        this._attempt = params.attempt ?? 0;
+        this.modeInfo = params.modeInfo;
+        this._confirmation = params.confirmation;
+        this._locationData = params.locationData;
+        this._attachedContext = params.attachedContext;
+        this.isCompleteAddedRequest = params.isCompleteAddedRequest ?? false;
+        this.modelId = params.modelId;
+        this.id = params.restoredId ?? 'request_' + generateUuid();
+        this._editedFileEvents = params.editedFileEvents;
+        this.userSelectedTools = params.userSelectedTools;
+    }
+    adoptTo(session) {
+        this._session = session;
+    }
+}
+class AbstractResponse {
+    get value() {
+        return this._responseParts;
+    }
+    constructor(value) {
+        this._responseRepr = '';
+        this._markdownContent = '';
+        this._responseParts = value;
+        this._updateRepr();
+    }
+    toString() {
+        return this._responseRepr;
+    }
+    getMarkdown() {
+        return this._markdownContent;
+    }
+    _updateRepr() {
+        this._responseRepr = this.partsToRepr(this._responseParts);
+        this._markdownContent = ( this._responseParts.map(part => {
+            if (part.kind === 'inlineReference') {
+                return this.inlineRefToRepr(part);
+            }
+            else if (part.kind === 'markdownContent' || part.kind === 'markdownVuln') {
+                return part.content.value;
+            }
+            else {
+                return '';
+            }
+        }))
+            .filter(s => s.length > 0)
+            .join('');
+    }
+    partsToRepr(parts) {
+        const blocks = [];
+        let currentBlockSegments = [];
+        let hasEditGroupsAfterLastClear = false;
+        for (const part of parts) {
+            let segment;
+            switch (part.kind) {
+                case 'clearToPreviousToolInvocation':
+                    currentBlockSegments = [];
+                    blocks.length = 0;
+                    hasEditGroupsAfterLastClear = false;
+                    continue;
+                case 'treeData':
+                case 'progressMessage':
+                case 'codeblockUri':
+                case 'extensions':
+                case 'pullRequest':
+                case 'undoStop':
+                case 'prepareToolInvocation':
+                case 'elicitation2':
+                case 'elicitationSerialized':
+                case 'thinking':
+                case 'multiDiffData':
+                case 'mcpServersStarting':
+                    continue;
+                case 'toolInvocation':
+                case 'toolInvocationSerialized':
+                    segment = this.getToolInvocationText(part);
+                    break;
+                case 'inlineReference':
+                    segment = { text: this.inlineRefToRepr(part) };
+                    break;
+                case 'command':
+                    segment = { text: part.command.title, isBlock: true };
+                    break;
+                case 'textEditGroup':
+                case 'notebookEditGroup':
+                    hasEditGroupsAfterLastClear = true;
+                    continue;
+                case 'confirmation':
+                    if (part.message instanceof MarkdownString) {
+                        segment = { text: `${part.title}\n${part.message.value}`, isBlock: true };
+                        break;
+                    }
+                    segment = { text: `${part.title}\n${part.message}`, isBlock: true };
+                    break;
+                case 'markdownContent':
+                case 'markdownVuln':
+                case 'progressTask':
+                case 'progressTaskSerialized':
+                case 'warning':
+                    segment = { text: part.content.value };
+                    break;
+                default:
+                    continue;
+            }
+            if (segment.isBlock) {
+                if (currentBlockSegments.length) {
+                    blocks.push(currentBlockSegments.join(''));
+                    currentBlockSegments = [];
+                }
+                blocks.push(segment.text);
+            }
+            else {
+                currentBlockSegments.push(segment.text);
+            }
+        }
+        if (currentBlockSegments.length) {
+            blocks.push(currentBlockSegments.join(''));
+        }
+        if (hasEditGroupsAfterLastClear) {
+            blocks.push(( localize(5936, "Made changes.")));
+        }
+        return blocks.join('\n\n');
+    }
+    inlineRefToRepr(part) {
+        if ('uri' in part.inlineReference) {
+            return this.uriToRepr(part.inlineReference.uri);
+        }
+        return 'name' in part.inlineReference
+            ? '`' + part.inlineReference.name + '`'
+            : this.uriToRepr(part.inlineReference);
+    }
+    getToolInvocationText(toolInvocation) {
+        let message = '';
+        let input = '';
+        if (toolInvocation.pastTenseMessage) {
+            message = typeof toolInvocation.pastTenseMessage === 'string'
+                ? toolInvocation.pastTenseMessage
+                : toolInvocation.pastTenseMessage.value;
+        }
+        else {
+            message = typeof toolInvocation.invocationMessage === 'string'
+                ? toolInvocation.invocationMessage
+                : toolInvocation.invocationMessage.value;
+        }
+        if (toolInvocation.toolSpecificData) {
+            if (toolInvocation.toolSpecificData.kind === 'terminal') {
+                message = 'Ran terminal command';
+                const terminalData = migrateLegacyTerminalToolSpecificData(toolInvocation.toolSpecificData);
+                input = terminalData.commandLine.userEdited ?? terminalData.commandLine.toolEdited ?? terminalData.commandLine.original;
+            }
+        }
+        let text = message;
+        if (input) {
+            text += `: ${input}`;
+        }
+        if (toolInvocation.kind === 'toolInvocationSerialized' || (toolInvocation.kind === 'toolInvocation' && IChatToolInvocation.isComplete(toolInvocation))) {
+            const resultDetails = IChatToolInvocation.resultDetails(toolInvocation);
+            if (resultDetails && 'input' in resultDetails) {
+                const resultPrefix = toolInvocation.kind === 'toolInvocationSerialized' || IChatToolInvocation.isComplete(toolInvocation) ? 'Completed' : 'Errored';
+                text += `\n${resultPrefix} with input: ${resultDetails.input}`;
+            }
+        }
+        return { text, isBlock: true };
+    }
+    uriToRepr(uri) {
+        if (uri.scheme === Schemas.http || uri.scheme === Schemas.https) {
+            return ( uri.toString(false));
+        }
+        return basename(uri);
+    }
+}
+class ResponseView extends AbstractResponse {
+    constructor(_response, undoStop) {
+        let idx = _response.value.findIndex(v => v.kind === 'undoStop' && v.id === undoStop);
+        if (_response.value[idx + 1]?.kind === 'codeblockUri' && _response.value[idx - 1]?.kind === 'markdownContent') {
+            idx--;
+        }
+        super(idx === -1 ? _response.value.slice() : _response.value.slice(0, idx));
+        this.undoStop = undoStop;
+    }
+}
+class Response extends AbstractResponse {
+    get onDidChangeValue() {
+        return this._onDidChangeValue.event;
+    }
+    constructor(value) {
+        super(( asArray(value).map((v) => ('kind' in v ? v :
+            isMarkdownString(v) ? { content: v, kind: 'markdownContent' } :
+                { kind: 'treeData', treeData: v }))));
+        this._onDidChangeValue = ( new Emitter());
+        this._citations = [];
+    }
+    dispose() {
+        this._onDidChangeValue.dispose();
+    }
+    clear() {
+        this._responseParts = [];
+        this._updateRepr(true);
+    }
+    clearToPreviousToolInvocation(message) {
+        let lastToolInvocationIndex = -1;
+        for (let i = this._responseParts.length - 1; i >= 0; i--) {
+            const part = this._responseParts[i];
+            if (part.kind === 'toolInvocation' || part.kind === 'toolInvocationSerialized') {
+                lastToolInvocationIndex = i;
+                break;
+            }
+        }
+        if (lastToolInvocationIndex !== -1) {
+            this._responseParts = this._responseParts.slice(0, lastToolInvocationIndex + 1);
+        }
+        else {
+            this._responseParts = [];
+        }
+        if (message) {
+            this._responseParts.push({ kind: 'warning', content: ( new MarkdownString(message)) });
+        }
+        this._updateRepr(true);
+    }
+    updateContent(progress, quiet) {
+        if (progress.kind === 'clearToPreviousToolInvocation') {
+            if (progress.reason === ChatResponseClearToPreviousToolInvocationReason.CopyrightContentRetry) {
+                this.clearToPreviousToolInvocation(( localize(
+                    5937,
+                    "Response cleared due to possible match to public code, retrying with modified prompt."
+                )));
+            }
+            else if (progress.reason === ChatResponseClearToPreviousToolInvocationReason.FilteredContentRetry) {
+                this.clearToPreviousToolInvocation(( localize(
+                    5938,
+                    "Response cleared due to content safety filters, retrying with modified prompt."
+                )));
+            }
+            else {
+                this.clearToPreviousToolInvocation();
+            }
+            return;
+        }
+        else if (progress.kind === 'markdownContent') {
+            const lastResponsePart = this._responseParts
+                .filter(p => p.kind !== 'textEditGroup')
+                .at(-1);
+            if (!lastResponsePart || lastResponsePart.kind !== 'markdownContent' || !canMergeMarkdownStrings(lastResponsePart.content, progress.content)) {
+                this._responseParts.push(progress);
+            }
+            else {
+                const idx = this._responseParts.indexOf(lastResponsePart);
+                this._responseParts[idx] = { ...lastResponsePart, content: appendMarkdownString(lastResponsePart.content, progress.content) };
+            }
+            this._updateRepr(quiet);
+        }
+        else if (progress.kind === 'thinking') {
+            const lastResponsePart = this._responseParts
+                .filter(p => p.kind !== 'textEditGroup')
+                .at(-1);
+            const lastText = lastResponsePart && lastResponsePart.kind === 'thinking'
+                ? (Array.isArray(lastResponsePart.value) ? lastResponsePart.value.join('') : (lastResponsePart.value || ''))
+                : '';
+            const currText = Array.isArray(progress.value) ? progress.value.join('') : (progress.value || '');
+            const isEmpty = (s) => s.length === 0;
+            if (!lastResponsePart
+                || lastResponsePart.kind !== 'thinking'
+                || isEmpty(currText)
+                || isEmpty(lastText)
+                || !canMergeMarkdownStrings(( new MarkdownString(lastText)), ( new MarkdownString(currText)))) {
+                this._responseParts.push(progress);
+            }
+            else {
+                const idx = this._responseParts.indexOf(lastResponsePart);
+                this._responseParts[idx] = {
+                    ...lastResponsePart,
+                    value: appendMarkdownString(( new MarkdownString(lastText)), ( new MarkdownString(currText))).value
+                };
+            }
+            this._updateRepr(quiet);
+        }
+        else if (progress.kind === 'textEdit' || progress.kind === 'notebookEdit') {
+            const useOldApproachForInlineNotebook = progress.uri.scheme === Schemas.vscodeNotebookCell && !this._responseParts.find(part => part.kind === 'notebookEditGroup');
+            const notebookUri = useOldApproachForInlineNotebook ? undefined : CellUri.parse(progress.uri)?.notebook;
+            const uri = notebookUri ?? progress.uri;
+            let found = false;
+            const groupKind = progress.kind === 'textEdit' && !notebookUri ? 'textEditGroup' : 'notebookEditGroup';
+            const edits = groupKind === 'textEditGroup' ? progress.edits : ( progress.edits.map(edit => TextEdit.isTextEdit(edit) ? { uri: progress.uri, edit } : edit));
+            const isExternalEdit = progress.isExternalEdit;
+            for (let i = 0; !found && i < this._responseParts.length; i++) {
+                const candidate = this._responseParts[i];
+                if (candidate.kind === groupKind && !candidate.done && isEqual(candidate.uri, uri)) {
+                    candidate.edits.push(edits);
+                    candidate.done = progress.done;
+                    found = true;
+                }
+            }
+            if (!found) {
+                this._responseParts.push({
+                    kind: groupKind,
+                    uri,
+                    edits: groupKind === 'textEditGroup' ? [edits] : edits,
+                    done: progress.done,
+                    isExternalEdit,
+                });
+            }
+            this._updateRepr(quiet);
+        }
+        else if (progress.kind === 'progressTask') {
+            const responsePosition = this._responseParts.push(progress) - 1;
+            this._updateRepr(quiet);
+            const disp = progress.onDidAddProgress(() => {
+                this._updateRepr(false);
+            });
+            progress.task?.().then((content) => {
+                disp.dispose();
+                if (typeof content === 'string') {
+                    this._responseParts[responsePosition].content = ( new MarkdownString(content));
+                }
+                this._updateRepr(false);
+            });
+        }
+        else if (progress.kind === 'toolInvocation') {
+            autorunSelfDisposable(reader => {
+                progress.state.read(reader);
+                this._updateRepr(false);
+                if (IChatToolInvocation.isComplete(progress, reader)) {
+                    reader.dispose();
+                }
+            });
+            this._responseParts.push(progress);
+            this._updateRepr(quiet);
+        }
+        else {
+            this._responseParts.push(progress);
+            this._updateRepr(quiet);
+        }
+    }
+    addCitation(citation) {
+        this._citations.push(citation);
+        this._updateRepr();
+    }
+    _updateRepr(quiet) {
+        super._updateRepr();
+        if (!this._onDidChangeValue) {
+            return;
+        }
+        this._responseRepr += this._citations.length ? '\n\n' + getCodeCitationsMessage(this._citations) : '';
+        if (!quiet) {
+            this._onDidChangeValue.fire();
+        }
+    }
+}
+class ChatResponseModel extends Disposable {
+    get shouldBeBlocked() {
+        return this._shouldBeBlocked;
+    }
+    get request() {
+        return this.session.getRequests().find(r => r.id === this.requestId);
+    }
+    get session() {
+        return this._session;
+    }
+    get shouldBeRemovedOnSend() {
+        return this._shouldBeRemovedOnSend;
+    }
+    get isComplete() {
+        return this._modelState.get().value !== ResponseModelState.Pending && this._modelState.get().value !== ResponseModelState.NeedsInput;
+    }
+    get timestamp() {
+        return this._timestamp;
+    }
+    set shouldBeRemovedOnSend(disablement) {
+        this._shouldBeRemovedOnSend = disablement;
+        this._onDidChange.fire(defaultChatResponseModelChangeReason);
+    }
+    get isCanceled() {
+        return this._modelState.get().value === ResponseModelState.Cancelled;
+    }
+    get completedAt() {
+        const state = this._modelState.get();
+        if (state.value === ResponseModelState.Complete || state.value === ResponseModelState.Cancelled || state.value === ResponseModelState.Failed) {
+            return state.completedAt;
+        }
+        return undefined;
+    }
+    get state() {
+        const state = this._modelState.get().value;
+        if (state === ResponseModelState.Complete && !!this._result?.errorDetails && this.result?.errorDetails?.code !== 'canceled') {
+            return ResponseModelState.Failed;
+        }
+        return state;
+    }
+    get vote() {
+        return this._vote;
+    }
+    get voteDownReason() {
+        return this._voteDownReason;
+    }
+    get followups() {
+        return this._followups;
+    }
+    get entireResponse() {
+        return this._finalizedResponse || this._response;
+    }
+    get result() {
+        return this._result;
+    }
+    get username() {
+        return this.session.responderUsername;
+    }
+    get avatarIcon() {
+        return this.session.responderAvatarIcon;
+    }
+    get agent() {
+        return this._agent;
+    }
+    get slashCommand() {
+        return this._slashCommand;
+    }
+    get agentOrSlashCommandDetected() {
+        return this._agentOrSlashCommandDetected ?? false;
+    }
+    get usedContext() {
+        return this._usedContext;
+    }
+    get contentReferences() {
+        return Array.from(this._contentReferences);
+    }
+    get codeCitations() {
+        return this._codeCitations;
+    }
+    get progressMessages() {
+        return this._progressMessages;
+    }
+    get isStale() {
+        return this._isStale;
+    }
+    get response() {
+        const undoStop = this._shouldBeRemovedOnSend?.afterUndoStop;
+        if (!undoStop) {
+            return this._finalizedResponse || this._response;
+        }
+        if (this._responseView?.undoStop !== undoStop) {
+            this._responseView = ( new ResponseView(this._response, undoStop));
+        }
+        return this._responseView;
+    }
+    get codeBlockInfos() {
+        return this._codeBlockInfos;
+    }
+    constructor(params) {
+        super();
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._modelState = observableValue(this, { value: ResponseModelState.Pending });
+        this._shouldBeBlocked = false;
+        this._contentReferences = [];
+        this._codeCitations = [];
+        this._progressMessages = [];
+        this._isStale = false;
+        this._session = params.session;
+        this._agent = params.agent;
+        this._slashCommand = params.slashCommand;
+        this.requestId = params.requestId;
+        this._timestamp = params.timestamp || Date.now();
+        if (params.modelState) {
+            this._modelState.set(params.modelState, undefined);
+        }
+        this._timeSpentWaitingAccumulator = params.timeSpentWaiting || 0;
+        this._vote = params.vote;
+        this._voteDownReason = params.voteDownReason;
+        this._result = params.result;
+        this._followups = params.followups ? [...params.followups] : undefined;
+        this.isCompleteAddedRequest = params.isCompleteAddedRequest ?? false;
+        this._shouldBeRemovedOnSend = params.shouldBeRemovedOnSend;
+        this._shouldBeBlocked = params.shouldBeBlocked ?? false;
+        this._isStale = Array.isArray(params.responseContent) && (params.responseContent.length !== 0 || isMarkdownString(params.responseContent) && params.responseContent.value.length !== 0);
+        this._response = this._register(( new Response(params.responseContent)));
+        this._codeBlockInfos = params.codeBlockInfos ? [...params.codeBlockInfos] : undefined;
+        const signal = observableSignalFromEvent(this, this.onDidChange);
+        const _isPendingBool = ( signal.map((_value, r) => {
+            signal.read(r);
+            return ( this._response.value.some(
+                part => part.kind === 'toolInvocation' && part.state.read(r).type === IChatToolInvocation.StateKind.WaitingForConfirmation
+                    || part.kind === 'confirmation' && !part.isUsed
+                    || part.kind === 'elicitation2' && part.state.read(r) === ElicitationState.Pending
+            ));
+        }));
+        this.isPendingConfirmation = ( _isPendingBool.map(pending => pending ? { startedWaitingAt: Date.now() } : undefined));
+        this.isInProgress = ( signal.map((_value, r) => {
+            signal.read(r);
+            return !_isPendingBool.read(r)
+                && !this.shouldBeRemovedOnSend
+                && (this._modelState.read(r).value === ResponseModelState.Pending || this._modelState.read(r).value === ResponseModelState.NeedsInput);
+        }));
+        this._register(this._response.onDidChangeValue(() => this._onDidChange.fire(defaultChatResponseModelChangeReason)));
+        this.id = params.restoredId ?? 'response_' + generateUuid();
+        this._register(this._session.onDidChange((e) => {
+            if (e.kind === 'setCheckpoint') {
+                const isDisabled = ( e.disabledResponseIds.has(this.id));
+                const didChange = this._shouldBeBlocked === isDisabled;
+                this._shouldBeBlocked = isDisabled;
+                if (didChange) {
+                    this._onDidChange.fire(defaultChatResponseModelChangeReason);
+                }
+            }
+        }));
+        let lastStartedWaitingAt = undefined;
+        this.confirmationAdjustedTimestamp = derived(reader => {
+            const pending = this.isPendingConfirmation.read(reader);
+            if (pending) {
+                this._modelState.set({ value: ResponseModelState.NeedsInput }, undefined);
+                if (!lastStartedWaitingAt) {
+                    lastStartedWaitingAt = pending.startedWaitingAt;
+                }
+            }
+            else if (lastStartedWaitingAt) {
+                if (this._modelState.read(reader).value === ResponseModelState.NeedsInput) {
+                    this._modelState.set({ value: ResponseModelState.Pending }, undefined);
+                }
+                this._timeSpentWaitingAccumulator += Date.now() - lastStartedWaitingAt;
+                lastStartedWaitingAt = undefined;
+            }
+            return this._timestamp + this._timeSpentWaitingAccumulator;
+        }).recomputeInitiallyAndOnChange(this._store);
+    }
+    initializeCodeBlockInfos(codeBlockInfo) {
+        if (this._codeBlockInfos) {
+            throw ( new BugIndicatingError('Code block infos have already been initialized'));
+        }
+        this._codeBlockInfos = [...codeBlockInfo];
+    }
+    updateContent(responsePart, quiet) {
+        this._response.updateContent(responsePart, quiet);
+    }
+    addUndoStop(undoStop) {
+        this._onDidChange.fire({ reason: 'undoStop', id: undoStop.id });
+        this._response.updateContent(undoStop, true);
+    }
+    applyReference(progress) {
+        if (progress.kind === 'usedContext') {
+            this._usedContext = progress;
+        }
+        else if (progress.kind === 'reference') {
+            this._contentReferences.push(progress);
+            this._onDidChange.fire(defaultChatResponseModelChangeReason);
+        }
+    }
+    applyCodeCitation(progress) {
+        this._codeCitations.push(progress);
+        this._response.addCitation(progress);
+        this._onDidChange.fire(defaultChatResponseModelChangeReason);
+    }
+    setAgent(agent, slashCommand) {
+        this._agent = agent;
+        this._slashCommand = slashCommand;
+        this._agentOrSlashCommandDetected = !agent.isDefault || !!slashCommand;
+        this._onDidChange.fire(defaultChatResponseModelChangeReason);
+    }
+    setResult(result) {
+        this._result = result;
+        this._onDidChange.fire(defaultChatResponseModelChangeReason);
+    }
+    complete() {
+        if (this._result?.errorDetails?.responseIsRedacted) {
+            this._response.clear();
+        }
+        const state = !!this._result?.errorDetails && this._result.errorDetails.code !== 'canceled' ? ResponseModelState.Failed : ResponseModelState.Complete;
+        this._modelState.set({ value: state, completedAt: Date.now() }, undefined);
+        this._onDidChange.fire({ reason: 'completedRequest' });
+    }
+    completeResponseIfNeeded() {
+        if (!this.isComplete) {
+            this.complete();
+        }
+    }
+    cancel() {
+        this._modelState.set({ value: ResponseModelState.Cancelled, completedAt: Date.now() }, undefined);
+        this._onDidChange.fire({ reason: 'completedRequest' });
+    }
+    setFollowups(followups) {
+        this._followups = followups;
+        this._onDidChange.fire(defaultChatResponseModelChangeReason);
+    }
+    setVote(vote) {
+        this._vote = vote;
+        this._onDidChange.fire(defaultChatResponseModelChangeReason);
+    }
+    setVoteDownReason(reason) {
+        this._voteDownReason = reason;
+        this._onDidChange.fire(defaultChatResponseModelChangeReason);
+    }
+    setEditApplied(edit, editCount) {
+        if (!this.response.value.includes(edit)) {
+            return false;
+        }
+        if (!edit.state) {
+            return false;
+        }
+        edit.state.applied = editCount;
+        this._onDidChange.fire(defaultChatResponseModelChangeReason);
+        return true;
+    }
+    adoptTo(session) {
+        this._session = session;
+        this._onDidChange.fire(defaultChatResponseModelChangeReason);
+    }
+    finalizeUndoState() {
+        this._finalizedResponse = this.response;
+        this._responseView = undefined;
+        this._shouldBeRemovedOnSend = undefined;
+    }
+    toJSON() {
+        const modelState = this._modelState.get();
+        const pendingConfirmation = this.isPendingConfirmation.get();
+        return {
+            responseId: this.id,
+            result: this.result,
+            responseMarkdownInfo: this.codeBlockInfos?.map(info => ({ suggestionId: info.suggestionId })),
+            followups: this.followups,
+            modelState: modelState.value === ResponseModelState.Pending || modelState.value === ResponseModelState.NeedsInput ? { value: ResponseModelState.Cancelled, completedAt: Date.now() } : modelState,
+            vote: this.vote,
+            voteDownReason: this.voteDownReason,
+            slashCommand: this.slashCommand,
+            usedContext: this.usedContext,
+            contentReferences: this.contentReferences,
+            codeCitations: this.codeCitations,
+            timestamp: this._timestamp,
+            timeSpentWaiting: (pendingConfirmation ? Date.now() - pendingConfirmation.startedWaitingAt : 0) + this._timeSpentWaitingAccumulator,
+        };
+    }
+}
+function normalizeSerializableChatData(raw) {
+    normalizeOldFields(raw);
+    if (!('version' in raw)) {
+        return {
+            version: 3,
+            ...raw,
+            lastMessageDate: raw.creationDate,
+            customTitle: undefined,
+        };
+    }
+    if (raw.version === 2) {
+        return {
+            ...raw,
+            version: 3,
+            customTitle: raw.computedTitle
+        };
+    }
+    return raw;
+}
+function normalizeOldFields(raw) {
+    if (!raw.sessionId) {
+        raw.sessionId = generateUuid();
+    }
+    if (!raw.creationDate) {
+        raw.creationDate = getLastYearDate();
+    }
+    if ('version' in raw && (raw.version === 2 || raw.version === 3)) {
+        if (!raw.lastMessageDate) {
+            raw.lastMessageDate = getLastYearDate();
+        }
+    }
+    if (raw.initialLocation === 'editing-session') {
+        raw.initialLocation = ChatAgentLocation.Chat;
+    }
+}
+function getLastYearDate() {
+    const lastYearDate = ( new Date());
+    lastYearDate.setFullYear(lastYearDate.getFullYear() - 1);
+    return lastYearDate.getTime();
+}
+function isExportableSessionData(obj) {
+    return !!obj &&
+        Array.isArray(obj.requests) &&
+        typeof obj.responderUsername === 'string';
+}
+function isSerializableSessionData(obj) {
+    const data = obj;
+    return isExportableSessionData(obj) &&
+        typeof data.creationDate === 'number' &&
+        typeof data.sessionId === 'string' &&
+        obj.requests.every((request) => !request.usedContext  || isIUsedContext(request.usedContext));
+}
+var ChatRequestRemovalReason;
+(function (ChatRequestRemovalReason) {
+    ChatRequestRemovalReason[ChatRequestRemovalReason["Removal"] = 0] = "Removal";
+    ChatRequestRemovalReason[ChatRequestRemovalReason["Resend"] = 1] = "Resend";
+    ChatRequestRemovalReason[ChatRequestRemovalReason["Adoption"] = 2] = "Adoption";
+})(ChatRequestRemovalReason || (ChatRequestRemovalReason = {}));
+class InputModel {
+    constructor(initialState) {
+        this._state = observableValueOpts({ debugName: 'inputModelState', equalsFn: equals }, initialState);
+        this.state = this._state;
+    }
+    setState(state) {
+        const current = this._state.get();
+        this._state.set({
+            attachments: [],
+            mode: { id: 'agent', kind: ChatModeKind.Agent },
+            selectedModel: undefined,
+            inputText: '',
+            selections: [],
+            contrib: {},
+            ...current,
+            ...state
+        }, undefined);
+    }
+    clearState() {
+        this._state.set(undefined, undefined);
+    }
+    toJSON() {
+        const value = this.state.get();
+        if (!value) {
+            return undefined;
+        }
+        return {
+            contrib: value.contrib,
+            attachments: value.attachments,
+            mode: value.mode,
+            selectedModel: value.selectedModel ? {
+                identifier: value.selectedModel.identifier,
+                metadata: value.selectedModel.metadata
+            } : undefined,
+            inputText: value.inputText,
+            selections: value.selections
+        };
+    }
+}
+let ChatModel = ChatModel_1 = class ChatModel extends Disposable {
+    static getDefaultTitle(requests) {
+        const firstRequestMessage = requests.at(0)?.message ?? '';
+        const message = typeof firstRequestMessage === 'string' ?
+            firstRequestMessage :
+            firstRequestMessage.text;
+        return message.split('\n')[0].substring(0, 200);
+    }
+    get contributedChatSession() {
+        return this._contributedChatSession;
+    }
+    setContributedChatSession(session) {
+        this._contributedChatSession = session;
+    }
+    get sessionId() {
+        return this._sessionId;
+    }
+    get sessionResource() {
+        return this._sessionResource;
+    }
+    get hasRequests() {
+        return this._requests.length > 0;
+    }
+    get lastRequest() {
+        return this._requests.at(-1);
+    }
+    get timestamp() {
+        return this._timestamp;
+    }
+    get timing() {
+        const lastResponse = this._requests.at(-1)?.response;
+        return {
+            startTime: this._timestamp,
+            endTime: lastResponse?.completedAt ?? lastResponse?.timestamp
+        };
+    }
+    get lastMessageDate() {
+        return this._lastMessageDate;
+    }
+    get _defaultAgent() {
+        return this.chatAgentService.getDefaultAgent(ChatAgentLocation.Chat, ChatModeKind.Ask);
+    }
+    get responderUsername() {
+        return this._defaultAgent?.fullName ??
+            this._initialResponderUsername ?? '';
+    }
+    get responderAvatarIcon() {
+        return this._defaultAgent?.metadata.themeIcon ??
+            this._initialResponderAvatarIconUri;
+    }
+    get isImported() {
+        return this._isImported;
+    }
+    get customTitle() {
+        return this._customTitle;
+    }
+    get title() {
+        return this._customTitle || ChatModel_1.getDefaultTitle(this._requests);
+    }
+    get hasCustomTitle() {
+        return this._customTitle !== undefined;
+    }
+    get editingSession() {
+        return this._editingSession;
+    }
+    get initialLocation() {
+        return this._initialLocation;
+    }
+    get canUseTools() {
+        return this._canUseTools;
+    }
+    get willKeepAlive() {
+        return !this._disableBackgroundKeepAlive;
+    }
+    constructor(initialData, initialModelProps, logService, chatAgentService, chatEditingService, chatService) {
+        super();
+        this.logService = logService;
+        this.chatAgentService = chatAgentService;
+        this.chatEditingService = chatEditingService;
+        this.chatService = chatService;
+        this._onDidDispose = this._register(( new Emitter()));
+        this.onDidDispose = this._onDidDispose.event;
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._isImported = false;
+        this._canUseTools = true;
+        this.currentEditedFileEvents = ( new ResourceMap());
+        this._checkpoint = undefined;
+        const isValidExportedData = isExportableSessionData(initialData);
+        const isValidFullData = isValidExportedData && isSerializableSessionData(initialData);
+        if (initialData && !isValidExportedData) {
+            this.logService.warn(`ChatModel#constructor: Loaded malformed session data: ${JSON.stringify(initialData)}`);
+        }
+        this._isImported = !!initialData && isValidExportedData && !isValidFullData;
+        this._sessionId = (isValidFullData && initialData.sessionId) || initialModelProps.sessionId || generateUuid();
+        this._sessionResource = initialModelProps.resource ?? LocalChatSessionUri.forSession(this._sessionId);
+        this._disableBackgroundKeepAlive = initialModelProps.disableBackgroundKeepAlive ?? false;
+        this._requests = initialData ? this._deserialize(initialData) : [];
+        this._timestamp = (isValidFullData && initialData.creationDate) || Date.now();
+        this._lastMessageDate = (isValidFullData && initialData.lastMessageDate) || this._timestamp;
+        this._customTitle = isValidFullData ? initialData.customTitle : undefined;
+        const serializedInputState = initialModelProps.inputState || (isValidFullData && initialData.inputState ? initialData.inputState : undefined);
+        this.inputModel = ( new InputModel(serializedInputState && {
+            attachments: serializedInputState.attachments,
+            mode: serializedInputState.mode,
+            selectedModel: serializedInputState.selectedModel && {
+                identifier: serializedInputState.selectedModel.identifier,
+                metadata: serializedInputState.selectedModel.metadata
+            },
+            contrib: serializedInputState.contrib,
+            inputText: serializedInputState.inputText,
+            selections: serializedInputState.selections
+        }));
+        this._initialResponderUsername = initialData?.responderUsername;
+        this._initialResponderAvatarIconUri = isUriComponents(initialData?.responderAvatarIconUri) ? URI.revive(initialData.responderAvatarIconUri) : initialData?.responderAvatarIconUri;
+        this._initialLocation = initialData?.initialLocation ?? initialModelProps.initialLocation;
+        this._canUseTools = initialModelProps.canUseTools;
+        this.lastRequestObs = observableFromEvent(this, this.onDidChange, () => this._requests.at(-1));
+        this._register(autorun(reader => {
+            const request = this.lastRequestObs.read(reader);
+            if (!request?.response) {
+                return;
+            }
+            reader.store.add(request.response.onDidChange(async (ev) => {
+                if (ev.reason === 'completedRequest' && this._editingSession) {
+                    if (request === this._requests.at(-1)
+                        && request.session.sessionResource.scheme !== Schemas.vscodeLocalChatSession
+                        && this._editingSession.hasEditsInRequest(request.id)) {
+                        const diffs = this._editingSession.getDiffsForFilesInRequest(request.id);
+                        request.response?.updateContent(editEntriesToMultiDiffData(diffs), true);
+                    }
+                    this._onDidChange.fire({ kind: 'completedRequest', request });
+                }
+            }));
+        }));
+        this.requestInProgress = ( this.lastRequestObs.map((request, r) => {
+            return request?.response?.isInProgress.read(r) ?? false;
+        }));
+        this.requestNeedsInput = ( this.lastRequestObs.map((request, r) => {
+            return !!request?.response?.isPendingConfirmation.read(r);
+        }));
+        if (this.initialLocation === ChatAgentLocation.Chat && !initialModelProps.disableBackgroundKeepAlive) {
+            const selfRef = this._register(( new MutableDisposable()));
+            this._register(autorun(r => {
+                const inProgress = this.requestInProgress.read(r);
+                const isWaitingForConfirmation = this.requestNeedsInput.read(r);
+                const shouldStayAlive = inProgress || isWaitingForConfirmation;
+                if (shouldStayAlive && !selfRef.value) {
+                    selfRef.value = chatService.getActiveSessionReference(this._sessionResource);
+                }
+                else if (!shouldStayAlive && selfRef.value) {
+                    selfRef.clear();
+                }
+            }));
+        }
+    }
+    startEditingSession(isGlobalEditingSession, transferFromSession) {
+        const session = this._editingSession ??= this._register(transferFromSession
+            ? this.chatEditingService.transferEditingSession(this, transferFromSession)
+            : isGlobalEditingSession
+                ? this.chatEditingService.startOrContinueGlobalEditingSession(this)
+                : this.chatEditingService.createEditingSession(this));
+        if (!this._disableBackgroundKeepAlive) {
+            const selfRef = this._register(( new MutableDisposable()));
+            this._register(autorun(r => {
+                const hasModified = ( session.entries.read(r).some(e => e.state.read(r) === ModifiedFileEntryState.Modified));
+                if (hasModified && !selfRef.value) {
+                    selfRef.value = this.chatService.getActiveSessionReference(this._sessionResource);
+                }
+                else if (!hasModified && selfRef.value) {
+                    selfRef.clear();
+                }
+            }));
+        }
+        this._register(autorun(reader => {
+            this._setDisabledRequests(session.requestDisablement.read(reader));
+        }));
+    }
+    notifyEditingAction(action) {
+        const state = action.outcome === 'accepted' ? ChatRequestEditedFileEventKind.Keep :
+            action.outcome === 'rejected' ? ChatRequestEditedFileEventKind.Undo :
+                action.outcome === 'userModified' ? ChatRequestEditedFileEventKind.UserModification : null;
+        if (state === null) {
+            return;
+        }
+        if (!( this.currentEditedFileEvents.has(action.uri)) || this.currentEditedFileEvents.get(action.uri)?.eventKind === ChatRequestEditedFileEventKind.Keep) {
+            this.currentEditedFileEvents.set(action.uri, { eventKind: state, uri: action.uri });
+        }
+    }
+    _deserialize(obj) {
+        const requests = obj.requests;
+        if (!Array.isArray(requests)) {
+            this.logService.error(`Ignoring malformed session data: ${JSON.stringify(obj)}`);
+            return [];
+        }
+        try {
+            return ( requests.map((raw) => {
+                const parsedRequest = typeof raw.message === 'string'
+                    ? this.getParsedRequestFromString(raw.message)
+                    : reviveParsedChatRequest(raw.message);
+                const variableData = this.reviveVariableData(raw.variableData);
+                const request = ( new ChatRequestModel({
+                    session: this,
+                    message: parsedRequest,
+                    variableData,
+                    timestamp: raw.timestamp ?? -1,
+                    restoredId: raw.requestId,
+                    confirmation: raw.confirmation,
+                    editedFileEvents: raw.editedFileEvents,
+                    modelId: raw.modelId,
+                }));
+                request.shouldBeRemovedOnSend = raw.isHidden ? { requestId: raw.requestId } : raw.shouldBeRemovedOnSend;
+                if (raw.response || raw.result || raw.responseErrorDetails) {
+                    const agent = (raw.agent && 'metadata' in raw.agent) ?
+                        reviveSerializedAgent(raw.agent) : undefined;
+                    const result = 'responseErrorDetails' in raw ?
+                        { errorDetails: raw.responseErrorDetails } : raw.result;
+                    request.response = ( new ChatResponseModel({
+                        responseContent: raw.response ?? [( new MarkdownString(raw.response))],
+                        session: this,
+                        agent,
+                        slashCommand: raw.slashCommand,
+                        requestId: request.id,
+                        modelState: raw.modelState || { value: raw.isCanceled ? ResponseModelState.Cancelled : ResponseModelState.Complete, completedAt: 'lastMessageDate' in obj ? obj.lastMessageDate : Date.now() },
+                        vote: raw.vote,
+                        timestamp: raw.timestamp,
+                        voteDownReason: raw.voteDownReason,
+                        result,
+                        followups: raw.followups,
+                        restoredId: raw.responseId,
+                        timeSpentWaiting: raw.timeSpentWaiting,
+                        shouldBeBlocked: request.shouldBeBlocked,
+                        codeBlockInfos: raw.responseMarkdownInfo?.map(info => ({ suggestionId: info.suggestionId })),
+                    }));
+                    request.response.shouldBeRemovedOnSend = raw.isHidden ? { requestId: raw.requestId } : raw.shouldBeRemovedOnSend;
+                    if (raw.usedContext) {
+                        request.response.applyReference(revive(raw.usedContext));
+                    }
+                    raw.contentReferences?.forEach(r => request.response.applyReference(revive(r)));
+                    raw.codeCitations?.forEach(c => request.response.applyCodeCitation(revive(c)));
+                }
+                return request;
+            }));
+        }
+        catch (error) {
+            this.logService.error('Failed to parse chat data', error);
+            return [];
+        }
+    }
+    reviveVariableData(raw) {
+        const variableData = raw && Array.isArray(raw.variables)
+            ? raw :
+            { variables: [] };
+        variableData.variables = ( variableData.variables.map((v) => {
+            if (v && 'values' in v && Array.isArray(v.values)) {
+                return {
+                    kind: 'generic',
+                    id: v.id ?? '',
+                    name: v.name,
+                    value: v.values[0]?.value,
+                    range: v.range,
+                    modelDescription: v.modelDescription,
+                    references: v.references
+                };
+            }
+            else {
+                return v;
+            }
+        }));
+        return variableData;
+    }
+    getParsedRequestFromString(message) {
+        const parts = [( new ChatRequestTextPart(( new OffsetRange(0, message.length)), { startColumn: 1, startLineNumber: 1, endColumn: 1, endLineNumber: 1 }, message))];
+        return {
+            text: message,
+            parts
+        };
+    }
+    getRequests() {
+        return this._requests;
+    }
+    resetCheckpoint() {
+        for (const request of this._requests) {
+            request.shouldBeBlocked = false;
+        }
+    }
+    setCheckpoint(requestId) {
+        let checkpoint;
+        let checkpointIndex = -1;
+        if (requestId !== undefined) {
+            this._requests.forEach((request, index) => {
+                if (request.id === requestId) {
+                    checkpointIndex = index;
+                    checkpoint = request;
+                    request.shouldBeBlocked = true;
+                }
+            });
+            if (!checkpoint) {
+                return;
+            }
+        }
+        const disabledRequestIds = ( new Set());
+        const disabledResponseIds = ( new Set());
+        for (let i = this._requests.length - 1; i >= 0; i -= 1) {
+            const request = this._requests[i];
+            if (this._checkpoint && !checkpoint) {
+                request.shouldBeBlocked = false;
+            }
+            else if (checkpoint && i >= checkpointIndex) {
+                request.shouldBeBlocked = true;
+                disabledRequestIds.add(request.id);
+                if (request.response) {
+                    disabledResponseIds.add(request.response.id);
+                }
+            }
+            else if (checkpoint && i < checkpointIndex) {
+                request.shouldBeBlocked = false;
+            }
+        }
+        this._checkpoint = checkpoint;
+        this._onDidChange.fire({
+            kind: 'setCheckpoint',
+            disabledRequestIds,
+            disabledResponseIds
+        });
+    }
+    get checkpoint() {
+        return this._checkpoint;
+    }
+    _setDisabledRequests(requestIds) {
+        this._requests.forEach((request) => {
+            const shouldBeRemovedOnSend = requestIds.find(r => r.requestId === request.id);
+            request.shouldBeRemovedOnSend = shouldBeRemovedOnSend;
+            if (request.response) {
+                request.response.shouldBeRemovedOnSend = shouldBeRemovedOnSend;
+            }
+        });
+        this._onDidChange.fire({ kind: 'setHidden' });
+    }
+    addRequest(message, variableData, attempt, modeInfo, chatAgent, slashCommand, confirmation, locationData, attachments, isCompleteAddedRequest, modelId, userSelectedTools, id) {
+        const editedFileEvents = [...( this.currentEditedFileEvents.values())];
+        this.currentEditedFileEvents.clear();
+        const request = ( new ChatRequestModel({
+            restoredId: id,
+            session: this,
+            message,
+            variableData,
+            timestamp: Date.now(),
+            attempt,
+            modeInfo,
+            confirmation,
+            locationData,
+            attachedContext: attachments,
+            isCompleteAddedRequest,
+            modelId,
+            editedFileEvents: editedFileEvents.length ? editedFileEvents : undefined,
+            userSelectedTools,
+        }));
+        request.response = ( new ChatResponseModel({
+            responseContent: [],
+            session: this,
+            agent: chatAgent,
+            slashCommand,
+            requestId: request.id,
+            isCompleteAddedRequest,
+            codeBlockInfos: undefined,
+        }));
+        this._requests.push(request);
+        this._lastMessageDate = Date.now();
+        this._onDidChange.fire({ kind: 'addRequest', request });
+        return request;
+    }
+    setCustomTitle(title) {
+        this._customTitle = title;
+        this._onDidChange.fire({ kind: 'setCustomTitle', title });
+    }
+    updateRequest(request, variableData) {
+        request.variableData = variableData;
+        this._onDidChange.fire({ kind: 'changedRequest', request });
+    }
+    adoptRequest(request) {
+        const oldOwner = request.session;
+        const index = oldOwner._requests.findIndex((candidate) => candidate.id === request.id);
+        if (index === -1) {
+            return;
+        }
+        oldOwner._requests.splice(index, 1);
+        request.adoptTo(this);
+        request.response?.adoptTo(this);
+        this._requests.push(request);
+        oldOwner._onDidChange.fire({ kind: 'removeRequest', requestId: request.id, responseId: request.response?.id, reason: ChatRequestRemovalReason.Adoption });
+        this._onDidChange.fire({ kind: 'addRequest', request });
+    }
+    acceptResponseProgress(request, progress, quiet) {
+        if (!request.response) {
+            request.response = ( new ChatResponseModel({
+                responseContent: [],
+                session: this,
+                requestId: request.id,
+                codeBlockInfos: undefined,
+            }));
+        }
+        if (request.response.isComplete) {
+            throw ( new Error('acceptResponseProgress: Adding progress to a completed response'));
+        }
+        if (progress.kind === 'usedContext' || progress.kind === 'reference') {
+            request.response.applyReference(progress);
+        }
+        else if (progress.kind === 'codeCitation') {
+            request.response.applyCodeCitation(progress);
+        }
+        else if (progress.kind === 'move') {
+            this._onDidChange.fire({ kind: 'move', target: progress.uri, range: progress.range });
+        }
+        else if (progress.kind === 'codeblockUri' && progress.isEdit) {
+            request.response.addUndoStop({ id: progress.undoStopId ?? generateUuid(), kind: 'undoStop' });
+            request.response.updateContent(progress, quiet);
+        }
+        else if (progress.kind === 'progressTaskResult') {
+            this.logService.error(`Couldn't handle progress: ${JSON.stringify(progress)}`);
+        }
+        else {
+            request.response.updateContent(progress, quiet);
+        }
+    }
+    removeRequest(id, reason = ChatRequestRemovalReason.Removal) {
+        const index = this._requests.findIndex(request => request.id === id);
+        const request = this._requests[index];
+        if (index !== -1) {
+            this._onDidChange.fire({ kind: 'removeRequest', requestId: request.id, responseId: request.response?.id, reason });
+            this._requests.splice(index, 1);
+            request.response?.dispose();
+        }
+    }
+    cancelRequest(request) {
+        if (request.response) {
+            request.response.cancel();
+        }
+    }
+    setResponse(request, result) {
+        if (!request.response) {
+            request.response = ( new ChatResponseModel({
+                responseContent: [],
+                session: this,
+                requestId: request.id,
+                codeBlockInfos: undefined,
+            }));
+        }
+        request.response.setResult(result);
+    }
+    setFollowups(request, followups) {
+        if (!request.response) {
+            return;
+        }
+        request.response.setFollowups(followups);
+    }
+    setResponseModel(request, response) {
+        request.response = response;
+        this._onDidChange.fire({ kind: 'addResponse', response });
+    }
+    toExport() {
+        return {
+            responderUsername: this.responderUsername,
+            responderAvatarIconUri: this.responderAvatarIcon,
+            initialLocation: this.initialLocation,
+            requests: ( this._requests.map((r) => {
+                const message = {
+                    ...r.message,
+                    parts: ( r.message.parts.map((p) => p && 'toJSON' in p ? p.toJSON() : p))
+                };
+                const agent = r.response?.agent;
+                const agentJson = agent && 'toJSON' in agent ? agent.toJSON() :
+                    agent ? { ...agent } : undefined;
+                return {
+                    requestId: r.id,
+                    message,
+                    variableData: r.variableData,
+                    response: r.response ?
+                        ( r.response.entireResponse.value.map(item => {
+                            if (item.kind === 'treeData') {
+                                return item.treeData;
+                            }
+                            else if (item.kind === 'markdownContent') {
+                                return item.content;
+                            }
+                            else if (item.kind === 'confirmation') {
+                                return { ...item, isLive: false };
+                            }
+                            else {
+                                return item;
+                            }
+                        }))
+                        : undefined,
+                    shouldBeRemovedOnSend: r.shouldBeRemovedOnSend,
+                    agent: agentJson,
+                    timestamp: r.timestamp,
+                    confirmation: r.confirmation,
+                    editedFileEvents: r.editedFileEvents,
+                    modelId: r.modelId,
+                    ...r.response?.toJSON(),
+                };
+            })),
+        };
+    }
+    toJSON() {
+        return {
+            version: 3,
+            ...this.toExport(),
+            sessionId: this.sessionId,
+            creationDate: this._timestamp,
+            lastMessageDate: this._lastMessageDate,
+            customTitle: this._customTitle,
+            hasPendingEdits: !!(this._editingSession?.entries.get().some(e => e.state.get() === ModifiedFileEntryState.Modified)),
+            ...this.inputModel.toJSON(),
+        };
+    }
+    dispose() {
+        this._requests.forEach(r => r.response?.dispose());
+        this._onDidDispose.fire();
+        super.dispose();
+    }
+};
+ChatModel = ChatModel_1 = ( __decorate([
+    ( __param(2, ILogService)),
+    ( __param(3, IChatAgentService)),
+    ( __param(4, IChatEditingService)),
+    ( __param(5, IChatService))
+], ChatModel));
+function updateRanges(variableData, diff) {
+    return {
+        variables: ( variableData.variables.map(v => ({
+            ...v,
+            range: v.range && {
+                start: v.range.start - diff,
+                endExclusive: v.range.endExclusive - diff
+            }
+        })))
+    };
+}
+function canMergeMarkdownStrings(md1, md2) {
+    if (md1.baseUri && md2.baseUri) {
+        const baseUriEquals = md1.baseUri.scheme === md2.baseUri.scheme
+            && md1.baseUri.authority === md2.baseUri.authority
+            && md1.baseUri.path === md2.baseUri.path
+            && md1.baseUri.query === md2.baseUri.query
+            && md1.baseUri.fragment === md2.baseUri.fragment;
+        if (!baseUriEquals) {
+            return false;
+        }
+    }
+    else if (md1.baseUri || md2.baseUri) {
+        return false;
+    }
+    return equals(md1.isTrusted, md2.isTrusted) &&
+        md1.supportHtml === md2.supportHtml &&
+        md1.supportThemeIcons === md2.supportThemeIcons;
+}
+function appendMarkdownString(md1, md2) {
+    const appendedValue = typeof md2 === 'string' ? md2 : md2.value;
+    return {
+        value: md1.value + appendedValue,
+        isTrusted: md1.isTrusted,
+        supportThemeIcons: md1.supportThemeIcons,
+        supportHtml: md1.supportHtml,
+        baseUri: md1.baseUri
+    };
+}
+function getCodeCitationsMessage(citations) {
+    if (citations.length === 0) {
+        return '';
+    }
+    const licenseTypes = citations.reduce((set, c) => set.add(c.license), ( new Set()));
+    const label = licenseTypes.size === 1 ?
+        ( localize(5939, "Similar code found with 1 license type", licenseTypes.size)) :
+        ( localize(5940, "Similar code found with {0} license types", licenseTypes.size));
+    return label;
+}
+var ChatRequestEditedFileEventKind;
+(function (ChatRequestEditedFileEventKind) {
+    ChatRequestEditedFileEventKind[ChatRequestEditedFileEventKind["Keep"] = 1] = "Keep";
+    ChatRequestEditedFileEventKind[ChatRequestEditedFileEventKind["Undo"] = 2] = "Undo";
+    ChatRequestEditedFileEventKind[ChatRequestEditedFileEventKind["UserModification"] = 3] = "UserModification";
+})(ChatRequestEditedFileEventKind || (ChatRequestEditedFileEventKind = {}));
+var ChatResponseResource;
+(function (ChatResponseResource) {
+    ChatResponseResource.scheme = 'vscode-chat-response-resource';
+    function createUri(sessionResource, toolCallId, index, basename) {
+        return ( URI.from({
+            scheme: ChatResponseResource.scheme,
+            authority: encodeHex(VSBuffer.fromString(( sessionResource.toString()))),
+            path: `/tool/${toolCallId}/${index}` + (basename ? `/${basename}` : ''),
+        }));
+    }
+    ChatResponseResource.createUri = createUri;
+    function parseUri(uri) {
+        if (uri.scheme !== ChatResponseResource.scheme) {
+            return undefined;
+        }
+        const parts = uri.path.split('/');
+        if (parts.length < 5) {
+            return undefined;
+        }
+        const [, kind, toolCallId, index] = parts;
+        if (kind !== 'tool') {
+            return undefined;
+        }
+        let sessionResource;
+        try {
+            sessionResource = ( URI.parse(( decodeHex(uri.authority).toString())));
+        }
+        catch (e) {
+            if (e instanceof SyntaxError) {
+                sessionResource = LocalChatSessionUri.forSession(uri.authority);
+            }
+            else {
+                throw e;
+            }
+        }
+        return {
+            sessionResource,
+            toolCallId: toolCallId,
+            index: Number(index),
+        };
+    }
+    ChatResponseResource.parseUri = parseUri;
+})(ChatResponseResource || (ChatResponseResource = {}));
+
+export { CHAT_ATTACHABLE_IMAGE_MIME_TYPES, ChatModel, ChatRequestEditedFileEventKind, ChatRequestModel, ChatRequestRemovalReason, ChatResponseModel, ChatResponseResource, Response, appendMarkdownString, canMergeMarkdownStrings, defaultChatResponseModelChangeReason, getAttachableImageExtension, getCodeCitationsMessage, isCellTextEditOperation, isCellTextEditOperationArray, isExportableSessionData, isSerializableSessionData, normalizeSerializableChatData, toChatHistoryContent, updateRanges };