@codingame/monaco-vscode-api 26.2.2 → 28.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/attachments/chatDynamicVariables.js

@@ -0,0 +1,243 @@
+
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { coalesce } from '../../../../../base/common/arrays.js';
+import { MarkdownString } from '../../../../../base/common/htmlContent.js';
+import { Disposable, MutableDisposable, dispose, isDisposable } from '../../../../../base/common/lifecycle.js';
+import { URI } from '../../../../../base/common/uri.js';
+import { Range } from '../../../../../editor/common/core/range.js';
+import { isLocation } from '../../../../../editor/common/languages.js';
+import { Action2, registerAction2 } from '../../../../../platform/actions/common/actions.js';
+import { ICommandService } from '../../../../../platform/commands/common/commands.service.js';
+import { ILabelService } from '../../../../../platform/label/common/label.service.js';
+import { addDynamicVariableActionId } from '../widget/input/editor/chatDynamicVariablesConstant.js';
+
+var ChatDynamicVariableModel_1;
+const dynamicVariableDecorationType = "chat-dynamic-variable";
+let ChatDynamicVariableModel = class ChatDynamicVariableModel extends Disposable {
+    static {
+        ChatDynamicVariableModel_1 = this;
+    }
+    static {
+        this.ID = "chatDynamicVariableModel";
+    }
+    get variables() {
+        return [...this._variables];
+    }
+    get id() {
+        return ChatDynamicVariableModel_1.ID;
+    }
+    constructor(widget, labelService) {
+        super();
+        this.widget = widget;
+        this.labelService = labelService;
+        this._variables = [];
+        this.decorationData = [];
+        this._editorListener = this._register(( new MutableDisposable()));
+        this._subscribeToEditor();
+        this._register(widget.onDidChangeActiveInputEditor(() => {
+            this._subscribeToEditor();
+            this.updateDecorations();
+        }));
+    }
+    _subscribeToEditor() {
+        this._editorListener.value = this.widget.inputEditor.onDidChangeModelContent(e => {
+            const removed = [];
+            let didChange = false;
+            this._variables = coalesce(( this._variables.map((ref, idx) => {
+                const model = this.widget.inputEditor.getModel();
+                if (!model) {
+                    removed.push(ref);
+                    return null;
+                }
+                const data = this.decorationData[idx];
+                if (!data) {
+                    removed.push(ref);
+                    return null;
+                }
+                const newRange = model.getDecorationRange(data.id);
+                if (!newRange) {
+                    removed.push(ref);
+                    return null;
+                }
+                const newText = model.getValueInRange(newRange);
+                if (newText !== data.text) {
+                    this.widget.inputEditor.executeEdits(this.id, [{
+                        range: newRange,
+                        text: ""
+                    }]);
+                    this.widget.refreshParsedInput();
+                    removed.push(ref);
+                    return null;
+                }
+                if (newRange.equalsRange(ref.range)) {
+                    return ref;
+                }
+                didChange = true;
+                return {
+                    ...ref,
+                    range: newRange
+                };
+            })));
+            dispose(removed.filter(isDisposable));
+            if (didChange || removed.length > 0) {
+                this.widget.refreshParsedInput();
+            }
+            this.updateDecorations();
+        });
+    }
+    getInputState(contrib) {
+        contrib[ChatDynamicVariableModel_1.ID] = this.variables;
+    }
+    setInputState(contrib) {
+        let s = contrib[ChatDynamicVariableModel_1.ID];
+        if (!Array.isArray(s)) {
+            s = [];
+        }
+        this.disposeVariables();
+        this._variables = [];
+        for (const variable of s) {
+            if (!isDynamicVariable(variable)) {
+                continue;
+            }
+            this.addReference(variable);
+        }
+    }
+    addReference(ref) {
+        if (!isValidEditorRange(ref.range)) {
+            return;
+        }
+        this._variables.push(ref);
+        this.updateDecorations();
+        this.widget.refreshParsedInput();
+    }
+    updateDecorations() {
+        const model = this.widget.inputEditor.getModel();
+        if (!model) {
+            this.decorationData = [];
+            return;
+        }
+        const validVariables = this._variables.filter(v => isValidEditorRange(v.range));
+        const decorationIds = this.widget.inputEditor.setDecorationsByType("chat", dynamicVariableDecorationType, ( validVariables.map(r => ({
+            range: r.range,
+            hoverMessage: this.getHoverForReference(r)
+        }))));
+        this._variables = validVariables.slice(0, decorationIds.length);
+        this.decorationData = [];
+        for (let i = 0; i < decorationIds.length; i++) {
+            this.decorationData.push({
+                id: decorationIds[i],
+                text: model.getValueInRange(this._variables[i].range)
+            });
+        }
+    }
+    getHoverForReference(ref) {
+        const value = ref.data;
+        if (URI.isUri(value)) {
+            return ( new MarkdownString(this.labelService.getUriLabel(value, {
+                relative: true
+            })));
+        } else if (isLocation(value)) {
+            const prefix = ref.fullName ? ` ${ref.fullName}` : "";
+            const rangeString = `#${value.range.startLineNumber}-${value.range.endLineNumber}`;
+            return ( new MarkdownString(prefix + this.labelService.getUriLabel(value.uri, {
+                relative: true
+            }) + rangeString));
+        } else {
+            return undefined;
+        }
+    }
+    disposeVariables() {
+        for (const variable of this._variables) {
+            if (isDisposable(variable)) {
+                variable.dispose();
+            }
+        }
+    }
+    dispose() {
+        this.disposeVariables();
+        super.dispose();
+    }
+};
+ChatDynamicVariableModel = ChatDynamicVariableModel_1 = ( __decorate([( __param(1, ILabelService))], ChatDynamicVariableModel));
+function isDynamicVariable(obj) {
+    return obj && typeof obj.id === "string" && Range.isIRange(obj.range) && isValidEditorRange(obj.range) && "data" in obj;
+}
+function isValidEditorRange(range) {
+    if (range.startLineNumber < 1 || range.endLineNumber < 1 || range.startColumn < 1 || range.endColumn < 1) {
+        return false;
+    }
+    if (range.startLineNumber > range.endLineNumber) {
+        return false;
+    }
+    if (range.startLineNumber === range.endLineNumber && range.startColumn >= range.endColumn) {
+        return false;
+    }
+    return true;
+}
+function isAddDynamicVariableContext(context) {
+    return "widget" in context && "range" in context && "variableData" in context;
+}
+class AddDynamicVariableAction extends Action2 {
+    static {
+        this.ID = addDynamicVariableActionId;
+    }
+    constructor() {
+        super({
+            id: AddDynamicVariableAction.ID,
+            title: ""
+        });
+    }
+    async run(accessor, ...args) {
+        const context = args[0];
+        if (!isAddDynamicVariableContext(context)) {
+            return;
+        }
+        let range = context.range;
+        const variableData = context.variableData;
+        const doCleanup = () => {
+            context.widget.inputEditor.executeEdits("chatInsertDynamicVariableWithArguments", [{
+                range: context.range,
+                text: ``
+            }]);
+        };
+        if (context.command) {
+            const commandService = accessor.get(ICommandService);
+            const selection = await commandService.executeCommand(context.command.id, ...(context.command.arguments ?? []));
+            if (!selection) {
+                doCleanup();
+                return;
+            }
+            const insertText = ":" + selection;
+            const insertRange = ( new Range(
+                range.startLineNumber,
+                range.endColumn,
+                range.endLineNumber,
+                range.endColumn + insertText.length
+            ));
+            range = ( new Range(
+                range.startLineNumber,
+                range.startColumn,
+                range.endLineNumber,
+                range.endColumn + insertText.length
+            ));
+            const editor = context.widget.inputEditor;
+            const success = editor.executeEdits("chatInsertDynamicVariableWithArguments", [{
+                range: insertRange,
+                text: insertText + " "
+            }]);
+            if (!success) {
+                doCleanup();
+                return;
+            }
+        }
+        context.widget.getContrib(ChatDynamicVariableModel.ID)?.addReference({
+            id: context.id,
+            range: range,
+            isFile: true,
+            data: variableData
+        });
+    }
+}
+registerAction2(AddDynamicVariableAction);
+
+export { AddDynamicVariableAction, ChatDynamicVariableModel, dynamicVariableDecorationType };

