@codingame/monaco-vscode-katex-common 24.1.0

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/computeAutomaticInstructions.js

@@ -0,0 +1,373 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { splitGlobAware, match } from '@codingame/monaco-vscode-api/vscode/vs/base/common/glob';
+import { ResourceMap, ResourceSet } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { dirname, basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { toPromptFileVariableEntry, PromptFileVariableKind, isPromptFileVariableEntry, IChatRequestVariableEntry, ChatRequestVariableSet, toToolVariableEntry, toPromptTextVariableEntry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatVariableEntries';
+import { VSCodeToolReference } 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 { PromptsConfig } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/config/config';
+import { isPromptOrInstructionsFile } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/config/promptFileLocations';
+import { PromptsType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import { IPromptsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service';
+import { OffsetRange } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/ranges/offsetRange';
+import { ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+
+function newInstructionsCollectionEvent() {
+    return { applyingInstructionsCount: 0, referencedInstructionsCount: 0, agentInstructionsCount: 0, listedInstructionsCount: 0, totalInstructionsCount: 0 };
+}
+let ComputeAutomaticInstructions = class ComputeAutomaticInstructions {
+    constructor(_enabledTools, _promptsService, _logService, _labelService, _configurationService, _workspaceService, _fileService, _telemetryService, _languageModelToolsService) {
+        this._enabledTools = _enabledTools;
+        this._promptsService = _promptsService;
+        this._logService = _logService;
+        this._labelService = _labelService;
+        this._configurationService = _configurationService;
+        this._workspaceService = _workspaceService;
+        this._fileService = _fileService;
+        this._telemetryService = _telemetryService;
+        this._languageModelToolsService = _languageModelToolsService;
+        this._parseResults = ( new ResourceMap());
+    }
+    async _parseInstructionsFile(uri, token) {
+        if (( this._parseResults.has(uri))) {
+            return this._parseResults.get(uri);
+        }
+        try {
+            const result = await this._promptsService.parseNew(uri, token);
+            this._parseResults.set(uri, result);
+            return result;
+        }
+        catch (error) {
+            this._logService.error(`[InstructionsContextComputer] Failed to parse instruction file: ${uri}`, error);
+            return undefined;
+        }
+    }
+    async collect(variables, token) {
+        const instructionFiles = await this._promptsService.listPromptFiles(PromptsType.instructions, token);
+        this._logService.trace(`[InstructionsContextComputer] ${instructionFiles.length} instruction files available.`);
+        const telemetryEvent = newInstructionsCollectionEvent();
+        const context = this._getContext(variables);
+        await this.addApplyingInstructions(instructionFiles, context, variables, telemetryEvent, token);
+        await this._addReferencedInstructions(variables, telemetryEvent, token);
+        await this._addAgentInstructions(variables, telemetryEvent, token);
+        const instructionsListVariable = await this._getInstructionsWithPatternsList(instructionFiles, variables, token);
+        if (instructionsListVariable) {
+            variables.add(instructionsListVariable);
+            telemetryEvent.listedInstructionsCount++;
+        }
+        this.sendTelemetry(telemetryEvent);
+    }
+    sendTelemetry(telemetryEvent) {
+        telemetryEvent.totalInstructionsCount = telemetryEvent.agentInstructionsCount + telemetryEvent.referencedInstructionsCount + telemetryEvent.applyingInstructionsCount + telemetryEvent.listedInstructionsCount;
+        this._telemetryService.publicLog2('instructionsCollected', telemetryEvent);
+    }
+    async addApplyingInstructions(instructionFiles, context, variables, telemetryEvent, token) {
+        for (const { uri } of instructionFiles) {
+            const parsedFile = await this._parseInstructionsFile(uri, token);
+            if (!parsedFile) {
+                this._logService.trace(`[InstructionsContextComputer] Unable to read: ${uri}`);
+                continue;
+            }
+            const applyTo = parsedFile.header?.applyTo;
+            if (!applyTo) {
+                this._logService.trace(`[InstructionsContextComputer] No 'applyTo' found: ${uri}`);
+                continue;
+            }
+            if (( context.instructions.has(uri))) {
+                this._logService.trace(`[InstructionsContextComputer] Skipping already processed instruction file: ${uri}`);
+                continue;
+            }
+            const match = this._matches(context.files, applyTo);
+            if (match) {
+                this._logService.trace(`[InstructionsContextComputer] Match for ${uri} with ${match.pattern}${match.file ? ` for file ${match.file}` : ''}`);
+                const reason = !match.file ?
+                    ( localize(5975, 'Automatically attached as pattern is **')) :
+                    ( localize(
+                    5976,
+                    'Automatically attached as pattern {0} matches {1}',
+                    applyTo,
+                    this._labelService.getUriLabel(match.file, { relative: true })
+                ));
+                variables.add(toPromptFileVariableEntry(uri, PromptFileVariableKind.Instruction, reason, true));
+                telemetryEvent.applyingInstructionsCount++;
+            }
+            else {
+                this._logService.trace(`[InstructionsContextComputer] No match for ${uri} with ${applyTo}`);
+            }
+        }
+    }
+    _getContext(attachedContext) {
+        const files = ( new ResourceSet());
+        const instructions = ( new ResourceSet());
+        for (const variable of attachedContext.asArray()) {
+            if (isPromptFileVariableEntry(variable)) {
+                instructions.add(variable.value);
+            }
+            else {
+                const uri = IChatRequestVariableEntry.toUri(variable);
+                if (uri) {
+                    files.add(uri);
+                }
+            }
+        }
+        return { files, instructions };
+    }
+    async _addAgentInstructions(variables, telemetryEvent, token) {
+        const useCopilotInstructionsFiles = this._configurationService.getValue(PromptsConfig.USE_COPILOT_INSTRUCTION_FILES);
+        const useAgentMd = this._configurationService.getValue(PromptsConfig.USE_AGENT_MD);
+        if (!useCopilotInstructionsFiles && !useAgentMd) {
+            this._logService.trace(`[InstructionsContextComputer] No agent instructions files added (settings disabled).`);
+            return;
+        }
+        const entries = ( new ChatRequestVariableSet());
+        if (useCopilotInstructionsFiles) {
+            const files = await this._promptsService.listCopilotInstructionsMDs(token);
+            for (const file of files) {
+                entries.add(toPromptFileVariableEntry(file, PromptFileVariableKind.Instruction, ( localize(
+                    5977,
+                    'Automatically attached as setting {0} is enabled',
+                    PromptsConfig.USE_COPILOT_INSTRUCTION_FILES
+                )), true));
+                telemetryEvent.agentInstructionsCount++;
+                this._logService.trace(`[InstructionsContextComputer] copilot-instruction.md files added: ${( file.toString())}`);
+            }
+            await this._addReferencedInstructions(entries, telemetryEvent, token);
+        }
+        if (useAgentMd) {
+            const files = await this._promptsService.listAgentMDs(token, false);
+            for (const file of files) {
+                entries.add(toPromptFileVariableEntry(file, PromptFileVariableKind.Instruction, ( localize(
+                    5978,
+                    'Automatically attached as setting {0} is enabled',
+                    PromptsConfig.USE_AGENT_MD
+                )), true));
+                telemetryEvent.agentInstructionsCount++;
+                this._logService.trace(`[InstructionsContextComputer] AGENTS.md files added: ${( file.toString())}`);
+            }
+        }
+        for (const entry of entries.asArray()) {
+            variables.add(entry);
+        }
+    }
+    _matches(files, applyToPattern) {
+        const patterns = splitGlobAware(applyToPattern, ',');
+        const patterMatches = (pattern) => {
+            pattern = pattern.trim();
+            if (pattern.length === 0) {
+                return undefined;
+            }
+            if (pattern === '**' || pattern === '**/*' || pattern === '*') {
+                return { pattern };
+            }
+            if (!pattern.startsWith('/') && !pattern.startsWith('**/')) {
+                pattern = '**/' + pattern;
+            }
+            for (const file of files) {
+                if (match(pattern, file.path, { ignoreCase: true })) {
+                    return { pattern, file };
+                }
+            }
+            return undefined;
+        };
+        for (const pattern of patterns) {
+            const matchResult = patterMatches(pattern);
+            if (matchResult) {
+                return matchResult;
+            }
+        }
+        return undefined;
+    }
+    _getTool(referenceName) {
+        if (!this._enabledTools) {
+            return undefined;
+        }
+        const tool = this._languageModelToolsService.getToolByName(referenceName);
+        if (tool && this._enabledTools.get(tool)) {
+            return { tool, variable: `#tool:${this._languageModelToolsService.getFullReferenceName(tool)}` };
+        }
+        return undefined;
+    }
+    async _getInstructionsWithPatternsList(instructionFiles, _existingVariables, token) {
+        const readTool = this._getTool('readFile');
+        const runSubagentTool = this._getTool(VSCodeToolReference.runSubagent);
+        const entries = [];
+        if (readTool) {
+            const searchNestedAgentMd = this._configurationService.getValue(PromptsConfig.USE_NESTED_AGENT_MD);
+            const agentsMdPromise = searchNestedAgentMd ? this._promptsService.findAgentMDsInWorkspace(token) : Promise.resolve([]);
+            entries.push('<instructions>');
+            entries.push('Here is a list of instruction files that contain rules for modifying or creating new code.');
+            entries.push('These files are important for ensuring that the code is modified or created correctly.');
+            entries.push('Please make sure to follow the rules specified in these files when working with the codebase.');
+            entries.push(`If the file is not already available as attachment, use the ${readTool.variable} tool to acquire it.`);
+            entries.push('Make sure to acquire the instructions before making any changes to the code.');
+            let hasContent = false;
+            for (const { uri } of instructionFiles) {
+                const parsedFile = await this._parseInstructionsFile(uri, token);
+                if (parsedFile) {
+                    entries.push('<instruction>');
+                    if (parsedFile.header) {
+                        const { description, applyTo } = parsedFile.header;
+                        if (description) {
+                            entries.push(`<description>${description}</description>`);
+                        }
+                        entries.push(`<file>${getFilePath(uri)}</file>`);
+                        if (applyTo) {
+                            entries.push(`<applyTo>${applyTo}</applyTo>`);
+                        }
+                    }
+                    entries.push('</instruction>');
+                    hasContent = true;
+                }
+            }
+            const agentsMdFiles = await agentsMdPromise;
+            for (const uri of agentsMdFiles) {
+                if (uri) {
+                    const folderName = this._labelService.getUriLabel(dirname(uri), { relative: true });
+                    const description = folderName.trim().length === 0 ? ( localize(5979, 'Instructions for the workspace')) : ( localize(5980, 'Instructions for folder \'{0}\'', folderName));
+                    entries.push('<instruction>');
+                    entries.push(`<description>${description}</description>`);
+                    entries.push(`<file>${getFilePath(uri)}</file>`);
+                    entries.push('</instruction>');
+                    hasContent = true;
+                }
+            }
+            if (!hasContent) {
+                entries.length = 0;
+            }
+            else {
+                entries.push('</instructions>', '', '');
+            }
+            const claudeSkills = await this._promptsService.findClaudeSkills(token);
+            if (claudeSkills && claudeSkills.length > 0) {
+                entries.push('<skills>');
+                entries.push('Here is a list of skills that contain domain specific knowledge on a variety of topics.');
+                entries.push('Each skill comes with a description of the topic and a file path that contains the detailed instructions.');
+                entries.push(`When a user asks you to perform a task that falls within the domain of a skill, use the ${readTool.variable} tool to acquire the full instructions from the file URI.`);
+                for (const skill of claudeSkills) {
+                    entries.push('<skill>');
+                    entries.push(`<name>${skill.name}</name>`);
+                    if (skill.description) {
+                        entries.push(`<description>${skill.description}</description>`);
+                    }
+                    entries.push(`<file>${getFilePath(skill.uri)}</file>`);
+                    entries.push('</skill>');
+                }
+                entries.push('</skills>', '', '');
+            }
+        }
+        if (runSubagentTool) {
+            const subagentToolCustomAgents = this._configurationService.getValue(ChatConfiguration.SubagentToolCustomAgents);
+            if (subagentToolCustomAgents) {
+                const agents = await this._promptsService.getCustomAgents(token);
+                if (agents.length > 0) {
+                    entries.push('<agents>');
+                    entries.push('Here is a list of agents that can be used when running a subagent.');
+                    entries.push('Each agent has optionally a description with the agent\'s purpose and expertise. When asked to run a subagent, choose the most appropriate agent from this list.');
+                    entries.push(`Use the ${runSubagentTool.variable} tool with the agent name to run the subagent.`);
+                    for (const agent of agents) {
+                        if (agent.infer === false) {
+                            continue;
+                        }
+                        entries.push('<agent>');
+                        entries.push(`<name>${agent.name}</name>`);
+                        if (agent.description) {
+                            entries.push(`<description>${agent.description}</description>`);
+                        }
+                        if (agent.argumentHint) {
+                            entries.push(`<argumentHint>${agent.argumentHint}</argumentHint>`);
+                        }
+                        entries.push('</agent>');
+                    }
+                    entries.push('</agents>', '', '');
+                }
+            }
+        }
+        if (entries.length === 0) {
+            return undefined;
+        }
+        const content = entries.join('\n');
+        const toolReferences = [];
+        const collectToolReference = (tool) => {
+            if (tool) {
+                let offset = content.indexOf(tool.variable);
+                while (offset >= 0) {
+                    toolReferences.push(toToolVariableEntry(tool.tool, ( new OffsetRange(offset, offset + tool.variable.length))));
+                    offset = content.indexOf(tool.variable, offset + 1);
+                }
+            }
+        };
+        collectToolReference(readTool);
+        collectToolReference(runSubagentTool);
+        return toPromptTextVariableEntry(content, true, toolReferences);
+    }
+    async _addReferencedInstructions(attachedContext, telemetryEvent, token) {
+        const seen = ( new ResourceSet());
+        const todo = [];
+        for (const variable of attachedContext.asArray()) {
+            if (isPromptFileVariableEntry(variable)) {
+                if (!( seen.has(variable.value))) {
+                    todo.push(variable.value);
+                    seen.add(variable.value);
+                }
+            }
+        }
+        let next = todo.pop();
+        while (next) {
+            const result = await this._parseInstructionsFile(next, token);
+            if (result && result.body) {
+                const refsToCheck = [];
+                for (const ref of result.body.fileReferences) {
+                    const url = result.body.resolveFilePath(ref.content);
+                    if (url && !( seen.has(url)) && (isPromptOrInstructionsFile(url) || this._workspaceService.getWorkspaceFolder(url) !== undefined)) {
+                        refsToCheck.push({ resource: url });
+                        seen.add(url);
+                    }
+                }
+                if (refsToCheck.length > 0) {
+                    const stats = await this._fileService.resolveAll(refsToCheck);
+                    for (let i = 0; i < stats.length; i++) {
+                        const stat = stats[i];
+                        const uri = refsToCheck[i].resource;
+                        if (stat.success && stat.stat?.isFile) {
+                            if (isPromptOrInstructionsFile(uri)) {
+                                todo.push(uri);
+                            }
+                            const reason = ( localize(5981, 'Referenced by {0}', basename(next)));
+                            attachedContext.add(toPromptFileVariableEntry(uri, PromptFileVariableKind.InstructionReference, reason, true));
+                            telemetryEvent.referencedInstructionsCount++;
+                            this._logService.trace(`[InstructionsContextComputer] ${( uri.toString())} added, referenced by ${( next.toString())}`);
+                        }
+                    }
+                }
+            }
+            next = todo.pop();
+        }
+    }
+};
+ComputeAutomaticInstructions = ( __decorate([
+    ( __param(1, IPromptsService)),
+    ( __param(2, ILogService)),
+    ( __param(3, ILabelService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, IWorkspaceContextService)),
+    ( __param(6, IFileService)),
+    ( __param(7, ITelemetryService)),
+    ( __param(8, ILanguageModelToolsService))
+], ComputeAutomaticInstructions));
+function getFilePath(uri) {
+    if (uri.scheme === Schemas.file || uri.scheme === Schemas.vscodeRemote) {
+        return uri.fsPath;
+    }
+    return ( uri.toString());
+}
+
+export { ComputeAutomaticInstructions, newInstructionsCollectionEvent };

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

@@ -0,0 +1,171 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Emitter } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+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 { ICodeEditorService } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/codeEditorService.service";
+import { IPosition, Position } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/position";
+import { IRange } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
+import { ISelection } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/selection";
+import { IEditorContribution } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/editorCommon";
+import { TextEdit } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages";
+import { IEditorWorkerService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/editorWorker.service";
+import { IMarkerDecorationsService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/markerDecorations.service";
+import { EditSuggestionId } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/textModelEditSource";
+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 { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { IInstantiationService, ServicesAccessor } 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 { ISharedWebContentExtractorService } from "@codingame/monaco-vscode-api/vscode/vs/platform/webContentExtractor/common/webContentExtractor.service";
+import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
+import { IChatAttachmentResolveService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatAttachmentResolveService.service";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service";
+import { IChatRequestVariableEntry } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatVariableEntries";
+import { ILanguageModelChatSelector } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels";
+import { ILanguageModelsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service";
+import { INotebookEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/services/notebookEditorService.service";
+import { ICellEditOperation } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon";
+import { HunkInformation, Session } from "./inlineChatSession.js";
+import { IInlineChatSessionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSessionService.service";
+import { EditorBasedInlineChatWidget } from "./inlineChatWidget.js";
+export declare enum State {
+    CREATE_SESSION = "CREATE_SESSION",
+    INIT_UI = "INIT_UI",
+    WAIT_FOR_INPUT = "WAIT_FOR_INPUT",
+    SHOW_REQUEST = "SHOW_REQUEST",
+    PAUSE = "PAUSE",
+    CANCEL = "CANCEL",
+    ACCEPT = "DONE"
+}
+export declare abstract class InlineChatRunOptions {
+    initialSelection?: ISelection;
+    initialRange?: IRange;
+    message?: string;
+    attachments?: URI[];
+    autoSend?: boolean;
+    existingSession?: Session;
+    position?: IPosition;
+    modelSelector?: ILanguageModelChatSelector;
+    blockOnResponse?: boolean;
+    static isInlineChatRunOptions(options: unknown): options is InlineChatRunOptions;
+}
+export declare class InlineChatController implements IEditorContribution {
+    private readonly _notebookEditorService;
+    static ID: string;
+    static get(editor: ICodeEditor): InlineChatController | null;
+    private readonly _delegate;
+    constructor(editor: ICodeEditor, configurationService: IConfigurationService, _notebookEditorService: INotebookEditorService);
+    dispose(): void;
+    get isActive(): boolean;
+    run(arg?: InlineChatRunOptions): Promise<boolean>;
+    focus(): void;
+    get widget(): EditorBasedInlineChatWidget;
+    getWidgetPosition(): Position | undefined;
+    acceptSession(): void | Promise<void>;
+}
+/**
+ * @deprecated
+ */
+export declare class InlineChatController1 implements IEditorContribution {
+    private readonly _editor;
+    private readonly _instaService;
+    private readonly _inlineChatSessionService;
+    private readonly _editorWorkerService;
+    private readonly _logService;
+    private readonly _configurationService;
+    private readonly _dialogService;
+    private readonly _chatService;
+    private readonly _editorService;
+    private readonly _webContentExtractorService;
+    private readonly _fileService;
+    private readonly _chatAttachmentResolveService;
+    static get(editor: ICodeEditor): InlineChatController1 | null;
+    private _isDisposed;
+    private readonly _store;
+    private readonly _ui;
+    private readonly _ctxVisible;
+    private readonly _ctxEditing;
+    private readonly _ctxResponseType;
+    private readonly _ctxRequestInProgress;
+    private readonly _ctxResponse;
+    private readonly _messages;
+    protected readonly _onDidEnterState: Emitter<State>;
+    get chatWidget(): import("../../chat/browser/chatWidget.js").ChatWidget;
+    private readonly _sessionStore;
+    private readonly _stashedSession;
+    private _delegateSession?;
+    private _session?;
+    private _strategy?;
+    constructor(_editor: ICodeEditor, _instaService: IInstantiationService, _inlineChatSessionService: IInlineChatSessionService, _editorWorkerService: IEditorWorkerService, _logService: ILogService, _configurationService: IConfigurationService, _dialogService: IDialogService, contextKeyService: IContextKeyService, _chatService: IChatService, _editorService: IEditorService, notebookEditorService: INotebookEditorService, _webContentExtractorService: ISharedWebContentExtractorService, _fileService: IFileService, _chatAttachmentResolveService: IChatAttachmentResolveService);
+    dispose(): void;
+    private _log;
+    get widget(): EditorBasedInlineChatWidget;
+    getId(): string;
+    getWidgetPosition(): Position | undefined;
+    private _currentRun?;
+    run(options?: InlineChatRunOptions | undefined): Promise<boolean>;
+    protected _nextState(state: State, options: InlineChatRunOptions): Promise<void>;
+    private [State.CREATE_SESSION];
+    private [State.INIT_UI];
+    private [State.WAIT_FOR_INPUT];
+    private [State.SHOW_REQUEST];
+    private [State.PAUSE];
+    private [State.ACCEPT];
+    private [State.CANCEL];
+    private _showWidget;
+    private _resetWidget;
+    private _updateCtxResponseType;
+    private _createChatTextEditGroupState;
+    private _makeChanges;
+    private _getMetadata;
+    private _updatePlaceholder;
+    private _updateInput;
+    arrowOut(up: boolean): void;
+    focus(): void;
+    viewInChat(): Promise<void>;
+    acceptSession(): void;
+    acceptHunk(hunkInfo?: HunkInformation): void | undefined;
+    discardHunk(hunkInfo?: HunkInformation): void | undefined;
+    toggleDiff(hunkInfo?: HunkInformation): void | undefined;
+    moveHunk(next: boolean): void;
+    cancelSession(): Promise<void>;
+    reportIssue(): void;
+    unstashLastSession(): Session | undefined;
+    joinCurrentRun(): Promise<void> | undefined;
+    get isActive(): boolean;
+    createImageAttachment(attachment: URI): Promise<IChatRequestVariableEntry | undefined>;
+}
+export declare class InlineChatController2 implements IEditorContribution {
+    private readonly _editor;
+    private readonly _instaService;
+    private readonly _notebookEditorService;
+    private readonly _inlineChatSessionService;
+    private readonly _webContentExtractorService;
+    private readonly _fileService;
+    private readonly _chatAttachmentResolveService;
+    private readonly _editorService;
+    private readonly _markerDecorationsService;
+    private readonly _languageModelService;
+    static readonly ID = "editor.contrib.inlineChatController2";
+    static get(editor: ICodeEditor): InlineChatController2 | undefined;
+    private readonly _store;
+    private readonly _isActiveController;
+    private readonly _zone;
+    private readonly _currentSession;
+    get widget(): EditorBasedInlineChatWidget;
+    get isActive(): boolean;
+    constructor(_editor: ICodeEditor, _instaService: IInstantiationService, _notebookEditorService: INotebookEditorService, _inlineChatSessionService: IInlineChatSessionService, codeEditorService: ICodeEditorService, contextKeyService: IContextKeyService, _webContentExtractorService: ISharedWebContentExtractorService, _fileService: IFileService, _chatAttachmentResolveService: IChatAttachmentResolveService, _editorService: IEditorService, _markerDecorationsService: IMarkerDecorationsService, _languageModelService: ILanguageModelsService, chatService: IChatService);
+    dispose(): void;
+    getWidgetPosition(): Position | undefined;
+    focus(): void;
+    run(arg?: InlineChatRunOptions): Promise<boolean>;
+    acceptSession(): Promise<void>;
+    rejectSession(): Promise<void>;
+    createImageAttachment(attachment: URI): Promise<IChatRequestVariableEntry | undefined>;
+}
+export declare function reviewEdits(accessor: ServicesAccessor, editor: ICodeEditor, stream: AsyncIterable<TextEdit[]>, token: CancellationToken, applyCodeBlockSuggestionId: EditSuggestionId | undefined): Promise<boolean>;
+export declare function reviewNotebookEdits(accessor: ServicesAccessor, uri: URI, stream: AsyncIterable<[
+    URI,
+    TextEdit[]
+] | ICellEditOperation[]>, token: CancellationToken): Promise<boolean>;