@codingame/monaco-vscode-katex-common 25.1.1 → 26.0.0

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatSessionService.d.ts

@@ -1,28 +0,0 @@
-import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
-import { ICodeEditor } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser";
-import { Position } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/position";
-import { Selection } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/selection";
-import { ServicesAccessor } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
-import { IChatEditingSession } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService";
-import { IChatModel, IChatModelInputState, IChatRequestModel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatModel";
-import { Session } from "./inlineChatSession.js";
-export interface ISessionKeyComputer {
-    getComparisonKey(editor: ICodeEditor, uri: URI): string;
-}
-export interface IInlineChatSessionEvent {
-    readonly editor: ICodeEditor;
-    readonly session: Session;
-}
-export interface IInlineChatSessionEndEvent extends IInlineChatSessionEvent {
-    readonly endedByExternalCause: boolean;
-}
-export interface IInlineChatSession2 {
-    readonly initialPosition: Position;
-    readonly initialSelection: Selection;
-    readonly uri: URI;
-    readonly chatModel: IChatModel;
-    readonly editingSession: IChatEditingSession;
-    dispose(): void;
-}
-export declare function moveToPanelChat(accessor: ServicesAccessor, model: IChatModel | undefined, resend: boolean): Promise<void>;
-export declare function askInPanelChat(accessor: ServicesAccessor, request: IChatRequestModel, state: IChatModelInputState | undefined): Promise<void>;

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

@@ -1,37 +0,0 @@
-
-import { ChatViewPaneTarget } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat';
-import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
-import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
-import { ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
-
-async function moveToPanelChat(accessor, model, resend) {
-    const chatService = accessor.get(IChatService);
-    const widgetService = accessor.get(IChatWidgetService);
-    const widget = await widgetService.revealWidget();
-    if (widget && widget.viewModel && model) {
-        let lastRequest;
-        for (const request of model.getRequests().slice()) {
-            await chatService.adoptRequest(widget.viewModel.model.sessionResource, request);
-            lastRequest = request;
-        }
-        if (lastRequest && resend) {
-            chatService.resendRequest(lastRequest, { location: widget.location });
-        }
-        widget.focusResponseItem();
-    }
-}
-async function askInPanelChat(accessor, request, state) {
-    const widgetService = accessor.get(IChatWidgetService);
-    const chatService = accessor.get(IChatService);
-    if (!request) {
-        return;
-    }
-    const newModelRef = chatService.startSession(ChatAgentLocation.Chat);
-    const newModel = newModelRef.object;
-    newModel.inputModel.setState({ ...state });
-    const widget = await widgetService.openSession(newModelRef.object.sessionResource, ChatViewPaneTarget);
-    newModelRef.dispose();
-    widget?.acceptInput(request.message.text);
-}
-
-export { askInPanelChat, moveToPanelChat };

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatSessionServiceImpl.d.ts

@@ -1,94 +0,0 @@
-import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
-import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
-import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
-import { IActiveCodeEditor, ICodeEditor } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser";
-import { ICodeEditorService } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/codeEditorService.service";
-import { Range } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
-import { ILanguageService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service";
-import { IValidEditOperation } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
-import { IEditorWorkerService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/editorWorker.service";
-import { IModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service";
-import { ITextModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service";
-import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
-import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
-import { IDialogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service";
-import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
-import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
-import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
-import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
-import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
-import { ITextFileService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/textfile/common/textfiles.service";
-import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
-import { IChatAgentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatAgents.service";
-import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
-import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service";
-import { Session, StashedSession } from "./inlineChatSession.js";
-import { IInlineChatSession2, IInlineChatSessionEndEvent, IInlineChatSessionEvent, ISessionKeyComputer } from "./inlineChatSessionService.js";
-import { IInlineChatSessionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSessionService.service";
-export declare class InlineChatError extends Error {
-    static readonly code = "InlineChatError";
-    constructor(message: string);
-}
-export declare class InlineChatSessionServiceImpl implements IInlineChatSessionService {
-    private readonly _telemetryService;
-    private readonly _modelService;
-    private readonly _textModelService;
-    private readonly _editorWorkerService;
-    private readonly _logService;
-    private readonly _instaService;
-    private readonly _editorService;
-    private readonly _textFileService;
-    private readonly _languageService;
-    private readonly _chatService;
-    private readonly _chatAgentService;
-    private readonly _chatWidgetService;
-    _serviceBrand: undefined;
-    private readonly _store;
-    private readonly _onWillStartSession;
-    readonly onWillStartSession: Event<IActiveCodeEditor>;
-    private readonly _onDidMoveSession;
-    readonly onDidMoveSession: Event<IInlineChatSessionEvent>;
-    private readonly _onDidEndSession;
-    readonly onDidEndSession: Event<IInlineChatSessionEndEvent>;
-    private readonly _onDidStashSession;
-    readonly onDidStashSession: Event<IInlineChatSessionEvent>;
-    private readonly _sessions;
-    private readonly _keyComputers;
-    constructor(_telemetryService: ITelemetryService, _modelService: IModelService, _textModelService: ITextModelService, _editorWorkerService: IEditorWorkerService, _logService: ILogService, _instaService: IInstantiationService, _editorService: IEditorService, _textFileService: ITextFileService, _languageService: ILanguageService, _chatService: IChatService, _chatAgentService: IChatAgentService, _chatWidgetService: IChatWidgetService);
-    dispose(): void;
-    createSession(editor: IActiveCodeEditor, options: {
-        headless?: boolean;
-        wholeRange?: Range;
-        session?: Session;
-    }, token: CancellationToken): Promise<Session | undefined>;
-    moveSession(session: Session, target: ICodeEditor): void;
-    releaseSession(session: Session): void;
-    private _releaseSession;
-    stashSession(session: Session, editor: ICodeEditor, undoCancelEdits: IValidEditOperation[]): StashedSession;
-    getCodeEditor(session: Session): ICodeEditor;
-    getSession(editor: ICodeEditor, uri: URI): Session | undefined;
-    private _key;
-    registerSessionKeyComputer(scheme: string, value: ISessionKeyComputer): IDisposable;
-    private readonly _sessions2;
-    private readonly _onDidChangeSessions;
-    readonly onDidChangeSessions: Event<this>;
-    createSession2(editor: ICodeEditor, uri: URI, token: CancellationToken): Promise<IInlineChatSession2>;
-    getSession2(uri: URI): IInlineChatSession2 | undefined;
-    getSessionBySessionUri(sessionResource: URI): IInlineChatSession2 | undefined;
-}
-export declare class InlineChatEnabler {
-    static Id: string;
-    private readonly _ctxHasProvider2;
-    private readonly _ctxHasNotebookProvider;
-    private readonly _ctxPossible;
-    private readonly _store;
-    constructor(contextKeyService: IContextKeyService, chatAgentService: IChatAgentService, editorService: IEditorService, configService: IConfigurationService);
-    dispose(): void;
-}
-export declare class InlineChatEscapeToolContribution extends Disposable {
-    static readonly Id = "inlineChat.escapeTool";
-    static readonly DONT_ASK_AGAIN_KEY = "inlineChat.dontAskMoveToPanelChat";
-    private static readonly _data;
-    constructor(lmTools: ILanguageModelToolsService, inlineChatSessionService: IInlineChatSessionService, dialogService: IDialogService, codeEditorService: ICodeEditorService, chatService: IChatService, logService: ILogService, storageService: IStorageService, instaService: IInstantiationService);
-}

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

@@ -1,495 +0,0 @@
-
-import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
-import { DisposableStore, MutableDisposable, toDisposable, Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
-import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
-import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
-import { assertType } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
-import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
-import { isCodeEditor, isDiffEditor, isCompositeEditor } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser';
-import { ICodeEditorService } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/codeEditorService.service';
-import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
-import { ILanguageService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service';
-import { createTextBufferFactoryFromSnapshot } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model/textModel';
-import { IEditorWorkerService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/editorWorker.service';
-import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service';
-import { ITextModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service';
-import { localize, localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
-import { registerAction2, Action2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
-import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
-import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
-import { IDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service';
-import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
-import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
-import { observableConfigValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/observable/common/platformObservableUtils';
-import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
-import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
-import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
-import { DEFAULT_EDITOR_ASSOCIATION } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor';
-import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
-import { ITextFileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/textfile/common/textfiles.service';
-import { UntitledTextEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/untitled/common/untitledTextEditorInput';
-import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
-import { IChatAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatAgents.service';
-import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
-import { ModifiedFileEntryState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService';
-import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
-import { ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
-import { ToolDataSource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
-import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service';
-import { CTX_INLINE_CHAT_HAS_AGENT2, CTX_INLINE_CHAT_HAS_NOTEBOOK_AGENT, CTX_INLINE_CHAT_POSSIBLE, InlineChatConfigKeys } from '../common/inlineChat.js';
-import { Session, SessionWholeRange, HunkData, StashedSession } from './inlineChatSession.js';
-import { askInPanelChat } from './inlineChatSessionService.js';
-import { IInlineChatSessionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSessionService.service';
-import { observableFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableFromEvent';
-import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
-
-var InlineChatEscapeToolContribution_1;
-class InlineChatError extends Error {
-    static { this.code = 'InlineChatError'; }
-    constructor(message) {
-        super(message);
-        this.name = InlineChatError.code;
-    }
-}
-let InlineChatSessionServiceImpl = class InlineChatSessionServiceImpl {
-    constructor(_telemetryService, _modelService, _textModelService, _editorWorkerService, _logService, _instaService, _editorService, _textFileService, _languageService, _chatService, _chatAgentService, _chatWidgetService) {
-        this._telemetryService = _telemetryService;
-        this._modelService = _modelService;
-        this._textModelService = _textModelService;
-        this._editorWorkerService = _editorWorkerService;
-        this._logService = _logService;
-        this._instaService = _instaService;
-        this._editorService = _editorService;
-        this._textFileService = _textFileService;
-        this._languageService = _languageService;
-        this._chatService = _chatService;
-        this._chatAgentService = _chatAgentService;
-        this._chatWidgetService = _chatWidgetService;
-        this._store = ( new DisposableStore());
-        this._onWillStartSession = this._store.add(( new Emitter()));
-        this.onWillStartSession = this._onWillStartSession.event;
-        this._onDidMoveSession = this._store.add(( new Emitter()));
-        this.onDidMoveSession = this._onDidMoveSession.event;
-        this._onDidEndSession = this._store.add(( new Emitter()));
-        this.onDidEndSession = this._onDidEndSession.event;
-        this._onDidStashSession = this._store.add(( new Emitter()));
-        this.onDidStashSession = this._onDidStashSession.event;
-        this._sessions = ( new Map());
-        this._keyComputers = ( new Map());
-        this._sessions2 = ( new ResourceMap());
-        this._onDidChangeSessions = this._store.add(( new Emitter()));
-        this.onDidChangeSessions = this._onDidChangeSessions.event;
-    }
-    dispose() {
-        this._store.dispose();
-        this._sessions.forEach(x => x.store.dispose());
-        this._sessions.clear();
-    }
-    async createSession(editor, options, token) {
-        const agent = this._chatAgentService.getDefaultAgent(ChatAgentLocation.EditorInline);
-        if (!agent) {
-            this._logService.trace('[IE] NO agent found');
-            return undefined;
-        }
-        this._onWillStartSession.fire(editor);
-        const textModel = editor.getModel();
-        const selection = editor.getSelection();
-        const store = ( new DisposableStore());
-        this._logService.trace(`[IE] creating NEW session for ${editor.getId()}, ${agent.extensionId}`);
-        const chatModelRef = options.session ? undefined : this._chatService.startSession(ChatAgentLocation.EditorInline);
-        const chatModel = options.session?.chatModel ?? chatModelRef?.object;
-        if (!chatModel) {
-            this._logService.trace('[IE] NO chatModel found');
-            chatModelRef?.dispose();
-            return undefined;
-        }
-        if (chatModelRef) {
-            store.add(chatModelRef);
-        }
-        const lastResponseListener = store.add(( new MutableDisposable()));
-        store.add(chatModel.onDidChange(e => {
-            if (e.kind !== 'addRequest' || !e.request.response) {
-                return;
-            }
-            const { response } = e.request;
-            session.markModelVersion(e.request);
-            lastResponseListener.value = response.onDidChange(() => {
-                if (!response.isComplete) {
-                    return;
-                }
-                lastResponseListener.clear();
-                for (const part of response.response.value) {
-                    if (part.kind !== 'textEditGroup' || part.uri.scheme !== Schemas.untitled || isEqual(part.uri, session.textModelN.uri)) {
-                        continue;
-                    }
-                    const langSelection = this._languageService.createByFilepathOrFirstLine(part.uri, undefined);
-                    const untitledTextModel = this._textFileService.untitled.create({
-                        associatedResource: part.uri,
-                        languageId: langSelection.languageId
-                    });
-                    untitledTextModel.resolve();
-                    this._textModelService.createModelReference(part.uri).then(ref => {
-                        store.add(ref);
-                    });
-                }
-            });
-        }));
-        store.add(this._chatAgentService.onDidChangeAgents(e => {
-            if (e === undefined && (!this._chatAgentService.getAgent(agent.id) || !( this._chatAgentService.getActivatedAgents().map(agent => agent.id)).includes(agent.id))) {
-                this._logService.trace(`[IE] provider GONE for ${editor.getId()}, ${agent.extensionId}`);
-                this._releaseSession(session, true);
-            }
-        }));
-        const id = generateUuid();
-        const targetUri = textModel.uri;
-        store.add((await this._textModelService.createModelReference(textModel.uri)));
-        const textModelN = textModel;
-        const textModel0 = store.add(this._modelService.createModel(createTextBufferFactoryFromSnapshot(textModel.createSnapshot()), { languageId: textModel.getLanguageId(), onDidChange: Event.None }, targetUri.with({ scheme: Schemas.vscode, authority: 'inline-chat', path: '', query: ( ( new URLSearchParams({ id, 'textModel0': '' })).toString()) }), true));
-        if (targetUri.scheme === Schemas.untitled) {
-            store.add(this._editorService.onDidCloseEditor(() => {
-                if (!this._editorService.isOpened({ resource: targetUri, typeId: UntitledTextEditorInput.ID, editorId: DEFAULT_EDITOR_ASSOCIATION.id })) {
-                    this._releaseSession(session, true);
-                }
-            }));
-        }
-        let wholeRange = options.wholeRange;
-        if (!wholeRange) {
-            wholeRange = ( new Range(
-                selection.selectionStartLineNumber,
-                selection.selectionStartColumn,
-                selection.positionLineNumber,
-                selection.positionColumn
-            ));
-        }
-        if (token.isCancellationRequested) {
-            store.dispose();
-            return undefined;
-        }
-        const session = ( new Session(
-            options.headless ?? false,
-            targetUri,
-            textModel0,
-            textModelN,
-            agent,
-            store.add(( new SessionWholeRange(textModelN, wholeRange))),
-            store.add(( new HunkData(this._editorWorkerService, textModel0, textModelN))),
-            chatModel,
-            options.session?.versionsByRequest
-        ));
-        const key = this._key(editor, session.targetUri);
-        if (( this._sessions.has(key))) {
-            store.dispose();
-            throw ( new Error(`Session already stored for ${key}`));
-        }
-        this._sessions.set(key, { session, editor, store });
-        return session;
-    }
-    moveSession(session, target) {
-        const newKey = this._key(target, session.targetUri);
-        const existing = this._sessions.get(newKey);
-        if (existing) {
-            if (existing.session !== session) {
-                throw ( new Error(`Cannot move session because the target editor already/still has one`));
-            }
-            else {
-                return;
-            }
-        }
-        let found = false;
-        for (const [oldKey, data] of this._sessions) {
-            if (data.session === session) {
-                found = true;
-                this._sessions.delete(oldKey);
-                this._sessions.set(newKey, { ...data, editor: target });
-                this._logService.trace(`[IE] did MOVE session for ${data.editor.getId()} to NEW EDITOR ${target.getId()}, ${session.agent.extensionId}`);
-                this._onDidMoveSession.fire({ session, editor: target });
-                break;
-            }
-        }
-        if (!found) {
-            throw ( new Error(`Cannot move session because it is not stored`));
-        }
-    }
-    releaseSession(session) {
-        this._releaseSession(session, false);
-    }
-    _releaseSession(session, byServer) {
-        let tuple;
-        for (const candidate of this._sessions) {
-            if (candidate[1].session === session) {
-                tuple = candidate;
-                break;
-            }
-        }
-        if (!tuple) {
-            return;
-        }
-        this._telemetryService.publicLog2('interactiveEditor/session', session.asTelemetryData());
-        const [key, value] = tuple;
-        this._sessions.delete(key);
-        this._logService.trace(`[IE] did RELEASED session for ${value.editor.getId()}, ${session.agent.extensionId}`);
-        this._onDidEndSession.fire({ editor: value.editor, session, endedByExternalCause: byServer });
-        value.store.dispose();
-    }
-    stashSession(session, editor, undoCancelEdits) {
-        const result = this._instaService.createInstance(StashedSession, editor, session, undoCancelEdits);
-        this._onDidStashSession.fire({ editor, session });
-        this._logService.trace(`[IE] did STASH session for ${editor.getId()}, ${session.agent.extensionId}`);
-        return result;
-    }
-    getCodeEditor(session) {
-        for (const [, data] of this._sessions) {
-            if (data.session === session) {
-                return data.editor;
-            }
-        }
-        throw ( new Error('session not found'));
-    }
-    getSession(editor, uri) {
-        const key = this._key(editor, uri);
-        return this._sessions.get(key)?.session;
-    }
-    _key(editor, uri) {
-        const item = this._keyComputers.get(uri.scheme);
-        return item
-            ? item.getComparisonKey(editor, uri)
-            : `${editor.getId()}@${( uri.toString())}`;
-    }
-    registerSessionKeyComputer(scheme, value) {
-        this._keyComputers.set(scheme, value);
-        return toDisposable(() => this._keyComputers.delete(scheme));
-    }
-    async createSession2(editor, uri, token) {
-        assertType(editor.hasModel());
-        if (( this._sessions2.has(uri))) {
-            throw ( new Error('Session already exists'));
-        }
-        this._onWillStartSession.fire(editor);
-        const chatModelRef = this._chatService.startSession(ChatAgentLocation.EditorInline, { canUseTools: false  });
-        const chatModel = chatModelRef.object;
-        chatModel.startEditingSession(false);
-        const widget = this._chatWidgetService.getWidgetBySessionResource(chatModel.sessionResource);
-        await widget?.attachmentModel.addFile(uri);
-        const store = ( new DisposableStore());
-        store.add(toDisposable(() => {
-            this._chatService.cancelCurrentRequestForSession(chatModel.sessionResource);
-            chatModel.editingSession?.reject();
-            this._sessions2.delete(uri);
-            this._onDidChangeSessions.fire(this);
-        }));
-        store.add(chatModelRef);
-        store.add(autorun(r => {
-            const entries = chatModel.editingSession?.entries.read(r);
-            if (!entries?.length) {
-                return;
-            }
-            const state = entries.find(entry => isEqual(entry.modifiedURI, uri))?.state.read(r);
-            if (state === ModifiedFileEntryState.Accepted || state === ModifiedFileEntryState.Rejected) {
-                const response = chatModel.getRequests().at(-1)?.response;
-                if (response) {
-                    this._chatService.notifyUserAction({
-                        sessionResource: response.session.sessionResource,
-                        requestId: response.requestId,
-                        agentId: response.agent?.id,
-                        command: response.slashCommand?.name,
-                        result: response.result,
-                        action: {
-                            kind: 'inlineChat',
-                            action: state === ModifiedFileEntryState.Accepted ? 'accepted' : 'discarded'
-                        }
-                    });
-                }
-            }
-            const allSettled = entries.every(entry => {
-                const state = entry.state.read(r);
-                return (state === ModifiedFileEntryState.Accepted || state === ModifiedFileEntryState.Rejected)
-                    && !entry.isCurrentlyBeingModifiedBy.read(r);
-            });
-            if (allSettled && !chatModel.requestInProgress.read(undefined)) {
-                store.dispose();
-            }
-        }));
-        const result = {
-            uri,
-            initialPosition: editor.getSelection().getStartPosition().delta(-1),
-            initialSelection: editor.getSelection(),
-            chatModel,
-            editingSession: chatModel.editingSession,
-            dispose: store.dispose.bind(store)
-        };
-        this._sessions2.set(uri, result);
-        this._onDidChangeSessions.fire(this);
-        return result;
-    }
-    getSession2(uri) {
-        let result = this._sessions2.get(uri);
-        if (!result) {
-            for (const [_, candidate] of this._sessions2) {
-                const entry = candidate.editingSession.getEntry(uri);
-                if (entry) {
-                    result = candidate;
-                    break;
-                }
-            }
-        }
-        return result;
-    }
-    getSessionBySessionUri(sessionResource) {
-        for (const session of ( this._sessions2.values())) {
-            if (isEqual(session.chatModel.sessionResource, sessionResource)) {
-                return session;
-            }
-        }
-        return undefined;
-    }
-};
-InlineChatSessionServiceImpl = ( __decorate([
-    ( __param(0, ITelemetryService)),
-    ( __param(1, IModelService)),
-    ( __param(2, ITextModelService)),
-    ( __param(3, IEditorWorkerService)),
-    ( __param(4, ILogService)),
-    ( __param(5, IInstantiationService)),
-    ( __param(6, IEditorService)),
-    ( __param(7, ITextFileService)),
-    ( __param(8, ILanguageService)),
-    ( __param(9, IChatService)),
-    ( __param(10, IChatAgentService)),
-    ( __param(11, IChatWidgetService))
-], InlineChatSessionServiceImpl));
-let InlineChatEnabler = class InlineChatEnabler {
-    static { this.Id = 'inlineChat.enabler'; }
-    constructor(contextKeyService, chatAgentService, editorService, configService) {
-        this._store = ( new DisposableStore());
-        this._ctxHasProvider2 = CTX_INLINE_CHAT_HAS_AGENT2.bindTo(contextKeyService);
-        this._ctxHasNotebookProvider = CTX_INLINE_CHAT_HAS_NOTEBOOK_AGENT.bindTo(contextKeyService);
-        this._ctxPossible = CTX_INLINE_CHAT_POSSIBLE.bindTo(contextKeyService);
-        const agentObs = observableFromEvent(this, chatAgentService.onDidChangeAgents, () => chatAgentService.getDefaultAgent(ChatAgentLocation.EditorInline));
-        const notebookAgentObs = observableFromEvent(this, chatAgentService.onDidChangeAgents, () => chatAgentService.getDefaultAgent(ChatAgentLocation.Notebook));
-        const notebookAgentConfigObs = observableConfigValue(InlineChatConfigKeys.notebookAgent, false, configService);
-        this._store.add(autorun(r => {
-            const agent = agentObs.read(r);
-            if (!agent) {
-                this._ctxHasProvider2.reset();
-            }
-            else {
-                this._ctxHasProvider2.set(true);
-            }
-        }));
-        this._store.add(autorun(r => {
-            this._ctxHasNotebookProvider.set(notebookAgentConfigObs.read(r) && !!notebookAgentObs.read(r));
-        }));
-        const updateEditor = () => {
-            const ctrl = editorService.activeEditorPane?.getControl();
-            const isCodeEditorLike = isCodeEditor(ctrl) || isDiffEditor(ctrl) || isCompositeEditor(ctrl);
-            this._ctxPossible.set(isCodeEditorLike);
-        };
-        this._store.add(editorService.onDidActiveEditorChange(updateEditor));
-        updateEditor();
-    }
-    dispose() {
-        this._ctxPossible.reset();
-        this._ctxHasProvider2.reset();
-        this._store.dispose();
-    }
-};
-InlineChatEnabler = ( __decorate([
-    ( __param(0, IContextKeyService)),
-    ( __param(1, IChatAgentService)),
-    ( __param(2, IEditorService)),
-    ( __param(3, IConfigurationService))
-], InlineChatEnabler));
-let InlineChatEscapeToolContribution = class InlineChatEscapeToolContribution extends Disposable {
-    static { InlineChatEscapeToolContribution_1 = this; }
-    static { this.Id = 'inlineChat.escapeTool'; }
-    static { this.DONT_ASK_AGAIN_KEY = 'inlineChat.dontAskMoveToPanelChat'; }
-    static { this._data = {
-        id: 'inline_chat_exit',
-        source: ToolDataSource.Internal,
-        canBeReferencedInPrompt: false,
-        alwaysDisplayInputOutput: false,
-        displayName: ( localize(8342, "Inline Chat to Panel Chat")),
-        modelDescription: 'Moves the inline chat session to the richer panel chat which supports edits across files, creating and deleting files, multi-turn conversations between the user and the assistant, and access to more IDE tools, like retrieve problems, interact with source control, run terminal commands etc.',
-    }; }
-    constructor(lmTools, inlineChatSessionService, dialogService, codeEditorService, chatService, logService, storageService, instaService) {
-        super();
-        this._store.add(lmTools.registerTool(InlineChatEscapeToolContribution_1._data, {
-            invoke: async (invocation, _tokenCountFn, _progress, _token) => {
-                const sessionResource = invocation.context?.sessionResource;
-                if (!sessionResource) {
-                    logService.warn('InlineChatEscapeToolContribution: no sessionId in tool invocation context');
-                    return { content: [{ kind: 'text', value: 'Cancel' }] };
-                }
-                const session = inlineChatSessionService.getSessionBySessionUri(sessionResource);
-                if (!session) {
-                    logService.warn(`InlineChatEscapeToolContribution: no session found for id ${sessionResource}`);
-                    return { content: [{ kind: 'text', value: 'Cancel' }] };
-                }
-                const dontAskAgain = storageService.getBoolean(InlineChatEscapeToolContribution_1.DONT_ASK_AGAIN_KEY, StorageScope.PROFILE);
-                let result;
-                if (dontAskAgain !== undefined) {
-                    result = { confirmed: dontAskAgain, checkboxChecked: false };
-                }
-                else {
-                    result = await dialogService.confirm({
-                        type: 'question',
-                        title: ( localize(8343, "Do you want to continue in Chat view?")),
-                        message: ( localize(8344, "Do you want to continue in Chat view?")),
-                        detail: ( localize(
-                            8345,
-                            "Inline chat is designed for making single-file code changes. Continue your request in the Chat view or rephrase it for inline chat."
-                        )),
-                        primaryButton: ( localize(8346, "Continue in Chat view")),
-                        cancelButton: ( localize(8347, "Cancel")),
-                        checkbox: { label: ( localize(8348, "Don't ask again")), checked: false },
-                    });
-                }
-                const editor = codeEditorService.getFocusedCodeEditor();
-                if (!editor || result.confirmed) {
-                    logService.trace('InlineChatEscapeToolContribution: moving session to panel chat');
-                    await instaService.invokeFunction(askInPanelChat, session.chatModel.getRequests().at(-1), session.chatModel.inputModel.state.get());
-                    session.dispose();
-                }
-                else {
-                    logService.trace('InlineChatEscapeToolContribution: rephrase prompt');
-                    const lastRequest = session.chatModel.getRequests().at(-1);
-                    chatService.removeRequest(session.chatModel.sessionResource, lastRequest.id);
-                    session.chatModel.inputModel.setState({ inputText: lastRequest.message.text });
-                }
-                if (result.checkboxChecked) {
-                    storageService.store(InlineChatEscapeToolContribution_1.DONT_ASK_AGAIN_KEY, result.confirmed, StorageScope.PROFILE, StorageTarget.USER);
-                    logService.trace('InlineChatEscapeToolContribution: stored don\'t ask again preference');
-                }
-                return { content: [{ kind: 'text', value: 'Success' }] };
-            }
-        }));
-    }
-};
-InlineChatEscapeToolContribution = InlineChatEscapeToolContribution_1 = ( __decorate([
-    ( __param(0, ILanguageModelToolsService)),
-    ( __param(1, IInlineChatSessionService)),
-    ( __param(2, IDialogService)),
-    ( __param(3, ICodeEditorService)),
-    ( __param(4, IChatService)),
-    ( __param(5, ILogService)),
-    ( __param(6, IStorageService)),
-    ( __param(7, IInstantiationService))
-], InlineChatEscapeToolContribution));
-registerAction2(class ResetMoveToPanelChatChoice extends Action2 {
-    constructor() {
-        super({
-            id: 'inlineChat.resetMoveToPanelChatChoice',
-            precondition: ( ChatContextKeys.Setup.hidden.negate()),
-            title: ( localize2(8349, "Reset Choice for 'Move Inline Chat to Panel Chat'")),
-            f1: true
-        });
-    }
-    run(accessor) {
-        accessor.get(IStorageService).remove(InlineChatEscapeToolContribution.DONT_ASK_AGAIN_KEY, StorageScope.PROFILE);
-    }
-});
-
-export { InlineChatEnabler, InlineChatError, InlineChatEscapeToolContribution, InlineChatSessionServiceImpl };