package/vscode/src/vs/workbench/contrib/chat/browser/attachments/chatScreenshotContext.js

@@ -5,7 +5,7 @@ const ScreenshotVariableId = "screenshot-focused-window";
 function convertBufferToScreenshotVariable(buffer) {
     return {
         id: ScreenshotVariableId,
-        name: ( localize(5110, "Screenshot")),
+        name: ( localize(5426, "Screenshot")),
         value: buffer.buffer,
         kind: "image"
     };

package/vscode/src/vs/workbench/contrib/chat/browser/attachments/chatVariables.d.ts

@@ -0,0 +1,15 @@
+import { IDynamicVariable } from "../../common/attachments/chatVariables.js";
+import { IChatVariablesService } from "../../common/attachments/chatVariables.service.js";
+import { IToolAndToolSetEnablementMap } from "../../common/tools/languageModelToolsService.js";
+import { IChatWidget } from "../chat.js";
+import { IChatWidgetService } from "../chat.service.js";
+import { URI } from "../../../../../base/common/uri.js";
+export declare function getDynamicVariablesForWidget(widget: IChatWidget): ReadonlyArray<IDynamicVariable>;
+export declare function getSelectedToolAndToolSetsForWidget(widget: IChatWidget): IToolAndToolSetEnablementMap;
+export declare class ChatVariablesService implements IChatVariablesService {
+    private readonly chatWidgetService;
+    _serviceBrand: undefined;
+    constructor(chatWidgetService: IChatWidgetService);
+    getDynamicVariables(sessionResource: URI): ReadonlyArray<IDynamicVariable>;
+    getSelectedToolAndToolSets(sessionResource: URI): IToolAndToolSetEnablementMap;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/attachments/chatVariables.js

@@ -0,0 +1,76 @@
+
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { IChatWidgetService } from '../chat.service.js';
+import { ChatDynamicVariableModel } from './chatDynamicVariables.js';
+import { Range } from '../../../../../editor/common/core/range.js';
+
+function getDynamicVariablesForWidget(widget) {
+    if (!widget.viewModel || !widget.supportsFileReferences) {
+        return [];
+    }
+    const model = widget.getContrib(ChatDynamicVariableModel.ID);
+    if (!model) {
+        return [];
+    }
+    if (widget.viewModel.editing && model.variables.length > 0) {
+        return model.variables;
+    }
+    if (widget.input.attachmentModel.attachments.length > 0 && widget.viewModel.editing) {
+        const references = [];
+        const editorModel = widget.inputEditor.getModel();
+        const modelTextLength = editorModel?.getValueLength() ?? 0;
+        for (const attachment of widget.input.attachmentModel.attachments) {
+            if (attachment.range) {
+                if (attachment.range.start >= attachment.range.endExclusive) {
+                    continue;
+                }
+                if (attachment.range.start < 0 || attachment.range.endExclusive > modelTextLength) {
+                    continue;
+                }
+                if (!editorModel) {
+                    continue;
+                }
+                const startPos = editorModel.getPositionAt(attachment.range.start);
+                const endPos = editorModel.getPositionAt(attachment.range.endExclusive);
+                const referenceObj = {
+                    id: attachment.id,
+                    fullName: attachment.name,
+                    modelDescription: attachment.modelDescription,
+                    range: ( new Range(startPos.lineNumber, startPos.column, endPos.lineNumber, endPos.column)),
+                    icon: attachment.icon,
+                    isFile: attachment.kind === "file",
+                    isDirectory: attachment.kind === "directory",
+                    data: attachment.value
+                };
+                references.push(referenceObj);
+            }
+        }
+        return references.length > 0 ? references : model.variables;
+    }
+    return model.variables;
+}
+function getSelectedToolAndToolSetsForWidget(widget) {
+    return widget.input.selectedToolsModel.entriesMap.get();
+}
+let ChatVariablesService = class ChatVariablesService {
+    constructor(chatWidgetService) {
+        this.chatWidgetService = chatWidgetService;
+    }
+    getDynamicVariables(sessionResource) {
+        const widget = this.chatWidgetService.getWidgetBySessionResource(sessionResource);
+        if (!widget) {
+            return [];
+        }
+        return getDynamicVariablesForWidget(widget);
+    }
+    getSelectedToolAndToolSets(sessionResource) {
+        const widget = this.chatWidgetService.getWidgetBySessionResource(sessionResource);
+        if (!widget) {
+            return ( new Map());
+        }
+        return getSelectedToolAndToolSetsForWidget(widget);
+    }
+};
+ChatVariablesService = ( __decorate([( __param(0, IChatWidgetService))], ChatVariablesService));
+
+export { ChatVariablesService, getDynamicVariablesForWidget, getSelectedToolAndToolSetsForWidget };

package/vscode/src/vs/workbench/contrib/chat/browser/chat.d.ts

@@ -160,6 +160,7 @@ export interface IChatWidgetViewOptions {
     enableWorkingSet?: "explicit" | "implicit";
     supportsChangingModes?: boolean;
     dndContainer?: HTMLElement;
+    inputEditorMinLines?: number;
     defaultMode?: IChatMode;
     /**
      * Optional delegate for the session target picker.
@@ -183,6 +184,11 @@ export interface IChatWidgetViewOptions {
      * redirect to a different workspace rather than executing locally.
      */
     submitHandler?: (query: string, mode: ChatModeKind) => Promise<boolean>;
+    /**
+     * Whether we are running in the sessions window.
+     * When true, the secondary toolbar (permissions picker) is hidden.
+     */
+    isSessionsWindow?: boolean;
 }
 export interface IChatViewViewContext {
     viewId: string;
@@ -204,6 +210,11 @@ export interface IChatAcceptInputOptions {
      * If Steering, also sets yieldRequested on any active request to signal it should wrap up.
      */
     queue?: ChatRequestQueueKind;
+    /**
+     * When true, always queues the request regardless of whether a request is currently in progress.
+     * The request stays in the pending queue until explicitly processed.
+     */
+    alwaysQueue?: boolean;
 }
 export interface IChatWidgetViewModelChangeEvent {
     readonly previousSessionResource: URI | undefined;
@@ -224,6 +235,7 @@ export interface IChatWidget {
         slashCommand?: IChatAgentCommand;
     }>;
     readonly onDidChangeParsedInput: Event<void>;
+    readonly onDidChangeActiveInputEditor: Event<void>;
     readonly onDidFocus: Event<void>;
     readonly location: ChatAgentLocation;
     readonly viewContext: IChatWidgetViewContext;
@@ -261,6 +273,42 @@ export interface IChatWidget {
      */
     focusResponseItem(lastFocused?: boolean): void;
     focusInput(): void;
+    /**
+     * Focuses the Todos view in the chat widget.
+     * @returns Whether the operation succeeded (i.e., the Todos view was focused).
+     */
+    focusTodosView(): boolean;
+    /**
+     * Toggles focus between the Todos view and the previous focus target in the chat widget.
+     * @returns Whether the operation succeeded (i.e., the focus was toggled).
+     */
+    toggleTodosViewFocus(): boolean;
+    /**
+     * Focuses the question carousel in the chat widget.
+     * @returns Whether the operation succeeded (i.e., the question carousel was focused).
+     */
+    focusQuestionCarousel(): boolean;
+    /**
+     * Toggles focus between the question carousel and the chat input.
+     * @returns Whether the operation succeeded (i.e., the focus was toggled).
+     */
+    toggleQuestionCarouselFocus(): boolean;
+    /**
+     * Navigates to the previous question in the question carousel.
+     * @returns Whether the operation succeeded (i.e., a previous question exists).
+     */
+    navigateToPreviousQuestion(): boolean;
+    /**
+     * Navigates to the next question in the question carousel.
+     * @returns Whether the operation succeeded (i.e., a next question exists).
+     */
+    navigateToNextQuestion(): boolean;
+    /**
+     * Toggles focus between the tip widget and the chat input.
+     * Returns false if no tip is visible.
+     * @returns Whether the operation succeeded (i.e., the focus was toggled).
+     */
+    toggleTipFocus(): boolean;
     hasInputFocus(): boolean;
     getModeRequestOptions(): Partial<IChatSendRequestOptions>;
     getCodeBlockInfoForEditor(uri: URI): IChatCodeBlockInfo | undefined;

package/vscode/src/vs/workbench/contrib/chat/browser/chat.service.d.ts

@@ -25,6 +25,15 @@ export interface IChatWidgetService {
     */
     readonly onDidBackgroundSession: Event<URI>;
     /**
+    * Fires when the focused chat widget changes.
+    */
+    readonly onDidChangeFocusedWidget: Event<IChatWidget | undefined>;
+    /**
+    * Fires when the focused chat session changes, either because the focused widget
+    * changed or because the focused widget loaded a different session.
+    */
+    readonly onDidChangeFocusedSession: Event<void>;
+    /**
     * Reveals the widget, focusing its input unless `preserveFocus` is true.
     */
     reveal(widget: IChatWidget, preserveFocus?: boolean): Promise<boolean>;

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditing/chatEditingEditorContextKeys.js

@@ -17,16 +17,16 @@ import { autorun } from '../../../../../base/common/observableInternal/reactions
 import { derived } from '../../../../../base/common/observableInternal/observables/derived.js';
 import { constObservable } from '../../../../../base/common/observableInternal/observables/constObservable.js';
 
-const ctxIsGlobalEditingSession = ( new RawContextKey("chatEdits.isGlobalEditingSession", undefined, ( localize(5342, "The current editor is part of the global edit session"))));
-const ctxHasEditorModification = ( new RawContextKey("chatEdits.hasEditorModifications", undefined, ( localize(5343, "The current editor contains chat modifications"))));
-const ctxIsCurrentlyBeingModified = ( new RawContextKey("chatEdits.isCurrentlyBeingModified", undefined, ( localize(5344, "The current editor is currently being modified"))));
-const ctxReviewModeEnabled = ( new RawContextKey("chatEdits.isReviewModeEnabled", true, ( localize(5345, "Review mode for chat changes is enabled"))));
+const ctxIsGlobalEditingSession = ( new RawContextKey("chatEdits.isGlobalEditingSession", undefined, ( localize(5844, "The current editor is part of the global edit session"))));
+const ctxHasEditorModification = ( new RawContextKey("chatEdits.hasEditorModifications", undefined, ( localize(5845, "The current editor contains chat modifications"))));
+const ctxIsCurrentlyBeingModified = ( new RawContextKey("chatEdits.isCurrentlyBeingModified", undefined, ( localize(5846, "The current editor is currently being modified"))));
+const ctxReviewModeEnabled = ( new RawContextKey("chatEdits.isReviewModeEnabled", true, ( localize(5847, "Review mode for chat changes is enabled"))));
 const ctxHasRequestInProgress = ( new RawContextKey("chatEdits.isRequestInProgress", false, ( localize(
-    5346,
+    5848,
     "The current editor shows a file from an edit session which is still in progress"
 ))));
-const ctxRequestCount = ( new RawContextKey("chatEdits.requestCount", 0, ( localize(5347, "The number of turns the editing session in this editor has"))));
-const ctxCursorInChangeRange = ( new RawContextKey("chatEdits.cursorInChangeRange", false, ( localize(5348, "The cursor is inside a change range made by chat editing."))));
+const ctxRequestCount = ( new RawContextKey("chatEdits.requestCount", 0, ( localize(5849, "The number of turns the editing session in this editor has"))));
+const ctxCursorInChangeRange = ( new RawContextKey("chatEdits.cursorInChangeRange", false, ( localize(5850, "The cursor is inside a change range made by chat editing."))));
 let ChatEditingEditorContextKeys = class ChatEditingEditorContextKeys {
     static {
         this.ID = "chat.edits.editorContextKeys";

package/vscode/src/vs/workbench/contrib/chat/browser/chatTipService.service.d.ts

@@ -1,15 +1,81 @@
+import { Event } from "../../../../base/common/event.js";
 import { IContextKeyService } from "../../../../platform/contextkey/common/contextkey.service.js";
 import { IChatTip } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/chat/browser/chatTipService";
 export declare const IChatTipService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatTipService>;
 export interface IChatTipService {
     readonly _serviceBrand: undefined;
     /**
-    * Gets a tip to show for a request, or undefined if a tip has already been shown this session.
-    * Only one tip is shown per VS Code session (resets on reload).
-    * Tips are only shown for requests created after the service was instantiated.
-    * @param requestId The unique ID of the request (used for stable rerenders).
-    * @param requestTimestamp The timestamp when the request was created.
-    * @param contextKeyService The context key service to evaluate tip eligibility.
+    * Fired when the current tip is dismissed.
     */
-    getNextTip(requestId: string, requestTimestamp: number, contextKeyService: IContextKeyService): IChatTip | undefined;
+    readonly onDidDismissTip: Event<void>;
+    /**
+    * Fired when the user navigates to a different tip (previous/next).
+    */
+    readonly onDidNavigateTip: Event<IChatTip>;
+    /**
+    * Fired when the tip widget is hidden without dismissing the tip.
+    */
+    readonly onDidHideTip: Event<void>;
+    /**
+    * Fired when tips are disabled.
+    */
+    readonly onDidDisableTips: Event<void>;
+    /**
+    * Gets a tip to show on the welcome/getting-started view.
+    * Returns the same tip on repeated calls for stable rerenders.
+    */
+    getWelcomeTip(contextKeyService: IContextKeyService): IChatTip | undefined;
+    /**
+    * Resets tip state for a new conversation.
+    * Call this when the chat widget binds to a new model.
+    */
+    resetSession(): void;
+    /**
+    * Dismisses the current tip and allows a new one to be picked for the same request.
+    * The dismissed tip will not be shown again for this user on this application installation.
+    */
+    dismissTip(): void;
+    /**
+    * Dismisses the current tip and hides all tips for the rest of the current chat session.
+    */
+    dismissTipForSession(): void;
+    /**
+    * Hides the tip widget without permanently dismissing the tip.
+    * The tip may be shown again in a future session.
+    */
+    hideTip(): void;
+    /**
+    * Hides all tips for the rest of the current chat session.
+    */
+    hideTipsForSession(): void;
+    /**
+    * Disables tips permanently by setting the `chat.tips.enabled` configuration to false.
+    */
+    disableTips(): Promise<void>;
+    /**
+    * Navigates to the next tip in the catalog without permanently dismissing the current one.
+    */
+    navigateToNextTip(): IChatTip | undefined;
+    /**
+    * Navigates to the previous tip in the catalog without permanently dismissing the current one.
+    */
+    navigateToPreviousTip(): IChatTip | undefined;
+    /**
+    * Gets the next eligible tip after the current one, without requiring multiple tips.
+    * Used after dismissing a tip to show the next available tip (even if it's the only one left).
+    */
+    getNextEligibleTip(): IChatTip | undefined;
+    /**
+    * Returns whether there are multiple eligible tips for navigation.
+    */
+    hasMultipleTips(): boolean;
+    /**
+    * Records usage of a slash command to update tip eligibility for flows where
+    * the slash command text is transformed before request submission.
+    */
+    recordSlashCommandUsage(command: string): void;
+    /**
+    * Clears all dismissed tips so they can be shown again.
+    */
+    clearDismissedTips(): void;
 }

package/vscode/src/vs/workbench/contrib/chat/browser/promptSyntax/promptFileRewriter.js

@@ -34,7 +34,7 @@ let PromptFileRewriter = class PromptFileRewriter {
             this.rewriteAttribute(model, "", toolsAttr.range);
             return;
         } else {
-            this.rewriteTools(model, newTools, toolsAttr.value.range, toolsAttr.value.type === "string");
+            this.rewriteTools(model, newTools, toolsAttr.value.range, toolsAttr.value.type === "scalar");
         }
     }
     rewriteTools(model, newTools, range, isString) {
@@ -64,7 +64,7 @@ let PromptFileRewriter = class PromptFileRewriter {
         if (!nameAttr) {
             return;
         }
-        if (nameAttr.value.type === "string" && nameAttr.value.value === newName) {
+        if (nameAttr.value.type === "scalar" && nameAttr.value.value === newName) {
             return;
         }
         editor.setSelection(nameAttr.range);

package/vscode/src/vs/workbench/contrib/chat/browser/widgetHosts/editor/chatEditorInput.d.ts

@@ -18,6 +18,7 @@ export declare class ChatEditorInput extends EditorInput implements IEditorClose
     private readonly chatService;
     private readonly dialogService;
     private readonly chatSessionsService;
+    private readonly instantiationService;
     static readonly TypeID: string;
     static readonly EditorID: string;
     private _sessionResource;
@@ -32,13 +33,14 @@ export declare class ChatEditorInput extends EditorInput implements IEditorClose
     private readonly modelRef;
     private get model();
     static getNewEditorUri(): URI;
-    constructor(resource: URI, options: IChatEditorOptions, chatService: IChatService, dialogService: IDialogService, chatSessionsService: IChatSessionsService);
+    constructor(resource: URI, options: IChatEditorOptions, chatService: IChatService, dialogService: IDialogService, chatSessionsService: IChatSessionsService, instantiationService: IInstantiationService);
     closeHandler: this;
     showConfirm(): boolean;
     transferOutEditingSession(): IChatEditingSession | undefined;
     confirm(editors: ReadonlyArray<IEditorIdentifier>): Promise<ConfirmResult>;
     get editorId(): string | undefined;
     get capabilities(): EditorInputCapabilities;
+    copy(): EditorInput;
     matches(otherInput: EditorInput | IUntypedEditorInput): boolean;
     get typeId(): string;
     getName(): string;