@codingame/monaco-vscode-chat-service-override 25.1.2 → 26.0.0

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

@@ -0,0 +1,15 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ILanguageModelsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service";
+import { InlineChatConfigKeys } from "@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/inlineChat/common/inlineChat";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+export declare class InlineChatDefaultModel extends Disposable {
+    private readonly languageModelsService;
+    private readonly logService;
+    static readonly ID = "workbench.contrib.inlineChatDefaultModel";
+    static readonly configName = InlineChatConfigKeys.DefaultModel;
+    static modelIds: string[];
+    static modelLabels: string[];
+    static modelDescriptions: string[];
+    constructor(languageModelsService: ILanguageModelsService, logService: ILogService);
+    private _updateModelValues;
+}

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

@@ -0,0 +1,127 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { Extensions } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configurationRegistry';
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ILanguageModelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service';
+import { InlineChatConfigKeys } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { DEFAULT_MODEL_PICKER_CATEGORY } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/widget/input/modelPickerWidget';
+
+var InlineChatDefaultModel_1;
+let InlineChatDefaultModel = class InlineChatDefaultModel extends Disposable {
+    static {
+        InlineChatDefaultModel_1 = this;
+    }
+    static {
+        this.ID = "workbench.contrib.inlineChatDefaultModel";
+    }
+    static {
+        this.configName = InlineChatConfigKeys.DefaultModel;
+    }
+    static {
+        this.modelIds = [""];
+    }
+    static {
+        this.modelLabels = [( localize(8635, "Auto (Vendor Default)"))];
+    }
+    static {
+        this.modelDescriptions = [( localize(8636, "Use the vendor's default model"))];
+    }
+    constructor(languageModelsService, logService) {
+        super();
+        this.languageModelsService = languageModelsService;
+        this.logService = logService;
+        this._register(
+            languageModelsService.onDidChangeLanguageModels(() => this._updateModelValues())
+        );
+        this._updateModelValues();
+    }
+    _updateModelValues() {
+        try {
+            InlineChatDefaultModel_1.modelIds.length = 0;
+            InlineChatDefaultModel_1.modelLabels.length = 0;
+            InlineChatDefaultModel_1.modelDescriptions.length = 0;
+            InlineChatDefaultModel_1.modelIds.push("");
+            InlineChatDefaultModel_1.modelLabels.push(( localize(8635, "Auto (Vendor Default)")));
+            InlineChatDefaultModel_1.modelDescriptions.push(( localize(8636, "Use the vendor's default model")));
+            const modelIds = this.languageModelsService.getLanguageModelIds();
+            const models = [];
+            for (const modelId of modelIds) {
+                try {
+                    const metadata = this.languageModelsService.lookupLanguageModel(modelId);
+                    if (metadata) {
+                        models.push({
+                            identifier: modelId,
+                            metadata
+                        });
+                    } else {
+                        this.logService.warn(`[InlineChatDefaultModel] No metadata found for model ID: ${modelId}`);
+                    }
+                } catch (e) {
+                    this.logService.error(`[InlineChatDefaultModel] Error looking up model ${modelId}:`, e);
+                }
+            }
+            const supportedModels = models.filter(model => {
+                if (!model.metadata?.isUserSelectable) {
+                    return false;
+                }
+                if (!model.metadata.capabilities?.toolCalling) {
+                    return false;
+                }
+                return true;
+            });
+            supportedModels.sort((a, b) => {
+                const aCategory = a.metadata.modelPickerCategory ?? DEFAULT_MODEL_PICKER_CATEGORY;
+                const bCategory = b.metadata.modelPickerCategory ?? DEFAULT_MODEL_PICKER_CATEGORY;
+                if (aCategory.order !== bCategory.order) {
+                    return aCategory.order - bCategory.order;
+                }
+                return a.metadata.name.localeCompare(b.metadata.name);
+            });
+            for (const model of supportedModels) {
+                try {
+                    const qualifiedName = `${model.metadata.name} (${model.metadata.vendor})`;
+                    InlineChatDefaultModel_1.modelIds.push(qualifiedName);
+                    InlineChatDefaultModel_1.modelLabels.push(model.metadata.name);
+                    InlineChatDefaultModel_1.modelDescriptions.push(model.metadata.tooltip ?? model.metadata.detail ?? "");
+                } catch (e) {
+                    this.logService.error(`[InlineChatDefaultModel] Error adding model ${model.metadata.name}:`, e);
+                }
+            }
+        } catch (e) {
+            this.logService.error("[InlineChatDefaultModel] Error updating model values:", e);
+        }
+    }
+};
+InlineChatDefaultModel = InlineChatDefaultModel_1 = ( __decorate([( __param(0, ILanguageModelsService)), ( __param(1, ILogService))], InlineChatDefaultModel));
+registerWorkbenchContribution2(
+    InlineChatDefaultModel.ID,
+    InlineChatDefaultModel,
+    WorkbenchPhase.BlockRestore
+);
+( Registry.as(Extensions.Configuration)).registerConfiguration({
+    ...{
+        id: "inlineChat",
+        title: ( localize(8637, "Inline Chat")),
+        order: 30,
+        type: "object"
+    },
+    properties: {
+        [InlineChatDefaultModel.configName]: {
+            description: ( localize(
+                8638,
+                "Select the default language model to use for inline chat from the available providers. Model names may include the provider in parentheses, for example 'Claude Haiku 4.5 (copilot)'."
+            )),
+            type: "string",
+            default: "",
+            enum: InlineChatDefaultModel.modelIds,
+            enumItemLabels: InlineChatDefaultModel.modelLabels,
+            markdownEnumDescriptions: InlineChatDefaultModel.modelDescriptions
+        }
+    }
+});
+
+export { InlineChatDefaultModel };

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

