@codingame/monaco-vscode-xterm-addons-common 24.1.0

package/vscode/src/vs/workbench/contrib/chat/browser/chatPasteProviders.js

@@ -0,0 +1,379 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { VSDataTransfer, createStringDataTransferItem } from '@codingame/monaco-vscode-api/vscode/vs/base/common/dataTransfer';
+import { HierarchicalKind } from '@codingame/monaco-vscode-api/vscode/vs/base/common/hierarchicalKind';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { revive } from '@codingame/monaco-vscode-api/vscode/vs/base/common/marshalling';
+import { Mimes } from '@codingame/monaco-vscode-api/vscode/vs/base/common/mime';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { joinPath, basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { ILanguageFeaturesService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/languageFeatures.service';
+import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.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 { isProposedApiEnabled } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions';
+import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
+import { IChatVariablesService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatVariables.service';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { ChatDynamicVariableModel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/contrib/chatDynamicVariables';
+import { cleanupOldImages, createFileForMedia, resizeImage, imageToHash } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/imageUtils';
+
+var CopyAttachmentsProvider_1;
+const COPY_MIME_TYPES = 'application/vnd.code.additional-editor-data';
+let PasteImageProvider = class PasteImageProvider {
+    constructor(chatWidgetService, extensionService, fileService, environmentService, logService) {
+        this.chatWidgetService = chatWidgetService;
+        this.extensionService = extensionService;
+        this.fileService = fileService;
+        this.environmentService = environmentService;
+        this.logService = logService;
+        this.kind = ( new HierarchicalKind('chat.attach.image'));
+        this.providedPasteEditKinds = [this.kind];
+        this.copyMimeTypes = [];
+        this.pasteMimeTypes = ['image/*'];
+        this.imagesFolder = joinPath(this.environmentService.workspaceStorageHome, 'vscode-chat-images');
+        cleanupOldImages(this.fileService, this.logService, this.imagesFolder);
+    }
+    async provideDocumentPasteEdits(model, ranges, dataTransfer, context, token) {
+        if (!( this.extensionService.extensions.some(ext => isProposedApiEnabled(ext, 'chatReferenceBinaryData')))) {
+            return;
+        }
+        const supportedMimeTypes = [
+            'image/png',
+            'image/jpeg',
+            'image/jpg',
+            'image/bmp',
+            'image/gif',
+            'image/tiff'
+        ];
+        let mimeType;
+        let imageItem;
+        for (const type of supportedMimeTypes) {
+            imageItem = dataTransfer.get(type);
+            if (imageItem) {
+                mimeType = type;
+                break;
+            }
+        }
+        if (!imageItem || !mimeType) {
+            return;
+        }
+        const currClipboard = await imageItem.asFile()?.data();
+        if (token.isCancellationRequested || !currClipboard) {
+            return;
+        }
+        const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
+        if (!widget) {
+            return;
+        }
+        const attachedVariables = widget.attachmentModel.attachments;
+        const displayName = ( localize(5457, 'Pasted Image'));
+        let tempDisplayName = displayName;
+        for (let appendValue = 2; ( attachedVariables.some(attachment => attachment.name === tempDisplayName)); appendValue++) {
+            tempDisplayName = `${displayName} ${appendValue}`;
+        }
+        const fileReference = await createFileForMedia(this.fileService, this.imagesFolder, currClipboard, mimeType);
+        if (token.isCancellationRequested || !fileReference) {
+            return;
+        }
+        const scaledImageData = await resizeImage(currClipboard);
+        if (token.isCancellationRequested || !scaledImageData) {
+            return;
+        }
+        const scaledImageContext = await getImageAttachContext(scaledImageData, mimeType, token, tempDisplayName, fileReference);
+        if (token.isCancellationRequested || !scaledImageContext) {
+            return;
+        }
+        const currentContextIds = widget.attachmentModel.getAttachmentIDs();
+        if (( currentContextIds.has(scaledImageContext.id))) {
+            return;
+        }
+        const edit = createCustomPasteEdit(model, [scaledImageContext], mimeType, this.kind, ( localize(5458, 'Pasted Image Attachment')), this.chatWidgetService);
+        return createEditSession(edit);
+    }
+};
+PasteImageProvider = ( __decorate([
+    ( __param(2, IFileService)),
+    ( __param(3, IEnvironmentService)),
+    ( __param(4, ILogService))
+], PasteImageProvider));
+async function getImageAttachContext(data, mimeType, token, displayName, resource) {
+    const imageHash = await imageToHash(data);
+    if (token.isCancellationRequested) {
+        return undefined;
+    }
+    return {
+        kind: 'image',
+        value: data,
+        id: imageHash,
+        name: displayName,
+        icon: Codicon.fileMedia,
+        mimeType,
+        isPasted: true,
+        references: [{ reference: resource, kind: 'reference' }]
+    };
+}
+function isImage(array) {
+    if (array.length < 4) {
+        return false;
+    }
+    const identifier = {
+        png: [0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A],
+        jpeg: [0xFF, 0xD8, 0xFF],
+        bmp: [0x42, 0x4D],
+        gif: [0x47, 0x49, 0x46, 0x38],
+        tiff: [0x49, 0x49, 0x2A, 0x00]
+    };
+    return ( ( Object.values(identifier)).some((signature) => signature.every((byte, index) => array[index] === byte)));
+}
+class CopyTextProvider {
+    constructor() {
+        this.providedPasteEditKinds = [];
+        this.copyMimeTypes = [COPY_MIME_TYPES];
+        this.pasteMimeTypes = [];
+    }
+    async prepareDocumentPaste(model, ranges, dataTransfer, token) {
+        if (model.uri.scheme === Schemas.vscodeChatInput) {
+            return;
+        }
+        const customDataTransfer = ( new VSDataTransfer());
+        const data = { range: ranges[0], uri: model.uri.toJSON() };
+        customDataTransfer.append(COPY_MIME_TYPES, createStringDataTransferItem(JSON.stringify(data)));
+        return customDataTransfer;
+    }
+}
+let CopyAttachmentsProvider = class CopyAttachmentsProvider {
+    static { CopyAttachmentsProvider_1 = this; }
+    static { this.ATTACHMENT_MIME_TYPE = 'application/vnd.chat.attachment+json'; }
+    constructor(chatWidgetService, chatVariableService) {
+        this.chatWidgetService = chatWidgetService;
+        this.chatVariableService = chatVariableService;
+        this.kind = ( new HierarchicalKind('chat.attach.attachments'));
+        this.providedPasteEditKinds = [this.kind];
+        this.copyMimeTypes = [CopyAttachmentsProvider_1.ATTACHMENT_MIME_TYPE];
+        this.pasteMimeTypes = [CopyAttachmentsProvider_1.ATTACHMENT_MIME_TYPE];
+    }
+    async prepareDocumentPaste(model, _ranges, _dataTransfer, _token) {
+        const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
+        if (!widget || !widget.viewModel) {
+            return undefined;
+        }
+        const attachments = widget.attachmentModel.attachments;
+        const dynamicVariables = this.chatVariableService.getDynamicVariables(widget.viewModel.sessionResource);
+        if (attachments.length === 0 && dynamicVariables.length === 0) {
+            return undefined;
+        }
+        const result = ( new VSDataTransfer());
+        result.append(CopyAttachmentsProvider_1.ATTACHMENT_MIME_TYPE, createStringDataTransferItem(JSON.stringify({ attachments, dynamicVariables })));
+        return result;
+    }
+    async provideDocumentPasteEdits(model, _ranges, dataTransfer, _context, token) {
+        const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
+        if (!widget || !widget.viewModel) {
+            return undefined;
+        }
+        const chatDynamicVariable = widget.getContrib(ChatDynamicVariableModel.ID);
+        if (!chatDynamicVariable) {
+            return undefined;
+        }
+        const text = dataTransfer.get(Mimes.text);
+        const data = dataTransfer.get(CopyAttachmentsProvider_1.ATTACHMENT_MIME_TYPE);
+        const rawData = await data?.asString();
+        const textdata = await text?.asString();
+        if (textdata === undefined || rawData === undefined) {
+            return;
+        }
+        if (token.isCancellationRequested) {
+            return;
+        }
+        let pastedData;
+        try {
+            pastedData = revive(JSON.parse(rawData));
+        }
+        catch {
+        }
+        if (!Array.isArray(pastedData?.attachments) && !Array.isArray(pastedData?.dynamicVariables)) {
+            return;
+        }
+        const edit = {
+            insertText: textdata,
+            title: ( localize(5459, 'Insert Prompt & Attachments')),
+            kind: this.kind,
+            handledMimeType: CopyAttachmentsProvider_1.ATTACHMENT_MIME_TYPE,
+            additionalEdit: {
+                edits: []
+            }
+        };
+        edit.additionalEdit?.edits.push({
+            resource: model.uri,
+            redo: () => {
+                widget.attachmentModel.addContext(...pastedData.attachments);
+                for (const dynamicVariable of pastedData.dynamicVariables) {
+                    chatDynamicVariable?.addReference(dynamicVariable);
+                }
+                widget.refreshParsedInput();
+            },
+            undo: () => {
+                widget.attachmentModel.delete(...( pastedData.attachments.map(c => c.id)));
+                widget.refreshParsedInput();
+            }
+        });
+        return createEditSession(edit);
+    }
+};
+CopyAttachmentsProvider = CopyAttachmentsProvider_1 = ( __decorate([
+    ( __param(0, IChatWidgetService)),
+    ( __param(1, IChatVariablesService))
+], CopyAttachmentsProvider));
+class PasteTextProvider {
+    constructor(chatWidgetService, modelService) {
+        this.chatWidgetService = chatWidgetService;
+        this.modelService = modelService;
+        this.kind = ( new HierarchicalKind('chat.attach.text'));
+        this.providedPasteEditKinds = [this.kind];
+        this.copyMimeTypes = [];
+        this.pasteMimeTypes = [COPY_MIME_TYPES];
+    }
+    async provideDocumentPasteEdits(model, ranges, dataTransfer, _context, token) {
+        if (model.uri.scheme !== Schemas.vscodeChatInput) {
+            return;
+        }
+        const text = dataTransfer.get(Mimes.text);
+        const editorData = dataTransfer.get('vscode-editor-data');
+        const additionalEditorData = dataTransfer.get(COPY_MIME_TYPES);
+        if (!editorData || !text || !additionalEditorData) {
+            return;
+        }
+        const textdata = await text.asString();
+        const metadata = JSON.parse(await editorData.asString());
+        const additionalData = JSON.parse(await additionalEditorData.asString());
+        const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
+        if (!widget) {
+            return;
+        }
+        const start = additionalData.range.startLineNumber;
+        const end = additionalData.range.endLineNumber;
+        if (start === end) {
+            const textModel = this.modelService.getModel(URI.revive(additionalData.uri));
+            if (!textModel) {
+                return;
+            }
+            const lineContent = textModel.getLineContent(start);
+            if (lineContent !== textdata) {
+                return;
+            }
+        }
+        const copiedContext = getCopiedContext(textdata, URI.revive(additionalData.uri), metadata.mode, additionalData.range);
+        if (token.isCancellationRequested || !copiedContext) {
+            return;
+        }
+        const currentContextIds = widget.attachmentModel.getAttachmentIDs();
+        if (( currentContextIds.has(copiedContext.id))) {
+            return;
+        }
+        const edit = createCustomPasteEdit(model, [copiedContext], Mimes.text, this.kind, ( localize(5460, 'Pasted Code Attachment')), this.chatWidgetService);
+        edit.yieldTo = [{ kind: HierarchicalKind.Empty.append('text', 'plain') }];
+        return createEditSession(edit);
+    }
+}
+function getCopiedContext(code, file, language, range) {
+    const fileName = basename(file);
+    const start = range.startLineNumber;
+    const end = range.endLineNumber;
+    const resultText = `Copied Selection of Code: \n\n\n From the file: ${fileName} From lines ${start} to ${end} \n \`\`\`${code}\`\`\``;
+    const pastedLines = start === end ? ( localize(5461, '1 line')) : ( localize(5462, '{0} lines', end + 1 - start));
+    return {
+        kind: 'paste',
+        value: resultText,
+        id: `${fileName}${start}${end}${range.startColumn}${range.endColumn}`,
+        name: `${fileName} ${pastedLines}`,
+        icon: Codicon.code,
+        pastedLines,
+        language,
+        fileName: ( file.toString()),
+        copiedFrom: {
+            uri: file,
+            range
+        },
+        code,
+        references: [{
+                reference: file,
+                kind: 'reference'
+            }]
+    };
+}
+function createCustomPasteEdit(model, context, handledMimeType, kind, title, chatWidgetService) {
+    const label = context.length === 1
+        ? context[0].name
+        : ( localize(5463, '{0} and {1} more', context[0].name, context.length - 1));
+    const customEdit = {
+        resource: model.uri,
+        variable: context,
+        undo: () => {
+            const widget = chatWidgetService.getWidgetByInputUri(model.uri);
+            if (!widget) {
+                throw ( new Error('No widget found for undo'));
+            }
+            widget.attachmentModel.delete(...( context.map(c => c.id)));
+        },
+        redo: () => {
+            const widget = chatWidgetService.getWidgetByInputUri(model.uri);
+            if (!widget) {
+                throw ( new Error('No widget found for redo'));
+            }
+            widget.attachmentModel.addContext(...context);
+        },
+        metadata: {
+            needsConfirmation: false,
+            label
+        }
+    };
+    return {
+        insertText: '',
+        title,
+        kind,
+        handledMimeType,
+        additionalEdit: {
+            edits: [customEdit],
+        }
+    };
+}
+function createEditSession(edit) {
+    return {
+        edits: [edit],
+        dispose: () => { },
+    };
+}
+let ChatPasteProvidersFeature = class ChatPasteProvidersFeature extends Disposable {
+    constructor(instaService, languageFeaturesService, chatWidgetService, extensionService, fileService, modelService, environmentService, logService) {
+        super();
+        this._register(languageFeaturesService.documentPasteEditProvider.register({ scheme: Schemas.vscodeChatInput, pattern: '*', hasAccessToAllModels: true }, instaService.createInstance(CopyAttachmentsProvider)));
+        this._register(languageFeaturesService.documentPasteEditProvider.register({ scheme: Schemas.vscodeChatInput, pattern: '*', hasAccessToAllModels: true }, ( new PasteImageProvider(
+            chatWidgetService,
+            extensionService,
+            fileService,
+            environmentService,
+            logService
+        ))));
+        this._register(languageFeaturesService.documentPasteEditProvider.register({ scheme: Schemas.vscodeChatInput, pattern: '*', hasAccessToAllModels: true }, ( new PasteTextProvider(chatWidgetService, modelService))));
+        this._register(languageFeaturesService.documentPasteEditProvider.register('*', ( new CopyTextProvider())));
+        this._register(languageFeaturesService.documentPasteEditProvider.register('*', ( new CopyTextProvider())));
+    }
+};
+ChatPasteProvidersFeature = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, ILanguageFeaturesService)),
+    ( __param(2, IChatWidgetService)),
+    ( __param(3, IExtensionService)),
+    ( __param(4, IFileService)),
+    ( __param(5, IModelService)),
+    ( __param(6, IEnvironmentService)),
+    ( __param(7, ILogService))
+], ChatPasteProvidersFeature));
+
+export { ChatPasteProvidersFeature, CopyTextProvider, PasteImageProvider, PasteTextProvider, isImage };

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

