@codingame/monaco-vscode-katex-common 24.1.0

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

@@ -0,0 +1,28 @@
+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/chatEditingService";
+import { IChatModel, IChatModelInputState, IChatRequestModel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/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

@@ -0,0 +1,37 @@
+
+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.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

@@ -0,0 +1,95 @@
+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/chatAgents.service";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service";
+import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/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 _ctxHasNotebookInline;
+    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

@@ -0,0 +1,497 @@
+
+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 { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+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/chatAgents.service';
+import { ModifiedFileEntryState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/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/languageModelToolsService';
+import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.service';
+import { CTX_INLINE_CHAT_HAS_AGENT2, CTX_INLINE_CHAT_HAS_NOTEBOOK_INLINE, 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._ctxHasNotebookInline = CTX_INLINE_CHAT_HAS_NOTEBOOK_INLINE.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._ctxHasNotebookInline.set(!notebookAgentConfigObs.read(r) && !!agentObs.read(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(8312, "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(8313, "Do you want to continue in Chat view?")),
+                        message: ( localize(8314, "Do you want to continue in Chat view?")),
+                        detail: ( localize(
+                            8315,
+                            "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(8316, "Continue in Chat view")),
+                        cancelButton: ( localize(8317, "Cancel")),
+                        checkbox: { label: ( localize(8318, "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: ( ( ContextKeyExpr.has('config.chat.disableAIFeatures')).negate()),
+            title: ( localize2(8319, "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 };