@@ -1,48 +1,16 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { illegalState } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
 import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 import { InlineChatController } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatController';
 import { IInlineChatSessionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSessionService.service';
 import { INotebookEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/services/notebookEditorService.service';
 import { CellUri } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
 import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
-import { NotebookTextDiffEditor } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/notebook/browser/diff/notebookDiffEditor';
-import { NotebookMultiTextDiffEditor } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/notebook/browser/diff/notebookMultiDiffEditor';
 
 let InlineChatNotebookContribution = class InlineChatNotebookContribution {
     constructor(sessionService, editorService, notebookEditorService) {
         this._store = ( new DisposableStore());
-        this._store.add(sessionService.registerSessionKeyComputer(Schemas.vscodeNotebookCell, {
-            getComparisonKey: (editor, uri) => {
-                const data = CellUri.parse(uri);
-                if (!data) {
-                    throw illegalState('Expected notebook cell uri');
-                }
-                let fallback;
-                for (const notebookEditor of notebookEditorService.listNotebookEditors()) {
-                    if (notebookEditor.hasModel() && isEqual(notebookEditor.textModel.uri, data.notebook)) {
-                        const candidate = `<notebook>${notebookEditor.getId()}#${uri}`;
-                        if (!fallback) {
-                            fallback = candidate;
-                        }
-                        if (notebookEditor.codeEditors.find((tuple) => tuple[1] === editor)) {
-                            return candidate;
-                        }
-                    }
-                }
-                if (fallback) {
-                    return fallback;
-                }
-                const activeEditor = editorService.activeEditorPane;
-                if (activeEditor && (activeEditor.getId() === NotebookTextDiffEditor.ID || activeEditor.getId() === NotebookMultiTextDiffEditor.ID)) {
-                    return `<notebook>${editor.getId()}#${uri}`;
-                }
-                throw illegalState('Expected notebook editor');
-            }
-        }));
         this._store.add(sessionService.onWillStartSession(newSessionEditor => {
             const candidate = CellUri.parse(newSessionEditor.getModel().uri);
             if (!candidate) {
@@ -72,10 +40,6 @@ let InlineChatNotebookContribution = class InlineChatNotebookContribution {
         this._store.dispose();
     }
 };
-InlineChatNotebookContribution = ( __decorate([
-    ( __param(0, IInlineChatSessionService)),
-    ( __param(1, IEditorService)),
-    ( __param(2, INotebookEditorService))
-], InlineChatNotebookContribution));
+InlineChatNotebookContribution = ( __decorate([( __param(0, IInlineChatSessionService)), ( __param(1, IEditorService)), ( __param(2, INotebookEditorService))], InlineChatNotebookContribution));
 
 export { InlineChatNotebookContribution };

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

@@ -0,0 +1,16 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+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";
+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,21 @@
+
+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 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 };

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

@@ -0,0 +1,51 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IActiveCodeEditor } 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 { 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 { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.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 { IInlineChatSession2 } 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 _chatService;
+    _serviceBrand: undefined;
+    private readonly _store;
+    private readonly _sessions;
+    private readonly _onWillStartSession;
+    readonly onWillStartSession: Event<IActiveCodeEditor>;
+    private readonly _onDidChangeSessions;
+    readonly onDidChangeSessions: Event<this>;
+    constructor(_chatService: IChatService, chatAgentService: IChatAgentService);
+    dispose(): void;
+    createSession(editor: IActiveCodeEditor): IInlineChatSession2;
+    getSessionByTextModel(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

@@ -0,0 +1,334 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { DisposableStore, dispose, 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 '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+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 { 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 { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.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 '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
+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(_chatService, chatAgentService) {
+        this._chatService = _chatService;
+        this._store = ( new DisposableStore());
+        this._sessions = ( new ResourceMap());
+        this._onWillStartSession = this._store.add(( new Emitter()));
+        this.onWillStartSession = this._onWillStartSession.event;
+        this._onDidChangeSessions = this._store.add(( new Emitter()));
+        this.onDidChangeSessions = this._onDidChangeSessions.event;
+        const agentObs = observableFromEvent(
+            this,
+            chatAgentService.onDidChangeAgents,
+            () => chatAgentService.getDefaultAgent(ChatAgentLocation.EditorInline)
+        );
+        this._store.add(autorun(r => {
+            const agent = agentObs.read(r);
+            if (!agent) {
+                dispose(( this._sessions.values()));
+                this._sessions.clear();
+            }
+        }));
+    }
+    dispose() {
+        this._store.dispose();
+    }
+    createSession(editor) {
+        const uri = editor.getModel().uri;
+        if (( this._sessions.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 store = ( new DisposableStore());
+        store.add(toDisposable(() => {
+            this._chatService.cancelCurrentRequestForSession(chatModel.sessionResource);
+            chatModel.editingSession?.reject();
+            this._sessions.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._sessions.set(uri, result);
+        this._onDidChangeSessions.fire(this);
+        return result;
+    }
+    getSessionByTextModel(uri) {
+        let result = this._sessions.get(uri);
+        if (!result) {
+            for (const [_, candidate] of this._sessions) {
+                const entry = candidate.editingSession.getEntry(uri);
+                if (entry) {
+                    result = candidate;
+                    break;
+                }
+            }
+        }
+        return result;
+    }
+    getSessionBySessionUri(sessionResource) {
+        for (const session of ( this._sessions.values())) {
+            if (isEqual(session.chatModel.sessionResource, sessionResource)) {
+                return session;
+            }
+        }
+        return undefined;
+    }
+};
+InlineChatSessionServiceImpl = ( __decorate([( __param(0, IChatService)), ( __param(1, IChatAgentService))], 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(8647, "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(8648, "Do you want to continue in Chat view?")),
+                        message: ( localize(8649, "Do you want to continue in Chat view?")),
+                        detail: ( localize(
+                            8650,
+                            "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(8651, "Continue in Chat view")),
+                        cancelButton: ( localize(8652, "Cancel")),
+                        checkbox: {
+                            label: ( localize(8653, "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(8654, "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 };