@@ -0,0 +1,17 @@
+import { IChatWidget } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat";
+import { IPromptsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service";
+import { IChatContextPickerItem, IChatContextPicker } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatContextPickService";
+/**
+ * Helper to register the `Attach Prompt` action.
+ */
+export declare function registerAttachPromptActions(): void;
+export declare class ChatInstructionsPickerPick implements IChatContextPickerItem {
+    private readonly promptsService;
+    readonly type = "pickerPick";
+    readonly label: string;
+    readonly icon: import("@codingame/monaco-vscode-api/vscode/vs/base/common/themables").ThemeIcon;
+    readonly commandId = "workbench.action.chat.attach.instructions";
+    constructor(promptsService: IPromptsService);
+    isEnabled(widget: IChatWidget): Promise<boolean> | boolean;
+    asPicker(): IChatContextPicker;
+}

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

@@ -0,0 +1,101 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { ChatViewId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat';
+import { CHAT_CONFIG_MENU_ID, CHAT_CATEGORY } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
+import { localize2, localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
+import { IPromptsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service';
+import { PromptFilePickers } from './pickers/promptFilePickers.js';
+import { Action2, registerAction2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { getCleanPromptName } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/config/promptFileLocations';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { PromptsType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import { compare } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import { toPromptFileVariableEntry, PromptFileVariableKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatVariableEntries';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service';
+
+const ATTACH_INSTRUCTIONS_ACTION_ID = 'workbench.action.chat.attach.instructions';
+const CONFIGURE_INSTRUCTIONS_ACTION_ID = 'workbench.action.chat.configure.instructions';
+class ManageInstructionsFilesAction extends Action2 {
+    constructor() {
+        super({
+            id: CONFIGURE_INSTRUCTIONS_ACTION_ID,
+            title: ( localize2(5750, "Configure Instructions...")),
+            shortTitle: ( localize2(5751, "Chat Instructions")),
+            icon: Codicon.bookmark,
+            f1: true,
+            precondition: ChatContextKeys.enabled,
+            category: CHAT_CATEGORY,
+            menu: {
+                id: CHAT_CONFIG_MENU_ID,
+                when: ( ContextKeyExpr.and(ChatContextKeys.enabled, ( ContextKeyExpr.equals('view', ChatViewId)))),
+                order: 10,
+                group: '1_level'
+            }
+        });
+    }
+    async run(accessor) {
+        const openerService = accessor.get(IOpenerService);
+        const instaService = accessor.get(IInstantiationService);
+        const pickers = instaService.createInstance(PromptFilePickers);
+        const placeholder = ( localize(5752, 'Select the instructions file to open'));
+        const result = await pickers.selectPromptFile({ placeholder, type: PromptsType.instructions, optionEdit: false });
+        if (result !== undefined) {
+            await openerService.open(result.promptFile);
+        }
+    }
+}
+function registerAttachPromptActions() {
+    registerAction2(ManageInstructionsFilesAction);
+}
+let ChatInstructionsPickerPick = class ChatInstructionsPickerPick {
+    constructor(promptsService) {
+        this.promptsService = promptsService;
+        this.type = 'pickerPick';
+        this.label = ( localize(5753, 'Instructions...'));
+        this.icon = Codicon.bookmark;
+        this.commandId = ATTACH_INSTRUCTIONS_ACTION_ID;
+    }
+    isEnabled(widget) {
+        return !!widget.attachmentCapabilities.supportsInstructionAttachments;
+    }
+    asPicker() {
+        const picks = this.promptsService.listPromptFiles(PromptsType.instructions, CancellationToken.None).then(value => {
+            const result = [];
+            value = value.slice(0).sort((a, b) => compare(a.storage, b.storage));
+            let storageType;
+            for (const promptsPath of value) {
+                if (storageType !== promptsPath.storage) {
+                    storageType = promptsPath.storage;
+                    result.push({
+                        type: 'separator',
+                        label: this.promptsService.getPromptLocationLabel(promptsPath)
+                    });
+                }
+                result.push({
+                    label: promptsPath.name ?? getCleanPromptName(promptsPath.uri),
+                    asAttachment: () => {
+                        return toPromptFileVariableEntry(promptsPath.uri, PromptFileVariableKind.Instruction);
+                    }
+                });
+            }
+            return result;
+        });
+        return {
+            placeholder: ( localize(5754, 'Select instructions files to attach')),
+            picks,
+            configure: {
+                label: ( localize(5755, 'Configure Instructions...')),
+                commandId: CONFIGURE_INSTRUCTIONS_ACTION_ID
+            }
+        };
+    }
+};
+ChatInstructionsPickerPick = ( __decorate([
+    ( __param(0, IPromptsService))
+], ChatInstructionsPickerPick));
+
+export { ChatInstructionsPickerPick, registerAttachPromptActions };

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

@@ -0,0 +1,4 @@
+export declare const NEW_PROMPT_COMMAND_ID = "workbench.command.new.prompt";
+export declare const NEW_INSTRUCTIONS_COMMAND_ID = "workbench.command.new.instructions";
+export declare const NEW_AGENT_COMMAND_ID = "workbench.command.new.agent";
+export declare function registerNewPromptFileActions(): void;